Imaginemos que tenemos
que hallar el promedio de 10 números que introduzca el usuario (o realizar
cualquier otra operación con ellos). Parece evidente que tiene que haber una
solución más cómoda que definir 10 variables distintas y escribir 10 veces las
instrucciones de avisar al usuario, leer los datos que teclee, y almacenar esos
datos. Si necesitamos manejar 100, 1.000 o 10.000 datos, resulta todavía más
claro que no es eficiente utilizar una variable para cada uno de esos datos.
Por eso se emplean los arrays (o arreglos). Un array es una variable que puede contener varios dato del mismo tipo. Para acceder a cada uno de esos datos emplearemos corchetes. Por ejemplo, si definimos una variable llamada "m" que contenga 10 números enteros, accederemos al primero de estos números como m[0], el último como m[9] y el quinto como m[4] (se empieza a numerar a desde 0 y se termina en n-1). Veamos un ejemplo que halla la media de cinco números (con decimales, "double"):
// Array1.java
// Aplicación de ejemplo con Arrays
// Introducción a Java
class Array1 {
public static void main( String args[] ) {
double a[] = { 10, 23.5, 15, 7, 8.9 };
double total = 0;
int i;
for (i=0; i<5; i++)
total += a[i];
System.out.println(
"La media es:" );
System.out.println( total / 5 );
}
}
Para definir la variable podemos usar dos formatos: "double a[]" (que es la sintaxis habitual en C y C++) o bien "double[] a" (que es la sintaxis recomendada en Java, y posiblemente es una forma más "razonable" de escribir "la variable a es un array de doubles").
Nota: Quien venga de C y/o C++ tiene que tener en cuenta que en Java no son válidas definiciones como float a[5]; habrá que asignar los valores como acabamos de hacer, o reservar espacio de la forma que veremos a continuación.
Lo habitual no será conocer los valores en el momento de teclear el programa, como hemos hecho esta vez. Será mucho más frecuente que los datos los teclee el usuario o bien que los leamos de algún fichero, los calculemos, etc. En este caso, tendremos que reservar el espacio, y los valores los almacenaremos a medida que vayamos conociéndolos.
Para ello, primero declararíamos que vamos a utilizar un array, así:
double[] datos;
y después reservaríamos espacio (por ejemplo, para 1.000 datos) con
datos = new double [1000];
Estos dos pasos se pueden dar en uno solo, así:
double[] datos = new double [1000];
y daríamos los valores de una forma similar a la que hemos visto en el ejemplo anterior:
datos[25] = 100 ; datos[0] = i*5 ; datos[j+1] = (j+5)2 = new double [1000];
Vamos a ver un ejemplo algo más completo, con tres arrays de números enteros, llamados a, b y c. A uno de ellos (a) le daremos valores al definirlo, otro lo definiremos en dos pasos (b) y le daremos fijos, y el otro lo definiremos en un paso y le daremos valores calculados a partir de ciertas operaciones:
// Array2.java
// Aplicación de ejemplo con Arrays
// Introducción a Java
class Array2 {
public static void main( String args[] ) {
int
i; // Para repetir con bucles "for"
// ------ Primer array de ejemplo
int[] a = { 10, 12345, -15, 0, 7 };
System.out.println( "Los valores de a son:"
);
for (i=0; i<5; i++)
System.out.println( a[i] );
//
------ Segundo array de ejemplo
int[] b;
b = new int [3];
b[0] = 15; b[1] = 132; b[2] = -1;
System.out.println( "Los valores de b son:"
);
for (i=0; i<3; i++)
System.out.println( b[i] );
// ------ Tercer array de ejemplo
int j = 4;
int[] c = new int[j];
for (i=0; i<j; i++)
c[i] = (i+1)*(i+1);
System.out.println( "Los valores de c son:" );
for (i=0; i<j; i++)
System.out.println( c[i] );
}
}
Las matrices se definen,
como un arreglo bidimensional, en donde tenemos un número de reglones N y un
número de columnas M. La representación matemática de una matriz es :
|
a11 |
a12 |
... |
a1M |
|
a21 |
a22 |
... |
a2M |
|
... |
... |
... |
... |
|
aN1 |
aN2 |
... |
aNM |
Para hacer la definición en Java de este arreglo hacemos
double A[][] = new double [N][M];
donde A es el nombre del arreglo N el número de renglones y M el número de
columnas.
Para hacer referencia al elemento en el i-esimo renglón y la j-esima columna
hacemos A[i][j].
Otra forma de hacer la definición de un arreglo es mediante la siguiente
instrucción
double a[][] = {{1,2,3},
{4,5,6}, {7,8,9}};
esta instrucción crea un arreglo de 3 renglones con 3 columnas y los elementos
lo dispone de la siguiente manera
|
|
|
1 |
2 |
3 |
|
A |
= |
4 |
5 |
6 |
|
|
|
7 |
8 |
9 |
Ejemplo.
Hacer un programa que almacene la matriz anterior en un arreglo, la eleve
al cuadrado e imprima el resultado en la pantalla.
class arreglos
{
static public void main(String args[])
{
double a[][] = {{1,2,3}, {4,5,6}, {7,8,9}};
double b[][] = new double [3][3];
int i, j;
for(i=0; i< 3; i++)
for(j=0; j<3; j++)
b[i][j] = a[i][j] * a[i][j];
for(i=0; i< 3; i++)
{
for(j=0; j<3; j++)
System.out.print(b[i][j] + " ");
System.out.println("");
}
}
}
Una cadena de texto (en
inglés, "string") es un bloque de letras, que usaremos para poder almacenar
palabras y frases. En algunos lenguajes, podríamos utilizar un
"array" de "chars" para este fin, pero en Java no es
necesario, porque tenemos un tipo "cadena" específico ya incorporado
en el lenguaje.
Realmente en Java hay dos "variantes" de las cadenas de texto: existe una clase llamada "String" y otra clase llamada "StringBuffer". Un "String" será una cadena de caracteres constante, que no se podrá modificar (podremos leer su valor, extraer parte de él, etc.; para cualquier modificación, realmente Java creará una nueva cadena), mientras que un "StringBuffer" se podrá modificar "con más facilidad" (podremos insertar letras, dar la vuelta a su contenido, etc) a cambio de ser ligeramente menos eficiente (más lento).
Vamos a ver las principales posibilidades de cada uno de estos dos tipos de cadena de texto y luego lo aplicaremos en un ejemplo.
Podemos "concatenar" cadenas (juntar dos cadenas para dar lugar a
una nueva) con el signo +, igual que sumamos números. Por otra parte, los
métodos de la clase String son:
|
Método |
Cometido |
|
length() |
Devuelve la longitud
(número de caracteres) de la cadena |
|
charAt (int pos) |
Devuelve el carácter
que hay en una cierta posición |
|
toLowerCase() |
Devuelve la cadena
convertida a minúsculas |
|
toUpperCase() |
Devuelve la cadena
convertida a mayúsculas |
|
substring(int desde, |
Devuelve una subcadena:
varias letras a partir de una posición dada |
|
replace(char antiguo, |
Devuelve una cadena conun
carácter reemplazado por otro |
|
trim() |
Devuelve una cadena sin
espacios de blanco iniciales ni finales |
|
startsWith(String |
Indica si la cadena
empieza con una cierta subcadena |
|
endsWith(String |
Indica si la cadena
termina con una cierta subcadena |
|
indexOf(String subcadena, |
Indica la posición en
que se encuentra una cierta subcadena |
|
lastIndexOf(String |
Indica la posición en
que se encuentra una cierta subcadena |
|
valueOf( objeto ) |
Devuelve un String que
es la representación como texto del |
|
concat(String cadena) |
Devuelve la cadena con
otra añadida a su final (concatenada) |
|
equals(String cadena) |
Mira si las dos cadenas
son iguales (lo mismo que "= =") |
|
equals-IgnoreCase( |
Comprueba si dos
cadenas son iguales, pero despreciando |
|
compareTo(String
cadena2) |
Compara una cadena con
la otra (devuelve 0 si son iguales, |
Como se ve, en ningún momento estamos modificando el String de partida. Eso sí, en muchos de los casos creamos un String modificado a partir del original.
El método "compareTo" se basa en el órden lexicográfico: una cadena que empiece por "A" se considerará "menor" que otra que empiece por la letra "B"; si la primera letra es igual en ambas cadenas, se pasa a comparar la segunda, y así sucesivamente. Las mayúsculas y minúsculas se consideran diferentes.
Hay alguna otra posibilidad, de uso menos sencillo, que no veremos (al menos
por ahora), como la de volcar parte del String en un array de chars o de bytes.
Los métodos de la clase StringBuffer son:
|
Método |
Cometido |
|
length() |
Devuelve la longitud
(número de caracteres) de la cadena |
|
setLength() |
Modifica la longitud de
la cadena (la trunca si hace falta) |
|
charAt (int pos) |
Devuelve el carácter
que hay en una cierta posición |
|
setCharAt(int
pos, char |
Cambia el carácter que
hay en una cierta posición |
|
toString() |
Devuelve el
StringBuffer convertido en String |
|
reverse() |
Cambia el orden de los
caracteres que forman la cadena |
|
append( objeto ) |
Añade otra cadena, un
número, etc. al final de la cadena |
|
insert(int pos, objeto) |
Añade otra cadena, un
número, etc. en una cierta posición |
Al igual que ocurre con los strings, existe alguna otra posibilidad más
avanzada, que no he comentado, como la de volcar parte del String en un array
de chars, o de comprobar la capacidad (tamaño máximo) que tiene un StringBuffer
o fijar dicha capacidad.
Un comentario extra sobre los Strings: Java convertirá a String todo aquello que indiquemos entre comillas dobles. Así, son válidas expresiones como "Prueba".length() y también podemos concatenar varias expresiones dentro de una orden System.out.println:
System.out.println( "Texto: " + texto1 + 5 + 23.5 );
Vamos a ver un ejemplo que aplique la mayoría de todo esto:
// Strings1.java
// Aplicación
de ejemplo con Strings
// Introducción
a Java,
class Strings1 {
public static void main( String args[] ) {
String texto1 =
"Hola";
// Forma "sencilla"
String texto2 = new String("Prueba"); // Usando un
constructor
System.out.println( "La primera cadena de texto es :" );
System.out.println( texto1 );
System.out.println( "Concatenamos las dos: " + texto1 + texto2 );
System.out.println( "Concatenamos varios: " + texto1 + 5 + "
" + 23.5 );
System.out.println( "La longitud de la segunda es: " +
texto2.length() );
System.out.println( "La segunda letra de texto2 es: "
+ texto2.charAt(1) );
System.out.println( "La cadena texto2 en mayúsculas: "
+ texto2.toUpperCase() );
System.out.println( "Tres letras desde la posición 1: "
+ texto2.substring(1,3) );
System.out.println( "Comparamos texto1 y texto2: "
+ texto1.compareTo(texto2) );
if (texto1.compareTo(texto2) < 0)
System.out.println( "Texto1 es menor que texto2" );
StringBuffer texto3 = new StringBuffer("Otra prueba");
texto3.append(" mas");
System.out.println( "Texto 3 ahora es: " + texto3 );
texto3.insert(2, "1");
System.out.println( "Y ahora es: " + texto3 );
texto3.reverse();
System.out.println( "Y ahora: " + texto3 );
}
}
El resultado de este programa sería el siguiente:
La primera cadena de texto es :
Hola
Concatenamos las dos: HolaPrueba
Concatenamos varios: Hola5 23.5
La longitud de la segunda es: 6
La segunda letra de texto2 es: r
La cadena texto2 en mayúsculas: PRUEBA
Tres letras desde la posición 1: ru
Comparamos texto1 y texto2: -8
Texto1 es menor que texto2
Texto 3 ahora es: Otra prueba mas
Y ahora es: Ot1ra prueba mas
Y ahora: sam abeurp ar1tO