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?
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.
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 |
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.
|
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.
|
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.
|
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.
