Vida es Belleza: funcion .length

Mostrando entradas con la etiqueta funcion .length. Mostrar todas las entradas

viernes, 6 de diciembre de 2013

Metodos de la clase String en java – Curso – Texas

Mencionemos algunos métodos de la clase String y su funcionamiento.

El siguiente cuadro fue extraído de la documentación de java en el sitio web oracle.com.

Versión Ingles:

Method Summary
`char`	`charAt(intindex)` Returns the character at the specified index.
`int`	`compareTo(Objecto)` Compares this String to another Object.
`int`	`compareTo(StringanotherString)` Compares two strings lexicographically.
`int`	`compareToIgnoreCase(Stringstr)` Compares two strings lexicographically, ignoring case differences.
`String`	`concat(Stringstr)` Concatenates the specified string to the end of this string.
`boolean`	`contentEquals(StringBuffersb)` Returns`true`if and only if this`String`represents the same sequence of characters as the specified`StringBuffer`.
`staticString`	`copyValueOf(char[]data)` Returns a String that represents the character sequence in the array specified.
`staticString`	`copyValueOf(char[]data, intoffset, intcount)` Returns a String that represents the character sequence in the array specified.
`boolean`	`endsWith(Stringsuffix)` Tests if this string ends with the specified suffix.
`boolean`	`equals(ObjectanObject)` Compares this string to the specified object.
`boolean`	`equalsIgnoreCase(StringanotherString)` Compares this`String`to another`String`, ignoring case considerations.
`byte[]`	`getBytes()` Encodes this`String`into a sequence of bytes using the platform's default charset, storing the result into a new byte array.
`byte[]`	`getBytes(StringcharsetName)` Encodes this`String`into a sequence of bytes using the named charset, storing the result into a new byte array.
`void`	`getChars(intsrcBegin, intsrcEnd, char[]dst, intdstBegin)` Copies characters from this string into the destination character array.
`int`	`hashCode()` Returns a hash code for this string.
`int`	`indexOf(intch)` Returns the index within this string of the first occurrence of the specified character.
`int`	`indexOf(intch, intfromIndex)` Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index.
`int`	`indexOf(Stringstr)` Returns the index within this string of the first occurrence of the specified substring.
`int`	`indexOf(Stringstr, intfromIndex)` Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.
`String`	`intern()` Returns a canonical representation for the string object.
`int`	`lastIndexOf(intch)` Returns the index within this string of the last occurrence of the specified character.
`int`	`lastIndexOf(intch, intfromIndex)` Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index.
`int`	`lastIndexOf(Stringstr)` Returns the index within this string of the rightmost occurrence of the specified substring.
`int`	`lastIndexOf(Stringstr, intfromIndex)` Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.
`int`	`length()` Returns the length of this string.
`boolean`	`regionMatches(booleanignoreCase, inttoffset,Stringother, intooffset, intlen)` Tests if two string regions are equal.
`boolean`	`regionMatches(inttoffset,Stringother, intooffset, intlen)` Tests if two string regions are equal.
`String`	`replace(charoldChar, charnewChar)` Returns a new string resulting from replacing all occurrences of`oldChar`in this string with`newChar`.
`boolean`	`startsWith(Stringprefix)` Tests if this string starts with the specified prefix.
`boolean`	`startsWith(Stringprefix, inttoffset)` Tests if this string starts with the specified prefix beginning a specified index.
`CharSequence`	`subSequence(intbeginIndex, intendIndex)` Returns a new character sequence that is a subsequence of this sequence.
`String`	`substring(intbeginIndex)` Returns a new string that is a substring of this string.
`String`	`substring(intbeginIndex, intendIndex)` Returns a new string that is a substring of this string.
`char[]`	`toCharArray()` Converts this string to a new character array.
`String`	`toLowerCase()` Converts all of the characters in this`String`to lower case using the rules of the default locale.
`String`	`toLowerCase(Localelocale)` Converts all of the characters in this`String`to lower case using the rules of the given`Locale`.
`String`	`toString()` This object (which is already a string!) is itself returned.
`String`	`toUpperCase()` Converts all of the characters in this`String`to upper case using the rules of the default locale.
`String`	`toUpperCase(Localelocale)` Converts all of the characters in this`String`to upper case using the rules of the given`Locale`.
`String`	`trim()` Returns a copy of the string, with leading and trailing whitespace omitted.
`staticString`	`valueOf(booleanb)` Returns the string representation of the`boolean`argument.
`staticString`	`valueOf(charc)` Returns the string representation of the`char`argument.
`staticString`	`valueOf(char[]data)` Returns the string representation of the`char`array argument.
`staticString`	`valueOf(char[]data, intoffset, intcount)` Returns the string representation of a specific subarray of the`char`array argument.
`staticString`	`valueOf(doubled)` Returns the string representation of the`double`argument.
`staticString`	`valueOf(floatf)` Returns the string representation of the`float`argument.
`staticString`	`valueOf(inti)` Returns the string representation of the`int`argument.
`staticString`	`valueOf(longl)` Returns the string representation of the`long`argument.
`staticString`	`valueOf(Objectobj)` Returns the string representation of the`Object`argument.

