La clase ArrayList.

Hay veces que estamos programando, y estamos usando arreglos con almacenamiento estático (un arreglo es un grupo de variables que contienen valores, todas de un mismo tipo) , el problema con ellos es precisamente ese, que su almacenamiento es estático,  ¿Qué quiere decir esto?, bueno que una vez que los declaramos, antes de usarlo, debemos definir cuál va a ser su tamaño, y este no podrá cambiar cuando el programa este corriendo, esto es un problema frecuente en  programación, y entonces me trae a la mente varias preguntas.

v  ¿Qué pasa si no sé cuál va a ser el tamaño del arreglo que quiero?

v  Tal vez si sepa el tamaño pero, ¿si necesito que crezca durante la ejecución del programa?

v  ¿Habrá implementaciones en Java que resuelvan este problema?

Bueno con un poco de suerte y podemos resolver todas estas cuestiones con un sola publicación así que manos a la obra, a continuación le presentare una clase interesante llamada ArrayList, esta supone una manera un poco distinta de trabajar a comparación de los arreglos normales, sobre todo porque este tipo de almacenamiento es dinámico, a medias, puesto que si no existieran y tuvieramos un arreglo normal en donde ya hemos ocupado toda su capacidad, lo que deberiamos hacer es crear otro arreglo con el doble de capacidad para poder copiar todo al arreglo nuevo y tener asi mas capacidad,y pues la clase ArrayList nos ahorra todo ese trabajo.

En publicaciones posteriores hablaremos de la clase LinkedList , la cual implementa una lista ligada y aunque su finalidad es la misma sus propiedades son un poco distintas.

¿Cómo la importamos?

import java.util.ArrayList;

ArrayList es una clase muy interesante de java, puesto que si uno se pone a pensar, nos ahorra mucho tiempo en cuestiones de implementación, es decir, un arrayList es un arreglo pero tiene la ventaja de que su almacenamiento es dinámico, y esto significa que su tamaño puede crecer o decrecer en tiempo de ejecución, algo que con un arreglo normal no se puede hacer.

Bueno todo esto está muy bien, pero lo que queremos es el código para aprender a usar un ArrayList , está bien comencemos con las declaraciones, ¿Cómo es que declaramos una ArraList?, debemos instanciar la clase ArrayList de la siguiente manera.

        ArrayList <String> cadena=new ArrayList();

       ArrayList <Integer> entero=new ArrayList();

       ArrayList <Double> flotante =new ArrayList();

**IMPORTANTE:: ArrayList No acepta como parámetro , tipos de datos abstractos(char,int,double,float,byte,short,long), en vez de eso debemos utilizar las clases adaptadas e estos tipos de datos (Integer para int ,String para char y String,Double para double,etc.) estas se comportan igual y tienen la ventaja de tener métodos de implementación que nos pueden servir, pero eso es tema de otra entrada.

Ademas esta es otra ventaja de arrayList, PODEMOS HACER ARRAYS DE CUALQUIER OBJETO QUE EXISTA EN JAVA.

En el ejemplo de arriba hemos declarado tres ArrayList de distintos tipos, ahora veamos como agregar elementos a ellos.

Para agregar elementos a ellos debemos usar el método add(); en cual le pasaremos como parámetro el elemento que queramos meter al ArrayList, es importante mencionar que este método esta sobrecargado, ¿Qué quiere decir esto?, bueno que dependiendo de lo que le pasemos como parámetro es como actuara y es que hay dos formas de este método, si solo le pasamos como parámetro el elemento que queremos agregar , lo agregara el final de la lista , pero si le pasamos como parámetros primero un número, y después separado por una coma el elemento a agregar , el método agregara el elemento en el índice del numero pasado.

 Forma 1

      cadena.add("HOLA");

       entero.add(1);

       flotante.add(2.3);

Para esta forma, el método agregara estos elementos en la posición final del ArrayList

Forma 2

       cadena.add(1,"HOLA");

       entero.add(1,1);

       flotante.add(1,2.3);

Para esta otra forma el método agregara el elemento que se la pasó en la posición del índice que le pasamos en el primer número que le dimos al elemento. En el caso de cadena “HOLA” será agregado en la posición 1, en el caso de entero (1) será agregado en la posición 1, y en el caso de flotante (2.3) será agregado en la posición 1.

**IMPORTANTE

