Programación OO Colecciones Dr. Eric Jeltsch F

Programación OO Colecciones Dr. Eric Jeltsch F.

Anexo: Collection

< interface >

Collection

public void clear();

public boolean add(Object o);

public boolean addAll(Collection c);

public boolean remove(Object o);

public boolean removeAll(Collection c);

public boolean contains(Object o);

public boolean containsAll(Collection c);

public boolean equals(Object o);

public boolean isEmpty();

public int size();

public boolean retainAll(Collection c);

public Iterator iterator();

publicObject [] toArray();

public Object [] toArray(Object [] a);

public int hashCode();

public String toString()

Fig.: la Interface Collection

< interface >

Iterator

public boolean hasNext();

public Object next();

public void remove();

Fig.: La Interface Iterator

< interface >

java.util.Comparator

public int compare(Object o1, Object o2)

// compara 2 Argumentos respecto de su orden

public boolean equals(Object arg)

// testea, si 2 Objetos, resp. Comparator-Objetos son =.

Fig.: La Interface Comparator

< interface >

List

public void add(int index, Object element);

public boolean add(Object o);

public boolean addAll(Collection c);

public boolean addAll(int index, Collection c)

public void clear();

public boolean equals(Object object);

public boolean contains(Object element);

public boolean containsAll(Collection collection);

public Object remove(int index)

public boolean remove(Object element);

public boolean removeAll(Collection c);

public boolean retainAll(Collection c);

public Object get();

public int hashCode();

public Iterator iterator();

public ListIterator listIterator():

public ListIterator listIterator(int startIndex);

public Object set(int index, Obeject element);

public List subList(int fromIndex, int toIndex);

public Object [] toArray();

public Object [] toArray(Object [] a);

Fig.: La Interface List

< interface >

Collection

< interface >

List

LinkedList ArrayList Vector

< Constructores > < Constructores >

public LinkedList(); public ArrayList();

public LinkedList(Collection collection); public ArrayList(Collection collection);

public ArrayList(int startCapacidad);

< Metodos > < Metodos >

public void addFirst(Object object); protected void removeRange

public void addLast(Object object); (int fromIndex, int toIndex)

public Object getFirst(); // elimina parte de la lista de

public Object getLast(); // fromIndex hasta toIndex. fromIndex

// es también borrado,

public Object removeFirst(); // lo que no ocurre con toIndex.

public Object removeLast();

Fig.: LinkedList, ArrayList, Vector

< interface >

Collection

< interface >

Set

public boolean add(Object element);

public boolean addAll(Collection collection);

public void clear();

public boolean equals(Object object);

public boolean contains(Object element);

public boolean containsAll(Collection collection);

public int hashCode();

public Iterator iterator();

public boolean remove(Object element);

public boolean removeAll(Collection collection);

public boolean retainAll(Collection collection);

public int size();

public Object[] toArray();

public Object[] toArray(Object[] a);

HashSet < interface >

SortedSet

public HashSet(); public Object first();

public HashSet(Collection collection); public Object last();

public HashSet(int startCapacidad); public SortedSet headSet(Object toElement);

public HashSet(int startCapacidad, public SortedSet subSet(Object fromElement,

float factorCarga); Object toElement);

public SortedSet tailSet(Object fromElement);

public Comparator comparator();

TreeSet

public TreeSet()

public TreeSet(Collection collection);

public TreeSet(Comparator vergleich);

public TreeSet(SortedSet collection);

Interface Map, SortedMap

< interface >

Collection

< interface >

Map

public void clear();

public boolean containsKey(Object key);

public boolean containsValue(Object value);

public Set entrySet();

public Object get(Object key);

public boolean isEmpty();

public Set keySet();

public Object remove(Object key);

public int size();

public Collection values();

HashMap < interface >

SortedMap

public HashMap(); public Comparator comparator();

public HashMap(Map collection); public Object firstKey();

public HashMap(int startCapacidad); public Object lastKey();

public HashMap(int startCapacidad, public SortedMap headMap(Object toKey);

int factorCarga); public SortedMap subMap(Object fromKey,

Object toKey);

public SortedMap tailMap(Object fromKey);

Hashtable TreeMap

public TreeMap();

public TreeMap(Map collection);

public TreeMap(Comparator vergleich);

public TreeMap(SortedMap collection);