Versión Español:

Resumen Método
`char`	`charAt(int index)` Devuelve el carácter en el índice especificado.
`int`	`compareTo(Objecto)` Compara esta string a otro objeto.
`int`	`compareTo(CadenaanotherString)` Compara dos cadenas lexicográfica.
`int`	`compareToIgnoreCase(Cadenastr)` Compara dos cadenas lexicográfica, haciendo caso omiso de las diferencias de caso.
String	`concat(Cadenastr)` Concatena la cadena especificada al final de esta cadena.
`boolean`	`contentEquals(StringBuffersb)` Devuelve`verdadero`si y sólo si esta`string`representa la misma secuencia de caracteres como la especificada`StringBuffer`.
static String	`copyValueOf(char [] data)` Devuelve una cadena que representa la secuencia de caracteres en la matriz especificada.
static String	`copyValueOf(char [] datos, int desplazamiento, int count)` Devuelve una cadena que representa la secuencia de caracteres en la matriz especificada.
`boolean`	`endsWith(Cadenasufijo)` Comprueba si la cadena termina con el sufijo especificado.
`boolean`	`equals(ObjectunObjeto)` Compara esta cadena para el objeto especificado.
`boolean`	`equalsIgnoreCase(CadenaanotherString)` Compara esta stringa otra`string`, haciendo caso omiso de las consideraciones del caso.
`byte []`	`getBytes()` Codifica la`string`en una secuencia de bytes utilizando charset por defecto de la plataforma, almacenando el resultado en una nueva matriz de bytes.
`byte []`	`getBytes(CadenacharsetName)` Codifica la`string`en una secuencia de bytes mediante el juego de caracteres con nombre, almacenando el resultado en una nueva matriz de bytes.
`vacío`	`getChars(int srcBegin, int srcEnd, char [] dst, int dstBegin)` Copias caracteres de esta cadena en la matriz de caracteres de destino.
`int`	`hashCode()` Devuelve un código hash para esta cadena.
`int`	`indexOf(int ch)` Devuelve el índice dentro de esta cadena de la primera aparición del carácter especificado.
`int`	`indexOf(int ch, int fromIndex)` Devuelve el índice dentro de esta cadena de la primera aparición del carácter especificado, comenzando la búsqueda en el índice especificado.
`int`	`indexOf(Cadenastr)` Devuelve el índice dentro de esta serie de la primera ocurrencia de la subcadena especificada.
`int`	`indexOf(Cadenastr, int fromIndex)` Devuelve el índice dentro de esta serie de la primera ocurrencia de la subcadena especificada, comenzando en el índice especificado.
`String`	`intern()` Devuelve una representación canónica para el objeto de cadena.
`int`	`lastIndexOf(int ch)` Devuelve el índice dentro de esta cadena de la última aparición del carácter especificado.
`int`	`lastIndexOf(int ch, int fromIndex)` Devuelve el índice dentro de esta cadena de la última aparición del carácter especificado, buscando hacia atrás, empezando por el índice especificado.
`int`	`lastIndexOf(Cadenastr)` Devuelve el índice dentro de esta cadena de la ocurrencia más a la derecha de la subcadena especificada.
`int`	`lastIndexOf(Cadenastr, int fromIndex)` Devuelve el índice dentro de esta cadena de la última aparición de la subcadena especificada, buscando hacia atrás, empezando por el índice especificado.
`int`	`length()` Devuelve la longitud de esta cadena.
`boolean`	`regionMatches(ignoreCase boolean, int Tdesplazamiento,string otra, int ooffset, int len)` Comprueba si dos regiones de cadenas son iguales.
`boolean`	`regionMatches(int Tdesplazamiento,Cadenaotra, int ooffset, int len)` Comprueba si dos regiones de cadenas son iguales.
`String`	`replace(char oldChar, char newChar)` Devuelve una nueva cadena resultante de reemplazar todas las apariciones de`oldChar`en esta cadena con`newChar`.
`boolean`	`startsWith(Cadenaprefijo)` Comprueba si la cadena comienza con el prefijo especificado.
`boolean`	`startsWith(Cadenaprefijo, int Tdesplazamiento)` Comprueba si la cadena comienza con el prefijo especificado a partir de un índice determinado.
`CharSequence`	`subsecuencia(int beginIndex, int endIndex)` Devuelve una nueva secuencia de caracteres que es una subsecuencia de esta secuencia.
`String`	`substring(int beginIndex)` Devuelve una nueva cadena que es una subcadena de esta cadena.
`String`	`substring(int beginIndex, int endIndex)` Devuelve una nueva cadena que es una subcadena de esta cadena.
`char []`	`ToCharArray()` convierte esta cadena a una nueva matriz de caracteres.
`String`	`toLowerCase()` Convierte todos los personajes de esta`string`a minúsculas utilizando las reglas de la configuración regional predeterminada.
`String`	`toLowerCase(Localelocale)` Convierte todos los personajes de esta`string`a minúsculas utilizando las reglas de lo dado`Locale`.
`String`	`toString()` Este objeto (que ya es una cadena!) es en sí regresaron.
`String`	`toUpperCase()` Convierte todos los personajes de esta`string`a mayúsculas utilizando las reglas de la configuración regional predeterminada.
`String`	`toUpperCase(Localelocale)` Convierte todos los personajes de esta`string`a mayúsculas utilizando las normas de la dada`Locale`.
`String`	`trim()` Devuelve una copia de la cadena, con el espacio inicial y final se omite.
static String	`valueOf(boolean b)` Devuelve la representación de cadena del`boolean`argumento.
static String	`valueOf(char c)` Devuelve la representación de cadena del`char`argumento.
static String	`valueOf(char [] data)` Devuelve la representación de cadena del`char`argumento de matriz.
static String	`valueOf(char [] datos, int desplazamiento, int count)` Devuelve la representación de cadena de una submatriz específica del`char`argumento de matriz.
static String	`valueOf(double d)` Devuelve la representación de cadena del`doble`argumento.
static String	`valueOf(float f)` Devuelve la representación de cadena del`flotador`argumento.
static String	`valueOf(int i)` Devuelve la representación de cadena del`int`argumento.
static String	`valueOf(long l)` Devuelve la representación de cadena de la`larga`discusión.
static String	`valueOf(Objectobj)` Devuelve la representación de cadena del`objeto`argumento.