Si usamos la segunda forma del add, si en la posición en la que le estamos indicando que insertaremos un elemento, ya existía algo, lo que hara es mover todos los elementos hacia adelante para que el nuevo pueda entrar, es decir no borra ningún elemento , solo los recorre, si lo que queremos es que borre el elemento que ya estaba , lo que debemos hacer es  usar el metodo set() explicado mas adelante.

Bueno bueno ya sabemos agregar elementos al ArrayList, ¿pero que hay si queremos obtener el valor de un elemento en el ArrayList?, si este es el caso entonces debemos usar otro método llamado get();,a este método basta con pasarle como parámetro el índice del elemento que queremos obtener , y el se encargara de obtenerlo y dárnoslo.

Por ejemplo si quisiéramos mostrar en consola los elementos que agregamos arriba, bastaría con hacer lo siguiente:

        System.out.println(cadena.get(1));

        System.out.println(entero.get(1));

        System.out.println(flotante.get(1));

Y el resultado obtenido seria el siguiente :

Resultado de imprimir la posición número 1 del Array

Bien estos dos métodos son básicos para empezar a usar los ArrayList, pero metámonos un poco más en los beneficios que nos da esta clase.

Hay más métodos que nos facilitan las cosas a la hora de programar, los siguientes son algunos de ellos.

isEmpty();	Devuelve true (verdadero) si es que el ArrayList que lo está llamando esta vacío.
contains(Object o);	Devuelve verdadero, si y solo si el elemento que se le pasa como parámetro se encuentra en el ArrayList, caso contrario devuelve falso.
indexOf(Object o);	Devuelve el índice de la primera ocurrencia del elemento pasado como parámetro, caso contrario devolverá un -1
lastIndexOf(Object o);	Devuelve el ultimo índice de las ocurrencias de elemento pasado como parámetro, caso contrario devolverá -1
remove(Object o); remove (int index);	Este método actúa de acuerdo a lo que le pasemos como parámetro, es decir si le pasamos un objeto de la clase que es el ArrayList, lo buscara en el ArrayList y eliminara la PRIMERA ocurrencia de este y devolverá true, si no hay elemento devuelve false que significa que la lista no tenía ningún elemento como el que se le paso y por ende la lista no fue cambiada. Sin embargo si le pasamos como parámetro un número, este lo tomara como un índice y eliminara lo que se encuentra en esa posición.
set(int index, Object o);	Define en el índice pasado como parámetro el objeto que también se pasó, es decir si le pasamos 1 , “hola”; pondrá en la posición 1 del ArrayList el texto hola, sin importar lo que haya ahí.
size();	Devuelve un entero con el tamaño del ArrayList.

Bien hasta ahora hemos visto muchos métodos que nos sirven para la clase ArrayList a continuación veremos un ejemplo, poniendo a prueba todo lo que hemos dicho hasta ahora.

   import java.util.ArrayList;

/**
 *
 * @author Luis
 */
public class ProbandoArrays {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        /**
         * Para esta prueba crearemos tres ArrayList
         */
        ArrayList cadena = new ArrayList();
        ArrayList entero = new ArrayList();
        ArrayList flotante = new ArrayList();
        /**
         * Una vez agregados llenaremos con diez posiciones cada uno el array de
         * String lo llenaremos con la forma HOLA X donde X es un número del 1
         * al 10 el array de enteros lo llenaremos con números del 1 al 10 y el
         * de flotantes lo llenaremos con números del 1.3 al 10.3 es importante
         * mencionar que el metodo add() agregará siempre al final de la lista
         */
        for (int i = 0; i <= 10; i++) {
            cadena.add("HOLA " + i);
            entero.add(i);
            flotante.add(i + 0.3);
        }

        //  Si quisieramos impimir el array completo haríamos lo siguiente 
        System.out.println(cadena);
        System.out.println(entero);
        System.out.println(flotante);

        // En cambio si ontener un elemento específico para usarlo o impimirlo
        //usaremos el método get();, imaginemos que queremos imprimir el elemento que esta
        // en la posición  4 de cada array, entonces debemos hacer lo siguiente
        System.out.println(cadena.get(4));
        System.out.println(entero.get(4));
        System.out.println(flotante.get(4));