En la API Collections, es uno de los cambios más notables experimentados por el paquete java.util del JDK1.2, pues las clases e interfaces que la componen ofrecen una estructura independiente de la implementación, con el fin de mejorar y manejar colecciones de objetos. Observar que Java1.1 proporcionaba la interfaz Enumeration y las seis clases siguientes: Vector, Stack, BitSet, Dictionary, Hashtable y Properties.

La clase Vector ofrece la posibilidad de implementar un array creciente. El array crece en la medida que se le van ingresando elementos. También se puede reducir el tamaño del array una vez eliminado algunos de ellos, esto último se logra con trimToSize().

La clase Stack ofrece la posibilidad de crear y usar objetos de almacenamiento denominados Pilas. Se almacena información colocándola en una pila y se elimina o recupera información sacándola de la pila. El último objeto colocado en una pila es el primer objeto que se puede recuperar. La clase Stack extiende la clase Vector. Los objetos se disponen en la pila por medio del método push() y se recuperan por el pop(). También posee un método llamado search() que busca un objeto determinado. El método peek() devuelve el elemento de la parte de arriba de la pila.

Las clases BitSet se utiliza para crear objetos que mantienen un conjunto de bits. En general se usan en aplicaciones orientadas al sistema operativo o en temas asociados a señales.

Las clases Dictionary, Hashtable y Properties, son tres generaciones de clases que implementan la capacidad de proporcionar un almacenamiento y recuperación de datos en base a claves, en este segmento deberían recordarse de las tablas de hashing como ejemplo de lo que son capaces de realizar.

Clases e interfaces de la API Collections del JD K 1.2

La API Collections del JDK 1.2 ha añadido 10 nuevas interfaces y 13 nuevas clases. Estas clases e interfaces adicionales ofrecen una API potente a la hora de trabajar con tipos diferentes de colecciones de objetos. Las interfaces de colecciones nuevas que JDK 1.2 ha introducido son:

Collection : Define métodos que implementan el concepto de un grupo de objetos, a los que se denomina elementos. La interfaz Collection se corresponde con un “saco” en el cual una colección permite que hallan objetos duplicados. Define un amplio espectro de métodos que sirven para agregar, quitar y recuperar objetos de la colección, además de métodos que operan en la propia colección.

List: Amplía la interfaz Collection con el objeto de implementar una colección ordenada de objetos. Dado que las listas están ordenadas, los objetos de la List pueden ser indexados. La interfaz ListIterator ofrece métodos para que se repitan los elementos de una lista.

Set: Amplía la interfaz Collection con el objeto de implementar un conjunto finito. Los conjuntos difieren de la lista en que no permiten elementos duplicados.

SortedSet: Un Set cuyos elementos están ordenados en orden ascendente.

Comparator: Ofrece el método compare() con el fin de comparar los elementos de una colección.

Iterator: Proporciona métodos para repetir los elementos de una colección. En el JDK 1.2, la interfaz Iterator sustituye a la interfaz Enumeration.

ListIterator: Amplía la interfaz Iterator con el fin de admitir la repetición bidireccional de listas.

Map: Reemplaza a la clase Dictionary como forma de asociar claves con valores.

SortedMap: Un Map cuyos elementos están ordenados en orden ascendente.

Map. Entry : Una interfaz interna de la interfaz Map que define métodos para trabajar con un par individual de clave-valor.

Existiendo otras más como LinkedList, ArrayList, HashSet, TreeSet, HashMap y otras.

EJEMPLOS VARIOS:

// Demo para ArrayList.

import java.util.*;

class ArrayListDemo {

public static void main(String args[]) {

// crea un array list

ArrayList al = new ArrayList();

System.out.println("Tamaño inicial del ArrayList: " +

al.size());

// agregar elementos al array list

al.add("C");

al.add("A");

al.add("E");

al.add("B");

al.add("D");

al.add("F");

al.add(1, "A2");

System.out.println("Tamaño del ArrayList, luego de...: " +

al.size());

// display el array list

System.out.println("Contenidos en ArrayList: " + al);

// Elimina elementos del array list

al.remove("F");

al.remove(2);

System.out.println("Tamaño del ArrayList luego de borrar: " +

al.size());

System.out.println("Contenido del ArrayList: " + al);

}

}

// Convertir un ArrayList en un array.

import java.util.*;

