Colecciones Interfaces para colecciones

• En Java 1.2 se introduce un nuevo marco para las

colecciones. (En el paquete java.util)
• Basado en STL de C++
– Interfaces.
• Permiten manipular una colección independientemente de los
detalles de implementación.
– Implementación
• La estructura real
– Algoritmos
• Métodos que permiten realizar cómputos

1 3

Beneficios de utilizar el
Interfaces para colecciones
marco de colecciones
• Reduce los esfuerzos de programación • Permiten manipular las estructuras
• Incrementa velocidad y calidad • Hay operaciones opcionales, es decir, una
• Ayuda a la interoperabilidad implementación concreta pudiera no tenerla.
• Reduce los esfuerzos de aprendizaje • Todas las colecciones del JDK implementan
• Reduce los esfuerzos de diseño todas las operaciones opcionales
• Fomenta la reutilización de software • Si se invoca una operación no soportada se
lanza la excepción
UnsupportedOperationException

2 4

1
Interface Collection Interface Map y SortedMap

• Proporciona un protocolo mínimo para una • Map

colección. – Empareja claves con valores
– Cada clave puede emparejarse con a lo sumo un valor
• Suelen usarse Set y List que son
– No puede haber claves duplicadas
interfaces más especializados – Muy parecido al antiguo Hashtable
• SortedMap
– Versión de Map que mantiene las claves ordenadas

5 7

Interface Set, List y

Interface Collection
SortedSet
public interface Collection {
• Set // Operaciones basicas
int size();
– No permite tener elementos duplicados boolean isEmpty();
boolean contains(Object element);
• SortedSet boolean add(Object element); // Opcional
boolean remove(Object element); // Opcional
– Versión de Set que mantiene ordenados a los Iterator iterator();
elementos // Operaciones completas
boolean containsAll(Collection c);
boolean addAll(Collection c); // Opcional
• List boolean removeAll(Collection c); // Opcional
– También llamado secuencia boolean retainAll(Collection c);
void clear();
//
//
Opcional
Opcional
– Controla dónde se inserta cada elemento // Operaciones con Arrays
Object[] toArray();
– Es muy parecido al antiguo Vector Object[] toArray(Object a[]);
}

6 8

2
 Interfaces e
Interface Iterador
implementación
– Tiene una conducta mejorada que la del antiguo • Cada interface puede estar implementada por más
Enumeration de una clase
– Ahora se permite quitar elementos de la – Podemos utilizar una referencia a la interface para
colección con el iterador señalar a un objeto de una clase concreta
Collection c = new ArrayList();

public interface Iterator { – Todas estas clases tienen un constructor que admite un
boolean hasNext(); objeto que implemente la interface Collection
Object next(); Collection d = new ArrayList(c);
void remove(); // Opcional
} – ¿Cómo actúan estos constructores?

9 11

Un ejemplo de Iterator Interface Set I

• Filtrar los elementos que no cumplen una • La interface es igual a la de Collection

condición • No permite elementos duplicados
static void filtro(Collection c) {
– El control se hace por el método equals()
for (Iterator i = c.iterator(); i.hasNext(); )
if (!cond(i.next()))
• Hay dos implementaciones en JDK
i.remove(); – HashSet
}
• Guarda los datos en una tabla hash
– Es un código genérico para cualquier colección – TreeSet
que admita la eliminación de elementos • Guarda los datos en un árbol

10 12

3
Interface Set II Un ejemplo de uso de Set
public interface Set {
// Operaciones basicas • ¿Cómo eliminar de una colección c todos los
int size();
boolean isEmpty(); elementos duplicados?
boolean contains(Object element);
boolean add(Object element); // Optional Collection noDups = new HashSet(c);
boolean remove(Object element); // Optional
Iterator iterator();
// Operaciones completas Ejercicios.
boolean containsAll(Collection c);
boolean addAll(Collection c); // Optional
– ¿Cómo hacer la unión, intersección y diferencia de
boolean removeAll(Collection c); // Optional conjuntos?
boolean retainAll(Collection c);
void clear();
//
//
Optional
Optional – Crear un programa como el anterior pero que mantenga
// Operaciones con Arrays un conjunto con las repetidas y otro con las no repetidas
Object[] toArray(); – Llaves y cerraduras
Object[] toArray(Object a[]);
}

13 15

Ejemplo de Interface Set Interface List I