        // algo importante es recordar que en los ArrayList los elmentos se empiezan
        //a contar desde la posicion 0.
        /**
         * ahora imagina que quieres agregar un elemento en una posicion
         * especifica del Array, bueno para eso existen dos métodos , y usaremos
         * el que nos convenga según el caso, si lo que queremos es insertar el
         * elemento en una posicion y queremos que los demás elementos se
         * recorran entonces usaremos el metodo add(indice,elemnto);, pero si lo
         * que queremos es agregar en una posicion el elmento y borrar lo que ya
         * había es esa posicion debemos usar el metodo set(indice,elemento);
         */
        System.out.println("\nAgregando un elemento en la posicion 5 y recorriendo todos los de más con el metodo add();");
        cadena.add(5, "Elemento agregado");
        entero.add(5, 9999);
        flotante.add(5, 333.44);
        System.out.println("Podemos ver que los elementos se recorrieron para dejar entrar al nuevo elemento\n");
        System.out.println(cadena);
        System.out.println(entero);
        System.out.println(flotante);

        System.out.println("\n Quitando el elemento de la posicion 2 con el método set();");
        cadena.set(2, "Eliminado y remplazado");
        entero.set(2, 000000000);
        flotante.set(2, .33333333333);
        System.out.println("El elemento fue remplazado, es decir eliminado, y cambiado por otro nuevo sin que los de más se recorrier\n");
        System.out.println(cadena);
        System.out.println(entero);
        System.out.println(flotante);

        /**
         * Que tal si queremos saber si existe algún elemento en la lista, con
         * una arreglo normal tendríamos que hacer un for e ir buscando el
         * elemento, ArrayList nos ahorra esto, o tan lo menos lo hace invisible
         * para nosotros y nos presenta el método contains(); , tenemos que
         * pasarle como parámetro el elemento a buscar , y nos devolvera true si
         * es que se encuentra y -1 o false si es que no esta el elemento
         */
        System.out.println("\n\nBucando elementos en el array con el metodo contains();");

        System.out.println("Buscamos en el array cadena la palabra HOLA 0 entonces nos devuleve: " + cadena.contains("HOLA 0"));
        System.out.println("Buscamos en el array cadena la palabra HOLA entonces nos devuleve: " + cadena.contains("HOLA"));

        System.out.println("\nBuscamos en el array entero el número 0 entonces nos devuleve: " + entero.contains(0));
        System.out.println("Buscamos en el array entero el número 10000 entonces nos devuleve: " + entero.contains(1000));

        System.out.println("\nBuscamos en el array flotante el número 1.3 entonces nos devuleve: " + flotante.contains(1.3));
        System.out.println("Buscamos en el array flotante el número 39.9 entonces nos devuleve: " + flotante.contains(39.9));

        /**
         * y que tal si quisieramos saber la posición en la que se encuentra un
         * elemento en el arreglo, el método indexOf(); y el método
         * lastIndexOf(); nos ayudan con eso, el primero nos devuleve el indice
         * de la primera ocurrencia de la busqueda, y el otro el indice de la
         * ultima ocurrencia, si el elemento no se encuentra en la lista ,
         * simplemente devuelve -1
         */
        System.out.println("\n obteniendo indices de busquedas con los métodos indexOf(); y lastIndexOf();");
        System.out.println("\n buscando el indice de la palabra HOLA 8 en el Array cadena : " + cadena.indexOf("HOLA 8"));
        //agregaremos otro 8 al array entero para que haya dos elementos iguales y porblemos el método lastIndexOf();
        entero.add(8);
        System.out.println("\n buscando la ultima ocurrencia de 8 en el Array entero : " + entero.lastIndexOf(8));
        System.out.println("\n buscando un elemento que no existe en el Array flotante : " + flotante.indexOf(3333.3333));
        /**
         * Por último imaginemos que queremos eliminar un elemento de la lista y
         * que los demas elementos se recorriran para no dejar ese espacio
         * vacío, bueno en este caso debemos usar el metodo remove(); y debemos
         * pasarle como parámetro el elemento a eleminar o la posición del
         * elmento, el método se encargara de eliminarlo y de recorrer los demas
         * elementos, para que no haya espacios vacíos
         */
        System.out.println("\n\n Eliminando elementos de  los ArrayList");

        System.out.println("\nEliminando de el ArrayList cadena por elemento   HOLA 0 ");
        cadena.remove("HOLA 0");
        System.out.println("\nEliminando de el ArrayList entero el elemento en la posicion 4");
        entero.remove(4);
        System.out.println("\nEliminando del ArrayList flotante el elemento 6.3");
        flotante.remove(6.3);

        System.out.println("Imprimiendo los Arrays Modificados: ");

        System.out.println(cadena);
        System.out.println(entero);
        System.out.println(flotante);

    }

}

Esto es todo por esta entrada, más adelante se publicarán entradas de ArrayList más avanzadas en las que pondremos a prueba las funcionalidades de esta maravillosa clase de la API de Java.