fuente:oracle.com

Matrices en Java – Forex – Curso – Motor

Una matriz es una estructura de datos en la que podemos almacenar una cierta cantidad de datos los cuales deben ser delmismo tipo(int, float, string...) posee dos subíndice, el primero representa el número de filas y el segundo representa la cantidad de columnas. La sintaxis para la declaración sería la siguiente.int[][] matriz; donde el tipo de dato puede ser el que nosotros deseemos, en éste casoint.

Ejemplo:

Matriz 2 x 3 ( 2 filas, 3 columnas).

columna 1 columna 2 columna 3
fila 1 4 59
fila 2 11 1 22

Cada elemento de la matriz posee una cierta posición o ubicación. Ejemplo, el dato9 se encuentra en la fila 1 columna 3.

IMPORTANTE:
Hay que tener en cuenta que en matemática (Álgebra lineal) empezamos a contar las filas y columnas a partir de 1. En programación para referirnos al dato9 sería la fila 0 y la columna 2, dado que empezamos a contar a partir de la posición [0][0].

Ejemplo:

Matriz 2 x 3 ( 2 filas, 3 columnas).

columna 0 columna 1 columna 2
fila 0 4 59
fila 1 11 1 22

Si queremos mostrar en pantalla el dato9 la sintaxis sería la siguiente:

System.out.println(matriz[0][2]);

Vamos a ver algunas formas de manejar las matrices en java:

"Desarrollar un programa en el cual se ingresen datos de tipo entero (int) en una matriz de orden m x n donde m es el numero de filas y n el numero de columnas (el numero de filas y columnas debe ser ingresado por el usuario). Además, imprimir: los componentes o datos de la primera fila de la matriz, los de la ultima fila, los de la primera columna, los de la diagonal principal (solo si es una matriz cuadrada), el mayor de todos los datos enteros y la fila y columna a las que pertenece, los valores que se encuentran en los vertices de la matriz y todos los datos o componentes de la matriz."

Matriz.java

import java.util.Scanner;

public class Matriz {
 private Scanner teclado;
 private int[][] matriz;
 private int filas;
 private int columnas;
 
 public void cargar(){
  teclado = new Scanner(System.in);
  System.out.println("Ingrese la cantidad de filas de la matriz");
  filas = teclado.nextInt();
  System.out.println("Ingrese la cantidad de columnas de la matriz");
  columnas = teclado.nextInt();
  matriz =  new int[filas][columnas];
  for(int i=0; i filas; i++){
   for(int j=0; jcolumnas;j++){
    System.out.println("Ingrese componente de la matriz");
    matriz[i][j] = teclado.nextInt();
   }
  }
 }
 
 public void PrimeraFila(){
  System.out.println("Primeral Fila:"); 
  for(int j=0; j  columnas; j++){
   System.out.println(matriz[0][j]); // No se presenta problemas acá ya que la matriz siempre tendra al menos un componente, y este estaría en la posición [0][0].
  }
 }
 
 public void UltimaFila(){
  System.out.println("Ultima Fila:");
  for(int j=0; j  columnas; j++){
   System.out.println(matriz[filas - 1][j]); // filas - 1 es el valor de la última fila. Ejemplo: una matriz de 2 x 2 la la ultima fila sería la 1 ya que empezamos desde 0, por lo tanto 2- 1 = 1. 
  }
 }
 
 public void PrimeraColumna(){
  System.out.println("Primeral Columna:");
  for(int i=0; i  filas; i++){
   System.out.println(matriz[i][0]); //No se presenta problemas acá ya que la matriz siempre tendra al menos un componente, y este estaría en la posición [0][0].
  }
 }
 
 public void DiagonalPrincipal(){
  System.out.println("Diagonal Principal:");
  if(filas == columnas){
  for(int D= 0; D matriz.length; D++){ // El metodo .length retorna la cantidad de filas de la matriz.
    System.out.println(matriz[D][D]);
  }
  }
  else{
   System.out.println("La matriz ingresada no es cuadrada, por lo tanto no tiene diagonal principal.");
  }
 }
 
 public void MayorElemento(){
  int mayorE = matriz[0][0]; //Declaramos la variable que va a almacenar al mayor elmento y lo inicializamos e la posición (0,0).
  int filaE = 0;
  int columnaE = 0;
  for(int i = 0; i  filas; i++){
   for(int j = 0; j  columnas; j++){
    if(matriz[i][j]  mayorE){
     mayorE = matriz[i][j];
     filaE = i + 1;  // La fila en donde se encuentra ese elemento. Le sumamos 1 ya que la teoría de matrices nos dice que el primer elemento de una matriz es el (1,1) y si imprimimos sin sumar 1 entonces arrojaríamos como resultado que el primer elemento es el (0,0) de ser este el caso. 
     columnaE = j + 1; // La columna en donde se encuentra ese elemento. Le sumamos 1 ya que la teoría de matrices nos dice que el primer elemento de una matriz es el (1,1) y si imprimimos sin sumar 1 entonces arrojaríamos como resultado que el primer elemento es el (0,0) de ser este el caso.
    }
   }
  }
  System.out.println("El mayor elemento dentro de la matriz es: " + mayorE);
  System.out.println("Se encuentra en la fila numero: " + filaE + " y en la columna numero: " + columnaE);
 }
 