import java.util.*;
• Una colección de elementos también
public class FindDups {
public static void main(String args[]) { llamado secuencia
Set s = new HashSet();
for (int i=0; i<args.length; i++) – Puede haber elementos repetidos
if (!s.add(args[i])) – Acceso a la posición
System.out.println
(" duplicado: "+args[i]); – Devuelve la posición de un elemento buscado
System.out.println(s.size()+ – Permite iterar de una forma más especializada
" palabras detectadas: "+s); (Con un ListIterator)
}
} – Realiza operaciones con rango de índices

14 16

4
Interface List II Ejemplo de interface List
private static void swap(List a, int i, int j) {

• Hay dos implementaciones en JDK Object tmp = a.get(i);

a.set(i, a.get(j));
– ArrayList a.set(j, tmp);
• Consultas en cualquier posición }
public static void shuffle(List list, Random rnd) {
• Añadir por los extremos for (int i=list.size(); i>1; i--)
– LinkedList swap(list, i-1, rnd.nextInt(i));
• Consultas por los extremos }
import java.util.*;
• Añadir en cualquier posición public class Shuffle {
• El antiguo Vector implementa esta public static void main(String args[]) {
List l = new ArrayList();
interface for (int i=0; i<args.length; i++)
l.add(args[i]);
Collections.shuffle(l, new Random());
System.out.println(l);
}
}
17 19

Un array visto como una

Interface List III
lista
public interface List extends Collection {
// Acceso Posicional
Object get(int index);
• En java.util.Arrays existe el
Object set(int index, Object element);
void add(int index, Object element);
//
//
Opt.
Opt.
método
Object remove(int index); // Opt.
abstract boolean addAll(int index, Collection c);// Opt. static List asList(array)

// Busqueda import java.util.*;

int indexOf(Object o);
int lastIndexOf(Object o);
public class Shuffle {
// Iteracion
public static void main(String args[]) {
ListIterator listIterator(); List l = Arrays.asList(args);
ListIterator listIterator(int index); Collections.shuffle(l);
System.out.println(l);
// Vista de rango }
List subList(int from, int to); }

18 20

5
 Métodos especiales de
Interface ListIterator
LinkedList
public interface ListIterator extends Iterator {
boolean hasNext(); • Permiten el acceso por los extremos
Object next();
void addFirst(Object)
boolean hasPrevious(); void addLast(Object)
Object previous(); Object getFirst()
Object getLast()
int nextIndex();
int previousIndex();
Object removeFirst()
Object removeLast()
void remove(); // Optional
void set(Object o);
void add(Object o);
// Optional
// Optional • Para poder utilizarse
} LinkedList l = new LinkedList();

– Implementar una clase Pila y una clase Cola

21 23

Algoritmos de la clase
Collections aplicados a Interface Map I
List
• Métodos de clase • Mantiene claves y valores asociados
sort(List) • Las claves no pueden repetirse.
suffle(List) – Se controla por equals()
reverse(List)
fill(List,Object) • A lo sumo puede haber un valor por clave
copy(List dest, List src)
binarySearch(List,Object)
• Hay dos implementaciones en JDK
– HashMap
– TreeMap
• La antigua Hashtable implementa el interfaz
Map

22 24

6
Interface Map II Ejemplo de uso de Map
public interface Map { import java.util.*;
// Operaciones basicas public class Frecuencia {
Object put(Object key, Object value); private static final Integer UNO = new Integer(1);
Object get(Object key);
Object remove(Object key); public static void main(String args[]) {
boolean containsKey(Object key); Map m = new HashMap();
boolean containsValue(Object value); // Inicializa la tabla desde la linea de cmd
int size(); for (int i=0; i<args.length; i++) {
boolean isEmpty(); Integer freq = (Integer) m.get(args[i]);
m.put(args[i],
// Operaciones completas (freq==null ? UNO :
void putAll(Map t); new Integer(freq.intValue() + 1)));
void clear(); }
System.out.println(m.size()+" pal. distintas");
... System.out.println(m);
}
}
25 27

Interface Map III Ordenación I

....

// Vista como colecciones

• Orden natural de algunos tipos:
public Set keySet();
public Collection values(); Class Natural Ordering
public Set entrySet(); Byte signed numerical
Character unsigned numerical
// Interface para los elementos de entrada Long signed numerical
public interface Entry {
Object getKey();
Integer signed numerical
Object getValue(); Short signed numerical
Object setValue(Object value); Double signed numerical
} Float signed numerical
} String lexicographic
Date chronological

26 28

7
Ordenación II Ordenación Natural

