Vectores,
Matrices o Arrays en Java:
El manejo de vectores en Java es similar al manejo de vectores en el lenguage de programación C.
Solo hay que tener en cuenta que un vector en Java se tiene primero que declarar, y luego se tiene que construir, ya que los vectores son, al
igual que todo en Java, objetos.
Declaración
de un vector:
Para declarar un vector se seguirá la siguiente sintaxis:
tipoDatos
nombreVector[];
tipoDatos es el tipo de datos de los elementos del vector (int,
double, String, etc.)
nombreVector es el nombre que tú quieras darle a tu vector.
Por ejemplo, supongamos que queremos crear un vector de enteros llamado v. La declaración será la siguiente:
int v[];
Como puedes ver, en la declaración de un vector no se indica la
dimensión de éste, es decir, el número de elementos que tiene. Esto se hace en
la construcción del vector.
Construcción
de un vector:
Para construir un vector que ya haya sido declarado se sigue la
siguiente sintaxis:
nombreVector
= new tipoDatos[dim];
· nombreVector es el nombre del vector a construir.
· tipoDatos es el tipo
de datos del vector.
· dim es la
dimensión del vector (el número de elementos).
Por ejemplo, si queremos que el vector v
declarado antes tenga 10 elementos, tendremos que hacer lo siguiente:
v = new
int[10];
En el momento de la construcción del vector, podemos usar una variable
entera para asignar el número de
elementos que se quiera.
Por ejemplo, en el siguiente caso el número de elementos del vector v viene dado por la variable num:
v = new
int[num];
Acceso a
los elementos de un vector:
Una vez declarado el vector y construido, este se puede usar de la misma
manera que en C. Se puede acceder a un elemento del vector escribiendo el
nombre del vector y entre corchetes el índice del elemento que quieres usar.
Recuerda que los índices comienzan a numerarse desde 0.
Ejemplo
N° 1:
etiMensaje.setText("El
Valor es: " + v[6]);
Aquí se coloca en una etiqueta el valor contenido en la sétima posición
del vector v.
Ejemplo N°
2:
for (int i = 0; i < 10; i++) {
v[i] = 100;
}
Este código recorre un vector de 10 elementos y almacena en dichos 10
elementos el número 100.
Longitud
de un vector:
Una forma rápida de saber la longitud que tiene un vector es usar lo
siguiente:
nombreVector.length
Por ejemplo, si el vector se llama v, su
longitud (el número de elementos que tiene) sería:
v.length
El siguiente código rellena el vector v con
ceros, da igual el número de elementos que tenga:
for (int i
= 0; i < v.length; i++) {
v[i] = 0;
}
Creación
de un vector e inicialización con datos al mismo tiempo:
Es posible crear un vector e introducir datos directamente en él al
mismo tiempo. La forma general de hacerlo sería la siguiente:
tipoDatos
nombreVector[] = {elemento1, elemento2, elemento3, …, elementoN};
Por
ejemplo:
int v[] =
{6, 3, 1, 2};
Este código crea un vector con cuatro números enteros: 6, 3, 1, 2.
Ejemplo
2:
String
coloresArcoiris[] = {"Rojo", "Naranja",
"Amarillo", "Verde", "Azul", "Añil",
"Violeta"};
Este código crea un vector que contiene 7 cadenas, correspondientes a
los colores del arcoíris.
VECTORES
DE COMPONENTES:
En Java, se pueden crear vectores de etiquetas, cuadros de texto, botones,
etc.
Esto es tremendamente útil cuando se tienen que definir muchos
componentes con una función parecida, y que tengan que ser tratados en
conjunto.
Por otro lado, nos ahorra mucho tiempo ya que no se tienen que diseñar
estos elementos en la misma ventana de diseño.
Los vectores de componentes se usan igual que se ha indicado antes.
Observa el siguiente ejemplo:
JLabel
vectorEtiquetas[]; //aquí se
crea un vector de etiquetas llamado vectorEtiquetas
vectorEtiquetas
= new JLabel[6]; //aquí se construye el vector, asignando 6 etiquetas
//ahora trabajamos con las
etiquetas del vector usando el bucle for
for (int i
= 0; i < vectorEtiquetas.length; i++) {
vectorEtiquetas[i] = new JLabel(); //se construye cada etiqueta
vectorEtiquetas[i].setBounds(10, 10 + i * 30, 100, 20); //se asigna
posición y tamaño
vectorEtiquetas[i].setText("Etiqueta " + i); //se
asigna un texto
this.getContentPane().add(vectorEtiquetas[i]); //se coloca en la ventana
}
Realiza el siguiente ejercicio para entender el ejemplo:
Ejercicio:
- Crea un nuevo proyecto en java.
- Empecemos definiendo desde código las características
de la ventana. Crearemos el método crearVentana, y lo llamaremos
desde el método constructor del proyecto:
- Vamos a situar en la ventana 10 cuadros de
verificación (JCheckBox). Para ello usaremos un vector de 10 JCheckBox.
Este vector se declarará en la zona de variables globales (será necesario
añadir el típico import):
- La construcción de los vectores de
componentes, se realiza en el método constructor (en nuestro caso en el
método crearVentana, que es llamado desde el método constructor).
Construiremos el vector de forma que contenga 10 JCheckBox:
- Se acaba de construir un vector con 10 cuadros
de verificación. Ahora, es necesario construir cada uno de los cuadros del
vector y asignarle ciertas propiedades. Esto se hace con un bucle for que
recorre los elementos del vector. (Añade el siguiente código dentro del método crearVentana):
- Analiza este código que se acaba de añadir:
- Observa como cada
elemento del vector debe ser construido:
vectorCuadros[i] = new JCheckBox();
- El texto que tendrá
cada elemento será: “Cuadro
de Verificación:
vectorCuadros[i].setText("Cuadro de Verificación: " + i);
- Los cuadros de
verificación se colocan uno debajo de otro. Estudia la línea siguiente y
observa como varía la posición vertical de cada cuadro:
vectorCuadros[i].setBounds(10, 10 + 30 * i, 300, 20);
- Luego agrego cada
cuadro de verificación en el panel de contenidos de la ventana.
this.getContentPane().add(vectorCuadros[i]);
- Ejecuta el programa y observa el resultado:
- Mejoremos la presentación de los cuadros
cambiando los rótulos de cada uno. Para ello, será necesario usar otro
vector auxiliar que contenga los textos de cada uno de los cuadros.
Modifica el código anterior de forma que quede así:
- En este código puedes observar como se usa un
vector de String que se crea conteniendo 10 colores. Luego, ese vector se
usa para asignar cada color al texto de cada cuadro. Si ejecutas el programa,
verás que cada cuadro tiene su texto correspondiente a un color.
- Ahora añade un botón con su evento actionPerformed.
Añade en la zona de variables globales lo siguiente:
JButton btnAceptar;
Y luego, dentro de crearVentana,
añade el siguiente código:
- Ahora programaremos la respuesta al evento actionPerformed
de forma que el programa diga cuantos cuadros hay seleccionados. Para
ello, se tendrá que programar el procedimiento btnAceptarActionPerformed,
cuya llamada se encuentra en el código anterior (la línea que da error):
Así pues, fuera de crearVentana, programa el
siguiente procedimiento:
- En este código se puede observar como se usa
un bucle for para recorrer fácilmente el vector de cuadros y averiguar cuáles
de ellos están seleccionados. Aumentamos un contador y lo demás es
sencillo.
Si este programa se hubiera hecho desde diseño, el
código para contar el número de cuadros seleccionados sería mucho más
engorroso. Piénsalo.
- Ejecuta el programa. Selecciona varios cuadros
y pulsa el botón Aceptar. Observa el resultado:
CONCLUSIONES:
En Java,
los vectores deben declararse y luego construirse. Es en la construcción del
vector cuando se le asigna a este el número de elementos.
En Java
se pueden crear vectores de componentes: etiquetas, cuadros de texto, botones,
etc. facilitando luego el trabajo con todos estos elementos en conjunto y
facilitando las labores de diseño.
