LOS VECTORES.

                                           LA CLASE DE VECTORES 

Los arrays en Java son suficientes para guardar tipos básicos de datos, y objetos de una determinada clase cuyo número conocemos de antemano. Algunas veces deseamos guardar objetos en un array pero no sabemos cuántos objetos vamos a guardar. Una solución es la de crear un array cuya dimensión sea más grande que el número de elementos que necesitamos guardar. La clase Vector nos proporciona una solución alternativa a este problema. Un vector es similar a un array, la diferencia estriba en que un vector crece automáticamente cuando alcanza la dimensión inicial máxima. Además, proporciona métodos adicionales para añadir, eliminar elementos, e insertar elementos entre otros dos existentes.

Crear un vector

Para usar la clase Vector hemos de poner al principo del archivo del código fuente la siguiente sentencia import

Import java.util.*;

Cuando creamos un vector u objeto de la clase Vector, podemos especificar su dimensión inicial, y cuanto crecerá si rebasamos dicha dimensión.

Vector vector=new Vector (20, 5);

Tenemos un vector con una dimensión inicial de 20 elementos. Si rebasamos dicha dimensión y guardamos 21 elementos la dimensión del vector crece a 25.

Al segundo constructor, solamente se le pasa la dimensión inicial.

Vector vector=new Vector (20);

Si se rebasa la dimensión inicial guardando 21 elementos, la dimensión del vector se duplica. El programador ha de tener cuidado con este constructor, ya que si se pretende guardar un número grande de elementos se tiene que especificar el incremento de la capacidad del vector, si no se quiere desperdiciar inútilmente la memoria el ordenador.

Con el tercer constructor, se crea un vector cuya dimensión inicial es 10.

Vector vector=new Vector ();

La dimensión del vector se duplica si se rebasa la dimensión inicial, por ejemplo, cuando se pretende guardar once elementos.

Añadir elementos al vector

Hay dos formas de añadir elementos a un vector. Podemos añadir un elemento a continuación del último elemento del vector, mediante la función miembro addElement.

v.addElement ("uno");

Podemos también insertar un elemento en una determinada posición, mediante insertElementAt. El segundo parámetro o índice, indica el lugar que ocupará el nuevo objeto. Si tratamos de insertar un elemento en una posición que no existe todavía obtenemos una excepción del tipo ArrayIndexOutOfBounds. Por ejemplo, si tratamos de insertar un elemento en la posición 9 cuando el vector solamente tiene cinco elementos.

Para insertar el string "tres" en la tercera posición del vector v, escribimos v.insertElementAt ("tres", 2);

En la siguiente porción de código, se crea un vector con una capacidad inicial de 10 elementos, valor por defecto, y se le añaden o insertan objetos de la clase String.

Vector v=new Vector();

v.addElement("uno");

v.addElement("dos");

v.addElement("cuatro");

v.addElement("cinco");

v.addElement("seis");

v.addElement("siete");

v.addElement("ocho");

v.addElement("nueve");

v.addElement("diez");

v.addElement("once");

v.addElement("doce");

v.insertElementAt("tres", 2);

Para saber cuantos elementos guarda un vector, se llama a la función miembro size. Para saber la dimensión actual de un vector se llama a la función miembro capacity. Por ejemplo, en la porción de código hemos guardado 12 elementos en el vector v. La dimensión de v es 20, ya que se ha superado la dimensión inicial de 10 establecida en la llamada al tercer constructor cuando se ha creado el vector v.

System.out.println("nº de elementos "+v.size());

System.out.println("dimensión "+v.capacity());

Podemos eliminar todos los elementos de un vector, llamando a la función miembro removeAllElements. O bien, podemos eliminar un elemento concreto, por ejemplo el que guarda el string "tres".

v.removeElement("tres");

Podemos eliminar dicho elemento, si especificamos su índice.

v.removeElementAt(2);

Acceso a los elementos de un vector

El acceso a los elementos de un vector no es tan sencillo como el acceso a los elementos de un array. En vez de dar un índice, usamos la función miembro elementAt. Por ejemplo, v.elementAt(4) sería equivalente a v[4], si v fuese un array.

Para acceder a todos lo elementos del vector, escribimos un código semejante al empleado para acceder a todos los elementos de un array.

for(int i=0; i<v.size(); i++){

System.out.print(v.elementAt(i)+"\t");

}

Existe otra alternativa, que es la de usar las funciones del interface Enumeration. Este interface declara dos funciones pero no implementa ninguna de ellas. Una Enumeration nos permite acceder a los elementos de una estructura de datos de forma secuencial.

public interface Enumeration {

boolean hasMoreElements();

Object nextElement();

}

La función miembro elements de la clase Vector devuelve un objeto de la clase VectorEnumerator que implementa el interface Enumeration y tiene que definir las dos funciones hasMoreElements y nextElement.

final class VectorEnumerator implements Enumeration {

Vector vector;

int count;

VectorEnumerator(Vector v) {

vector = v;

count = 0;

}

public boolean hasMoreElements() {

//...

}

public Object nextElement() {

//...

}

}

El objeto enum devuelto por la función miembro elements es de la clase VectorEnumerator, sin embargo no podemos escribir

VectorEnumerator enum=v.elements();

porque VectorEnumerator no es una clase pública. Como podemos ver en su definición, no tiene la palabra reservada public delante de class. Sin embargo, podemos guardar un objeto de la clase VectorEnumerator en una variable enum del tipo Enumeration, por que la clase implementa dicho interface.