 public void Vertices(){
  System.out.println("Vertices de la matriz: ");
  System.out.println("Valor del vertice superior izquierdo: " + matriz[0][0]);
  System.out.println("Valor del vertice superior derecho: " + matriz[0][columnas - 1]); //columnas menos 1 ya que si decimos que la matriz tiene 3 columnas empezaremos a agregar valores desde la posicion 0 hasta la 2 dado que el for se repite mientras j sea menor a la cantidad de columnas que ingresamos ( j  columnas).
  System.out.println("Valor del vertice inferior izquierdo: " + matriz[filas - 1][0]); //filas menos 1 ya que si decimos que la matriz tiene 4 filas empezaremos a agregar valores desde la posicion 0 hasta la 3 dado que el for se repite mientras 1 sea menor a la cantidad de filas que ingresamos ( i  filas).
  System.out.println("Valor del vertice inferior derecho: " + matriz[filas - 1][columnas - 1]); // Similar a las dos anteriores lineas.
 }
 
 public void MatrizCompleta(){
  System.out.println("Matriz Completa:");
  for(int i= 0; i filas; i++){
   for(int j=0; j  columnas; j++){
    System.out.println(matriz[i][j]);
   }
  }
 }
 
 public static void main(String[] ar){
  Matriz mat = new Matriz();
  mat.cargar();
  mat.PrimeraFila();
  mat.UltimaFila();
  mat.PrimeraColumna();
  mat.DiagonalPrincipal();
  mat.MayorElemento();
  mat.MatrizCompleta();  
 }

}

Explicación:

private int[][] matriz;
private int filas;
private int columnas;

Declaramos la matriz y las variables "filas" y "columnas" las cuales almacenarán el valor que les demos.

System.out.println("Ingrese la cantidad de filas de la matriz");
filas = teclado.nextInt();
System.out.println("Ingrese la cantidad de columnas de la matriz");
columnas = teclado.nextInt();
matriz =  new int[filas][columnas];

Solicitamos al usuario que ingrese la cantidad de filas y columnas y luego las almacenamos en las respectivas variables. Luego, creamos la matriz dándole al primer subíndice el valor ingresado para las filas y al segundo subíndice el valor ingresado para las columnas.

for(int i=0; i filas; i++){
 for(int j=0; jcolumnas;j++){
  System.out.println("Ingrese componente de la matriz");
  matriz[i][j] = teclado.nextInt();
 }
}

Para ingresar los elementos, componentes o datos de la matriz, usamos un ciclo for dentro de otro ciclo for dado que la matriz puede tener varias filas y cada fila puede tener varias columnas.

public void PrimeraFila(){
 System.out.println("Primeral Fila:"); 
 for(int j=0; j  columnas; j++){
 System.out.println(matriz[0][j]); // No se presenta problemas acá ya que la matriz siempre tendra al menos un componente, y este estaría en la posición [0][0].
 }
}

Para imprimir la primera fila de nuestra matriz sabemos que la primera fila sería el subíndice 0 y que ésta puede tener varias columnas, por ello usamos un for que recorra todas las columnas o el subíndice j, donde j tomara el valor desde 0 hasta la cantidad de columnas que contenga la matriz.

public void UltimaFila(){
 System.out.println("Ultima Fila:");
 for(int j=0; j  columnas; j++){
 System.out.println(matriz[filas - 1][j]);

}
}

Para imprimir la ultima fila de nuestra matriz sería:filas - 1debido a que si la matriz contiene dos filas para referirnos a la segunda fila ésta sería el subíndice [1] y no el 2.Ejemplo: una matriz de 2 x 2 la ultima fila sería la 1 ya que empezamos desde 0, por lo tanto 2- 1 = 1.

public void PrimeraColumna(){
 System.out.println("Primeral Columna:");
 for(int i=0; i  filas; i++){
 System.out.println(matriz[i][0]); //No se presenta problemas acá ya que la matriz siempre tendra al menos un componente, y este estaría en la posición [0][0].
  }
 }

Similar al método usado para la primera fila. El subíndice para la primera columna sería [0].matriz[i][0].