class ArrayList_Array {

public static void main(String args[]) {

// Crea un array list

ArrayList al = new ArrayList();

// Agrega elementos al array list

al.add(new Integer(1));

al.add(new Integer(2));

al.add(new Integer(3));

al.add(new Integer(4));

System.out.println("Contenido del ArrayList: " + al);

// obtener el array

Object ia[] = al.toArray();

int sum = 0;

// suma el array

for(int i=0; i<ia.length; i++)

sum += ((Integer) ia[i]).intValue();

System.out.println("La suma es: " + sum);

}

}

// Demo para LinkedList.

import java.util.*;

class LinkedListDemo {

public static void main(String args[]) {

// crea una linked list

LinkedList ll = new LinkedList();

// agrega elementos a la linked list

ll.add("F");

ll.add("B");

ll.add("D");

ll.add("E");

ll.add("C");

ll.addLast("Z");

ll.addFirst("A");

ll.add(1, "A2");

System.out.println("Contenido original de ll: " + ll);

// elimina elementos de la linked list

ll.remove("F");

ll.remove(2);

System.out.println("Contenido de la ll después de borrar: "

+ ll);

// elimina los elementos primero y ultimo

ll.removeFirst();

ll.removeLast();

System.out.println("ll despues de eliminar primero y ultimo: "

+ ll);

// obtener y setear un valor

Object val = ll.get(2);

ll.set(2, (String) val + " cambio");

System.out.println("ll despues de cambio: " + ll);

}

}

// Usando comparator para ordenar cuentas por apellido.

import java.util.*;

// Compara los string de los nombre.

class TComp implements Comparator {

public int compare(Object a, Object b) {

int i, j, k;

String aStr, bStr;

aStr = (String) a;

bStr = (String) b;

// hallar el indice del apellido

i = aStr.lastIndexOf(' ');

j = bStr.lastIndexOf(' ');

k = aStr.substring(i).compareTo(bStr.substring(j));

if(k==0) // apellido match, chequea el nombre entero

return aStr.compareTo(bStr);

else

return k;

}

}

class TreeMapDemo2 {

public static void main(String args[]) {

// Crea un tree map

TreeMap tm = new TreeMap(new TComp());

// elementos al map

tm.put("Juan Perez", new Double(3434.34));

tm.put("Tomas Contreras", new Double(123.22));

tm.put("Juan Palacios", new Double(1378.00));

tm.put("Teodoro Rosas", new Double(99.22));

tm.put("Rafael Sepulveda", new Double(-19.08));

// seteando la entrada

Set set = tm.entrySet();

// iterator

Iterator itr = set.iterator();

// Display los elementos

while(itr.hasNext()) {

Map.Entry me = (Map.Entry)itr.next();

System.out.print(me.getKey() + ": ");

System.out.println(me.getValue());

}

System.out.println();

// Depositamos 1000 en la cuenta de Juan Perez

double balance = ((Double)tm.get("Juan Perez")).doubleValue();

tm.put("Juan Perez", new Double(balance + 1000));

System.out.println("Nuevo balance de Juan Perez : " +

tm.get("Juan Perez"));

}

}

// Demo para ciertos algoritmos.

import java.util.*;

class AlgoritmosDemo {

public static void main(String args[]) {

// Crea e inicializa una linked list

LinkedList ll = new LinkedList();

ll.add(new Integer(-8));

ll.add(new Integer(20));

ll.add(new Integer(-20));

ll.add(new Integer(8));

// Crea un comparador en orden inverso

Comparator r = Collections.reverseOrder();

// ordena la lista usando el comparador

Collections.sort(ll, r);

// obtener el iterator

Iterator li = ll.iterator();

System.out.print("Lista ordenada: ");

while(li.hasNext())

System.out.print(li.next() + " ");

System.out.println();

Collections.shuffle(ll);

// display lista random

li = ll.iterator();

System.out.print("Lista barajada: ");

while(li.hasNext())

System.out.print(li.next() + " ");

System.out.println();

System.out.println("Minimum: " + Collections.min(ll));

System.out.println("Maximum: " + Collections.max(ll));

}

}

// Demo para varias operaciones con Vector.

import java.util.*;