Enumeration enum=v.elements();

while(enum.hasMoreElements()){

System.out.print(enum.nextElement()+"\t");

}

Desde el objeto enum devuelto por la función miembro elements de la clase Vector llamamos a las funciones miembro hasMoreElements y nextElement de la clase VectorEnumerator. La función hasMoreElements devuelve true mientras haya todavía más elementos que se puedan acceder en el vector v. Cuando se ha llegado al último elemento del vector, devuelve false. La función nextElement devuelve una referencia al próximo elemento en la estructura de datos. Esta función devuelve una referencia a un objeto de la clase base Object, que el programador precisará en ciertos casos, como veremos más abajo, promocionar (casting) a la clase adecuada.

Para buscar objetos en un vector se puede usar una Enumeration y hecer una comparación elemento por elemento mediante equals, tal como vemos en la siguiente porción de código

Enumeration enum=v.elements();

while(enum.hasMoreElements()){

String elemento=(String)enum.nextElement();

if(elemento.equals("tres")){

System.out.println("Encontrado tres");

break;

}

}

Podemos usar alternativamente, la función miembro contains para este propósito.

if(v.contains("tres")){

System.out.println("Encontrado tres"); 

}

Fuente. 

********************************************************************************************************

VARIABLES CON ÍNDICE O LOCALIZADOR. ARRAYS (ARREGLOS).

Vamos a repasar algunos conceptos que ya deberíamos conocer. Un array (arreglo) en Java es una estructura de datos que nos permite almacenar un conjunto de datos de un mismo tipo. El tamaño de los arrays se declara en un primer momento y no puede cambiar luego durante la ejecución del programa, como sí puede hacerse en otros lenguajes. Veremos ahora cómo declarar arrays estáticos de una dimensión. 

ARRAYS UNIDIMENSIONALES

La sintaxis para declarar e inicializar un array será:

  Tipo_de_variable[ ]   Nombre_del_array = new  Tipo_de_variable[dimensión];

También podemos alternativamente usar esta declaración:

  Tipo_de_variable[ ] Nombre_del_array;

  Nombre_del_array = new Tipo_de_variable[dimensión];

El tipo de variable puede ser cualquiera de los admitidos por Java y que ya hemos explicado. Ejemplos de declaración e inicialización con valores por defecto de arrays usando todos los tipos de variables Java, serían:

-        byte[ ] edad = new byte[4];

-        short[ ] edad = new short[4];

-        int[ ] edad = new int[4];

-        long[ ] edad = new long[4];

-        float[ ] estatura = new float[3];

-        double[ ] estatura = new double[3];

-        boolean[ ] estado = new boolean[5];

-        char[ ] sexo = new char[2];

-        String[ ] nombre = new String[2];

Aclarar que los valores por defecto son los siguientes:

a)      Para números el valor cero “0”.

b)      Para cadenas y letras el valor vacío.

c)       Para booleanos el valor false.

En caso de que queramos inicializarlos con valores propios, haremos esto:

Para números enteros

 int[ ] edad = {45, 23, 11, 9};  //Array de 4 elementos

De la misma forma procederíamos para los otros tipos de enteros : byte, short, long.

Para números reales

double[ ] estatura = {1.73, 1.67, 1.56}; //Array de 3 elementos

De la misma forma procederíamos para el tipo float, pero teniendo en cuenta que los números deberán llevar al final la letra “f” o “F”. Por ejemplo 1.73f o 1.73F.

Para cadenas

String[ ] nombre = {"María", "Gerson"};   //Array de 2 elementos

Para caracterers

char[ ] sexo = {'m', 'f'};   //Array de 2 elementos

Para booleanos

boolean[ ] = {true,false};    //Array de 2 elementos

Cuando creamos un array de nombre “a” y de dimensión “n” (int[ ] a = new int[n]) estamos creando n variables que son a[0], a[1], a[2], ..., a[n-1]. Los arrays se numeran desde el elemento cero, que sería el primer elemento, hasta el n-1 que sería el último elemento. Es decir, si tenemos un array de 5 elementos, el primer elemento sería el cero y el último elemento sería el 4.  Esto conviene tenerlo en cuenta porque puede dar lugar a alguna confusión. Disponer de un valor con índice cero puede ser de utilidad en situaciones como considerar cada variable asociada a una hora del día, empezando a contar desde la hora cero hasta la 23 (total de 24 horas), cosa que es habitual en algunos países. En lugar de 1, 2, 3, ..., 24 estaríamos usando 0, 1, 2, ..., 23.

Vamos a trabajarlo sobre el ordenador en un programa y ver qué pasaría si declaramos un array de tamaño “n” y vamos asignando un valor a cada variable del array desde la posición cero hasta la posición “n-1”. Adicionalmente vamos a comprobar qué ocurre si tratamos de asignarle valor a la variable de posición  “n”.

El código fuente del programa (escríbelo en BlueJ) es el siguiente:

    /* Ejemplo uso Arrays – aprenderaprogramar.com */

  public class ArrayDeNombres {

       public static void main(String arg[ ]) {

             String[ ] nombre = new String[4];

             nombre[0] = "Luis";

             nombre[1] = "María";

             nombre[2] = "Carlos";

             nombre[3] = "Jose";

             nombre[4] = "Ismael";   //Error:No existe esta variable array de índice 4

     }

  }