Estructuras dinámicas
En esta ocasión vamos a ver como declarar estructuras dinámicas en java,las llamadas arrays.
En ocasiones anteriores hemos visto los arreglos de una dimensión llamados vectores y de dos llamados matrices,a diferencia de los arreglos comunes que acabo de mencionar los
arrays deben o son dinámicos en tamaño no estáticos,por ejemplo al definir un vector de 10 elementos de tipo
int tenemos que hacer esto:
Integer elementos[] = new Integer[10];
Pero si quisiéramos o mejor dicho si no supiéramos cuantos elementos va a tener el arreglo como le haríamos?
Aquí es donde entra
ArrayList lo que seria como una simple lista en lenguajes como python o ruby.
Listas
Para usar
ArrayList tenemos que importarlo:
import java.util.ArrayList;
Su constructor es este:
ArrayList elementos = new ArrayList();
De esta manera seria idéntico a un lenguaje de alto nivel(fácil) crear una lista,a lo que me refiero es que podemos crear una lista de distintos tipos de datos,int,string,float,etc a diferencia de lo que seria un vector de un solo tipo de dato:
Para añadir un elemento usamos el método
add pasándole como parámetro el dato a usar,por ejemplo:
elementos.add("Hola Mundo"); // String
elementos.add(10); // int
elementos.add('a'); // char
Bien,aun asi cuando los llamemos se convertiran a un tipo envuelto:
int a Interger
char a Character // etc
Aun así no es muy recomendable usar este tipo de listas(con datos de muchos tipos),lo recomendable es usar un dato de un solo tipo ya que incluso el compilador muestra un error.
Para definir el tipo de datos que vamos a usar lo añadimos al lado del constructor entre etiquetas:
ArrayList arreglo = new ArrayList();
En donde tipo usamos un tipo envuelto,por ejemplo:
ArrayList arreglo = new ArrayList();
Primero vamos a ver los métodos de agregar y de obtener:
arreglo.add(10);
arreglo.add(120);
Ya hemos comentado el método
add,para obtener un elemento del arreglo usamos el método
get y le pasamos como parámetro el índice(comienza a contar desde 0) del elemento:
arreglo.get(10);
Si queremos ver el tamaño de un arreglo usamos el método
size que nos devuelve un int,por ejemplo para recorrer los elementos de un
array:
for (int i = 0;i < arreglo.size();i++)
System.out.println(arreglo.get(i));
Antes de ver las otras funciones podemos ver que añadir tiene otra función,la cual es diferente,mientras el
add normal "apila" los datos uno sobre otro,este otro
add puede añadir un dato en cierta posición:
arreglo.add(posición,elemento);
Eso seria como un remplazar.
Bien ahora vamos a ver las formas de iterar los elementos de un array,forma uno:
Esta ya la vimos:
for (int i = 0;i < arreglo.size();i++)
System.out.println(arreglo.get(i));
Forma dos:
Con un bucle foreach,donde
Integer es el tipo de Objeto.
for (Integer x: arreglo) {
System.out.println(x);
}
Forma tres con un
Iterator,donde
Integer no es el tipo de objeto.
import java.util.Iterator;
Iterator i = arreglo.iterator();
while(i.hasNext()) {
System.out.println(i.next());
}
Bien que mas podemos hacer?
Tenemos mas funciones:
arreglo.clear(); // Limpia el array(lo resetea)
arreglo.contains(elemento); // Devuelve true si existe el elemento en el array
arreglo.remove(indice); // elimina un elemento basado en el índice
arreglo.remove(elemento); // elimina un elemento basado en el elemento
arreglo.toArray(); // Devuelve un array (Object[])
arreglo.indexOf(elemento); // Devuelve el índice del elemento contando desde la izquierda
arreglo.lastIndexOf(elemento); // Devuelve el índice del elemento contando desde la derecha
Hashes
Ahora vamos a ver como usar los
arreglos asociativos o
has tables,los cuales se usan igual que las listas solo que se usan con clave valor en vez de índice valor:
Para definir un
Hashtable,primero lo importamos:
import java.util.Hashtable;
Ahora usamos este constructor:
Hashtable hash;
Los dos objetos son los que usaremos para clave y valor,se recomienda usar
String para clave,por ejemplo:
Hashtable hash = new Hashtable();
Ahora vamos a ver como añadir elementos:
Usamos:
hash.put(clave,valor);
Por ejemplo usando el hash de arriba:
hash.put("uno",1);
hash.put("diez",10);
Ahora tenemos dos elementos en el hash,como los recuperamos?
hash.get(clave);
Por ejemplo:
hash.get("uno"); // devuelve 1
Tenemos funciones similares al de
ArrayList:
hash.clear(); // Resetea el hash
hash.containsKey(clave); // Devuelve true si contiene la clave
hash.containsValue(valor); // Devuelve true si contiene el valor
hash.isEmpty(); // Devuelve true si esta vacio
hash.remove(clave); // Quita el objeto basado en clave
Como iteramos?
Aquí es un poco mas complicado ya que no podemos usar índices,pero aun así tenemos algunas opciones:
La primera opciones es usando
Collection ,primero importamos:
import java.util.Collection;
Ahora creamos un objeto
Collection,esta nos devolverá los valores:
Collection col = hash.values(); // En donde Integer es el tipo de objeto de los valores
Luego creamos un
Iterator,como con ArrayList y iteramos:
Iterator i = col.iterator();
while(i.hasNext()) {
System.out.println(i.next());
}
Forma 2:
Esta otra forma es mas sutil ya que podremos usar las llaves y los valores,es usando
Enumeration:
import java.util.Enumeration;
Enumeration en = hash.keys(); // En donde String es el tipo de Objeto de las claves
Bien ahora solo iteramos:
while(en.hasMoreElements()) {
String key = en.nextElement();
System.out.printf("Clave : %s Valor : %s\n",key,hash.get(key));
}
Eso es todo :D