class VectorDemo {

public static void main(String args[]) {

// tamaño inicial es 3, incrementando en 1

Vector v = new Vector(3, 1);

System.out.println("Tamaño Inicial: " + v.size());

System.out.println("Capacidad Inicial: " +

v.capacity());

v.addElement(new Integer(1));

v.addElement(new Integer(2));

v.addElement(new Integer(3));

v.addElement(new Integer(4));

System.out.println("Capacidad luego de 4 adiciones: " +

v.capacity());

v.addElement(new Double(5.45));

System.out.println("Capacidad actual: " +

v.capacity());

v.addElement(new Double(6.08));

v.addElement(new Integer(7));

System.out.println("capacidad Actual: " +

v.capacity());

v.addElement(new Float(9.4));

v.addElement(new Integer(10));

System.out.println("Capacidad Actual: " +

v.capacity());

v.addElement(new Integer(11));

v.addElement(new Integer(12));

System.out.println("Primer elemento: " +

(Integer)v.firstElement());

System.out.println("Ultimo elemento: " +

(Integer)v.lastElement());

if(v.contains(new Integer(5)))// pregunte por 3!!

System.out.println("Vector contiene 5.");

// enumera los elementos en el vector.

Enumeration vEnum = v.elements();

System.out.println("\nElementos en vector:");

while(vEnum.hasMoreElements())

System.out.print(vEnum.nextElement() + " ");

System.out.println();

}

}

// Demo para la clase Stack.

import java.util.*;

class StackDemo {

static void showpush(Stack st, int a) {

st.push(new Integer(a));

System.out.println("push(" + a + ")");

System.out.println("stack: " + st);

}

static void showpop(Stack st) {

System.out.print("pop -> ");

Integer a = (Integer) st.pop();

System.out.println(a);

System.out.println("stack: " + st);

}

public static void main(String args[]) {

Stack st = new Stack();

System.out.println("stack: " + st);

showpush(st, 42);

showpush(st, 66);

showpush(st, 99);

showpop(st);

showpop(st);

showpop(st);

try {

showpop(st);

} catch (EmptyStackException e) {

System.out.println("stack vacio.");

}

}

}

La clase Properties es una subclase de Hashtable que se utiliza para mantener listas de valores en las que la claves una cadena y el valor es también un objeto String.

/* Una guía telefonica en la cual se ingresan los numeros con sus respectivos

nombres. En la eventualidad que se le solicitara el numero correspondiente a un cliente,

bastara con ingresar el nombre y le saldra el numero.

*/

import java.io.*;

import java.util.*;

class LibroFonos {

public static void main(String args[])

throws IOException

{

Properties ht = new Properties();

BufferedReader br =

new BufferedReader(new InputStreamReader(System.in));

String nombre, numero;

FileInputStream fin = null;

boolean cambio = false;

// atrapando el archivo fono.dat.

try {

fin = new FileInputStream("fono.dat");

} catch(FileNotFoundException e) {

// ignorando archivos que no corresponden

}

/* si el archivo ya existe,

ingresa los numeros telef. existentes. */

try {

if(fin != null) {

ht.load(fin);

fin.close();

}

} catch(IOException e) {

System.out.println("Error al leer archivo.");

}

// usuario ingresa nuevos nombres y numeros.

do {

System.out.println("Ingrese nuevo Nombre" +

" ('quit' para Stop): ");

nombre = br.readLine();

if(nombre.equals("quit")) continue;

System.out.println("Ingrese Numero: ");

numero = br.readLine();

ht.put(nombre, numero);

cambio = true;

} while(!nombre.equals("quit"));

// Si el archivo tiene cambios, salvarlos.

if(cambio) {

FileOutputStream fono = new FileOutputStream("fono.dat");

ht.store(fono, "Guia Telefonica");

fono.close();

}

// Miremos el numero dado el nombre.

do {

System.out.println("Ingrese nombre a encontrar" +

" ('quit' to quit): ");

nombre = br.readLine();

if(nombre.equals("quit")) continue;

numero = (String) ht.get(nombre);

System.out.println(numero);

} while(!nombre.equals("quit"));

}

}

Un Set es un conjunto, en el cual no pueden aparecer elementos repetidos. Set tiene los mismos métodos como Collection. Standard-Implementación para Set son los HashSet (Array y los TreeSet (Arboles Binarios).

import java.util.*;

public class SetDemo

{

public static void main(String args [])

{

Set set = new HashSet();

set.add("Gerardo");

set.add("Tomas");

set.add("Michael");

set.add("Pedro");

set.add("Christian");

set.add("Valentina");

System.out.println(set);

Set sortedSet = new TreeSet(set);

System.out.println(sortedSet);

}

}