• Si se intenta ordenar un tipo que no sabe ordenarse • Los objetos de una clase que implementen
se produce una excepción un orden natural pueden utilizarse para:
• ClassCastException
– Elementos en un set ordenado (SortedSet)
– Es posible definir una ordenación para cualquier tipo.
Dos maneras: – Claves en un map ordenado (SortedMap)
• Definiendo en la clase la interface Comparable (Ordenación – En listas que utilicen el método
natural) Collection.sort()
– int compareTo(Object o)
• Definiendo la interface Comparator • Todos las clases envoltorios (wrapper)
– int compare(Object o1, Object o2) tienen definido un orden natural
29 31

Ordenación por
Ejemplo de Comparable
Comparable
public interface Comparable { import java.util.*;
public int compareTo(Object o); •public class Persona implements
private String nombre;
Comparable {

} private int edad;

public Name(String nombre, int edad) {
• Define el orden natural para los objetos de una if (nombre==null)
clase throw new NullPointerException();
this.nombre = nombre;
positivo Si receptor > o
0 Si recentor = o this.edad = edad;
negativo Si receptor < o }
– Si no es posible se produce la excepción: public int compareTo(Object o) {
Nombre n = (Nombre)o;
ClassCastException
if (edad > n.edad) return 1
• Este método no debe entrar en contradicción con else if (edad == n.edad) return 0
else return -1;
equals() }
}
30 32

8
Ordenación por
Interface SortedSet II
Comparator
public interface Comparator { public interface SortedSet extends Set {
int compare(Object o1, Object o2); // Vistas de rangos
SortedSet subSet(Object fromElement, Object toElement);
} SortedSet headSet(Object toElement);
SortedSet tailSet(Object fromElement);
• Existen versiones de todas las funciones de
ordenación que toman un argumento más: // elementos finales
Object first();
– Un objeto que implementa la interface Object last();
Comparator // acceso al Comparator
• Son válidas las consideraciones hechas }
Comparator comparator();

anteriormente

33 35

Interface SortedSet I Interface SortedSet III

• Es un Set que mantiene sus elementos
ordenados en orden ascendente.
– El orden es:
• Natural o
• Definido en una Comparator en el momento de la
creación
– Por mantener los datos ordenados puede
proporcionar nuevos métodos
– Lo implementa TreeSet
• Para las colecciones que implemente la
interface SortedSet hay dos nuevos
constructores
– Uno toma un objeto que implemente la
interface Comparable y devuelve un
SortedSet vacío
– Otro toma un SortedSet y devuelve otro
SortedSet con los mismos elementos y en el
mismo orden

34 36

9
Interface SortedMap I Ejemplo de SortedMap
import java.util.*;
• Es muy parecido a SortedSet public class Frecuencia {
private static final Integer UNO = new Integer(1);
• Un SortedMap es un Map que mantiene public static void main(String args[]) {
sus claves en orden (natural o dado en la SortedMap m = new HashMap();
// Inicializa la tabla desde la linea de cmd
creación) for (int i=0; i<args.length; i++) {
Integer freq = (Integer) m.get(args[i]);
• Añade nuevos métodos m.put(args[i],
(freq==null ? UNO :
• Lo implementa TreeMap new Integer(freq.intValue() + 1)));
}
System.out.println(m.size()+" pal. distintas");
System.out.println(m);
}
}
37 39

Interface SortedMap II Decoradores

public interface SortedMap extends Map {
Comparator comparator(); • Clases envoltorios que añaden
SortedMap subMap(Object fromKey, Object toKey); funcionalidad a las colecciones
SortedMap headMap(Object toKey);
SortedMap tailMap(Object fromKey); – De solo lectura
Object first(); – De acceso sincronizado
Object last();
} – Para crear colecciones unitarias

38 40

10
 Colecciones de solo lectura
•Si se intenta una operación de modificación
UnsupportedOperationException

Collection unmodifiableCollection(Collection collection)

List unmodifiableList(List list)
Map unmodifiableMap(Map map)
Set unmodifiableSet(Set set)
SortedMap unmodifiableSortedMap(SortedMap map)

SortedSet unmodifiableSortedSet(SortedSet set)

41

Implementaciones
Implementaciones
Hash Resizable Balanced Linked
Table Array Tree List
Interfaces Set HashSet TreeSet
SortedSet TreeSet
List ArrayList LinkedList
Vector
Map HashMap TreeMap
HashTable
SortedMap TreeMap

42

11