Download ArrayList • Un ArrayList es un array dinámico. No tiene restricciones

ArrayList
• Un ArrayList es un array dinámico. No tiene restricciones de capacidad. Su
tamaño se ajusta de forma dinámica.
• Constructor por defecto: new ArrayList(). Inicialmente, la capacidad de un
ArrayList creado así es 0.
• Los elementos dentro de un ArrayList son Objetos. No pueden ser de tipo básico,
pero pueden ser de cualquier tipo de objeto.
• La clase ArrayList forma parte del paquete java.util
• Para poner un elemento dentro de esta estructura, usamos el método add y para
recoger un elemento usamos el método get.
• Ejemplos: ArrayListExample.java
import java.util.*;
Public class ArrayListExample1 {
Public static void main(String[ ] args) {
ArrayList thisArrayList = new ArrayList();
thisArrayList.add("hello");
thisArrayList.add(",");
thisArrayList.add("are");
thisArrayList.add("you");
thisArrayList.add("?");
for (int i=0;i<thisArrayList.size();i++){
System.out.print(thisArrayList.get(i)+" ");
}
}
}
Métodos de ArrayList
http://java.sun.com/j2se/1.4.2/docs/api/java/util/ArrayList.html
• int size() -- El tamaño actual (puede ser 0)
• void add(obj) -- Añade un objeto al final del ArrayList, incrementando su tamaño
de 1. obj es un objeto.
• Object get(N) -- Devuelve el elemento almacenado a la posición N en el
ArrayList. N tiene que ser un entero entre 0 y size()-1.
– En ArrrayListInteger.java, se convierte el objeto devuelto por get() a un Integer
con casting.
– En ArrayListString.java, se convierte el objeto devuelto por get() a un String
llamando al método toString() de Object.
import java.util.ArrayList;
public class ArrayListInteger {
public static void main(String[] args) {
ArrayList numeros = new ArrayList();
Integer num1 = new Integer(10);
Integer num2 = new Integer(20);
Integer num3 = new Integer(30);
Integer num4 = new Integer(40);
numeros.add(num1);
numeros.add(num2);
numeros.add(num3);
numeros.add(num4);
int suma=0;
for (int i=0;i<numeros.size();i++) {
Integer thisNumero = (Integer)numeros.get(i);
suma = suma + thisNumero.intValue();
System.out.print(thisNumero);
if (i<numeros.size()-1)
System.out.print("+");
else
System.out.print("=");
}
System.out.println(suma);
}
}
import java.util.*;
public class ArrayListString {
public static void main(String[] args) {
ArrayList cadenas = new ArrayList();
cadenas.add("hello");
cadenas.add(",");
cadenas.add("are");
cadenas.add("you");
cadenas.add("?");
for (int i=0;i<cadenas.size();i++) {
Object object = cadenas.get(i);
String cadena = object.toString();
cadena = cadena.toUpperCase();
System.out.print(cadena+" ");
}
}
}
Más Métodos de ArrayList
http://java.sun.com/j2se/1.4.2/docs/api/java/util/ArrayList.html
• void set(index, obj) – Sustituye el elemento en la posición index por el objeto obj.
(index tiene que ser entre 0 y size()-1) dentro del ArrayList, sustituyendo el
elemento previamente almacenado a la posición N. Es equivalente a A[N] = obj
para un array A.
• Object remove(index) -- Elimina el elemento a la posición index (index entre 0 y
size()-1).
Devuelve el objeto eliminado
Los elementos después de este objeto están rebajados de una posición. El
tamaño del ArrayList disminuye de 1.
• int indexOf(obj) -- Busca el objeto obj dentro del ArrayList, y si lo encuentra,
devuelve la posición donde lo ha encontrado. Si no, devuelve -1.
Ejercicios
• Escribir los siguientes métodos:
– void eliminarTodos(ArrayList cadenas,String cadena)
Elimina todas las copias de cadena dentro de cadenas
– int min(ArrayList numeros)
Devuelve el número más pequeño del array dinámico
– void toUpperCase(ArrayList cadenas)
Sustituye cada cadena (String) del arrayList por la su versión
máyuscula.
– int veces(ArrayList cadenas,String cadena)
Devuelve el número de veces que aparece la cadena en el array dinámico de
cadenas.
Iterator
• Para recorrer un ArrayList, podemos llamar a get dado un índice (como en los
métodos anteriores).
• Podemos prescindir de los índices y usar un Iterator sobre este ArrayList:
ArrayListIterator.java
• La clase Iterator pertenece al paquete java.util
• La única función de un objeto de tipo Iterator es recorrer un ArrayList.
• Iterator tiene como métodos hasNext (que devuelve un boolean) y next (que
devuelve un Object).
• Como StringTokenizer, un objeto de tipo Iterator es de un solo uso.
import java.util.*;
public class ArrayListIterator {
public static void main(String[ ] args) {
ArrayList thisArrayList = new ArrayList();
thisArrayList.add("hello");
thisArrayList.add(",");
thisArrayList.add("are");
thisArrayList.add("you");
thisArrayList.add("?");
Iterator it = thisArrayList.iterator();
while (it.hasNext())
System.out.print(it.next()+" ");
}
}
HashMap
• Un HashMap es un array asociativo (o hash table).
• Contiene asociaciones <clave,valor>, donde la clave es única y permite acceder
al valor.
• Ejemplos de asociaciones:
– La lista de alumnos, cada alumno es accesible por su NIA.
– El directorio telefónico, cada número se accede por los apellidos
y la dirección.
– Un diccionario, cada definición se accede por lemma.
• Ejemplo: UseHashMap.java
Métodos de HashMap
http://java.sun.com/j2se/1.4.2/docs/api/java/util/HashMap.html
• int size() -- El tamaño actual = número de mappings <clave,valor>
• boolean isEmpty() - Devuelve true si el map es vacío
• void put(clave,valor) - Añade el mapping <clave,valor> a map, donde clave
y valor son objetos. Si clave ya existe, sustituye su valor por valor.
import java.util.*;
public class UseHashMap{
public static void main(String[] args) {
String aa= "INDIA";
HashMap hashmap = new HashMap();
hashmap.put("one",new Integer(1));
hashmap.put("two",null);
hashmap.put("three","THREE");
hashmap.put("four",aa);
System.out.println("The size of HashMap = "+ hashmap.size());
System.out.println("If hashmap empty = "+ hashmap.isEmpty());
}
}
Métodos de HashMap
http://java.sun.com/j2se/1.4.2/docs/api/java/util/HashMap.html
• Object get(clave) - Devuelve el valor asociado con clave, o null si clave no existe
dentro de map.
• Set keySet( ) - Devuelve un Set (conjunto de elementos individuales únicos)
correspondiente a las claves del map. Podemos iterar sobre este Set (con un
Iterator). Nota: Set es una clase de java.util
System.out.println("The elements of HashMap are");
Set set= hashmap.keySet();
Iterator iter = set.iterator();
while(iter.hasNext()){
Object clave = iter.next();
Object valor = hashmap.get(clave);
System.out.println("Key: " + clave + " Value: " + valor);
}
• Para recorrer un hashmap:
– Conseguimos el conjunto de claves
– Recorremos este conjunto, y para cada clave, sacamos su valor correspondiente
en el hashmap
Métodos de HashMap
http://java.sun.com/j2se/1.4.2/docs/api/java/util/HashMap.html
• boolean containsKey(clave) - Devuelve true si clave existe dentro de map
como clave
• boolean containsValue(valor) - Devuelve true si valor existe dentro de map
como valor
17
System.out.println("Contains key \"one\" ="+hashmap.containsKey("one"));
System.out.println("Contains key \"five\" ="+hashmap.containsKey("five"));
System.out.println("Contains value of variable aa \"INDIA\"
="+hashmap.containsValue(aa));
Integer thisInteger = new Integer(6);
System.out.println("Contains value \“6\” as Integer
="+hashmap.containsValue(thisInteger));
System.out.println("The value for the \"three\" key =" +
hashmap.get("three"));
Métodos de HashMap
http://java.sun.com/j2se/1.4.2/docs/api/java/util/HashMap.html
• Object remove(obj) - Elimina la asociación cuya clave es obj. Devuelve el valor
asociado con esta clave antes de eliminar.
• Collection values( ) - Devuelve una Collection (conjunto de elementos
individuales no únicos) de los valores que hay dentro del hashmap.
Podemos iterar sobre esta Collection.
• void clear() - elimina todos los mappings <clave,valor> del array.
Nota: Collection es una clase de java.util
hashmap.remove("two");
System.out.println("The size of HashMap has reduced by one");
System.out.println("The size of HashMap = " + hashmap.size());
System.out.println("The values of HashMap are =" + hashmap.values());
//Remove all the elements from the HashMap
hashmap.clear();
System.out.println("If hashmap empty = " + hashmap.isEmpty());
Ejercicios
• Escribir los métodos:
– Alumno getAlumno(HashMap alumnos,String nia)
Dado un array asociativo de <NIA,objeto-alumno>, el método devuelve el valor
(objeto-alumno) dado la clave.
– void increment(HashMap palabras,String palabra)
Dado un array asociativo palabras de <cadena,numero>, donde cadena es una
palabra (tipo) de un corpus y numero el número de veces que ocurre en el corpus,
el método incrementa de uno el número de veces que ocurre palabra.
Importante: puede que “palabra” no exista en el hashmap, en tal caso habrá que
añadirlo.