public void DiagonalPrincipal(){
 System.out.println("Diagonal Principal:");
if(filas == columnas){
 for(int D= 0; D matriz.length; D++){ // El metodo .length retorna la cantidad de filas de la matriz.
 System.out.println(matriz[D][D]);
 }
 }
else{
   System.out.println("La matriz ingresada no es cuadrada, por lo tanto no tiene diagonal principal.");
 }
}

Los elementos de la diagonal principal de una matriz son todos los que se encuentran en los subíndices i y j donde i = j .

Digamos que i = j = D. Entonces para referirnos a los elementos de la diagonal principal seríamatriz[D][D]

Si tenemos una matriz de 3x3 (3 filas, 3 columnas) los elementos de la diagonal principal serían:matriz[0][0],matriz[1][1],matriz[2][2]

Es IMPORTANTE tener presente que solo las matrices cuadradas poseen diagonal principal. Entiendase matriz cuadrada como la matriz que posee la misma cantidad de filas y columnas (matrices 2x2, 3x3, 4x4... nxn).Es por esto que usamos unif para imprimir los elementos solo sifilas == columnas, de no ser ésto así arrojará un mensaje de error diciendo que la matriz ingresada no es una matriz cuadrada.

Utilizamos el método.length el cual retorna la cantidad de filas de nuestra matriz, esto le dirá alciclo for cuantas veces se debe repetir.

public void MayorElemento(){
 int mayorE = matriz[0][0]; //Declaramos la variable que va a almacenar al mayor elmento y lo inicializamos e la posición [0][0].
 int filaE = 0;
 int columnaE = 0;
 for(int i = 0; i  filas; i++){
  for(int j = 0; j  columnas; j++){
   if(matriz[i][j]  mayorE){
   mayorE = matriz[i][j];
   filaE = i + 1;  // La fila en donde se encuentra ese elemento. Le sumamos 1 ya que la teoría de matrices nos dice que el primer elemento de una matriz es el [1,1] y si imprimimos sin sumar 1 entonces arrojaríamos como resultado que el primer elemento es el [0][0]. de ser este el caso. 
   columnaE = j + 1; // La columna en donde se encuentra ese elemento. Le sumamos 1 ya que la teoría de matrices nos dice que el primer elemento de una matriz es el (1,1) y si imprimimos sin sumar 1 entonces arrojaríamos como resultado que el primer elemento es el [0][0]. de ser este el caso.
   }
  }
 }
  System.out.println("El mayor elemento dentro de la matriz es: " + mayorE);
  System.out.println("Se encuentra en la fila numero: " + filaE + " y en la columna numero: " + columnaE);
}

Declaramos la variablemayorE y la inicializamos con el valor del elemento el cual se encuentra en la posición [0][0]. También las variablesfilaE ycolumnaE para almacenar la fila y columna en la que se encuentre el mayor elemento. Utilizamos un ciclo for dentro de otro ciclo for para ir comparando cada elemento o dato. Hay que tener en cuenta que al momento de imprimir la fila o columna en la que se encuentra el dato debemos hacerlo de la siguiente manera:filaE = i + 1; Si se encuentra en la fila 0 diremos por pantalla que se encuentra en la fila 1 o primera fila.

public void Vertices(){
 System.out.println("Vertices de la matriz: ");
 System.out.println("Valor del vertice superior izquierdo: " + matriz[0][0]);
 System.out.println("Valor del vertice superior derecho: " + matriz[0][columnas - 1]); 
 System.out.println("Valor del vertice inferior izquierdo: " + matriz[filas - 1][0]); 
 System.out.println("Valor del vertice inferior derecho: " + matriz[filas - 1][columnas - 1]); 
 }

Para el vértice superior izquierdo:columnas menos 1 ya que si decimos que la matriz tiene 3 columnas empezaremos a agregar valores desde la posicion 0 hasta la 2 dado que el for se repite mientras j sea menor a la cantidad de columnas que ingresamos ( j columnas).

Para el vértice inferior izquierdo:filas menos 1 ya que si decimos que la matriz tiene 4 filas empezaremos a agregar valores desde la posicion 0 hasta la 3 dado que el for se repite mientras 1 sea menor a la cantidad de filas que ingresamos ( i filas).

Para el vértice inferior derecho:Similar a las dos vértices anteriores.

Finalmente se realiza la salida: