‘Collection’ en java 1.6


List: un conjunto de cosas
Set: cosas únicas
Map: cosas con un único ID (identificador)
Queues: cosas organizadas en orden a cómo deben ser procesadas.

Ordenado (Ordered): Significa que la colección se puede iterar en un orden específico no aleatorio.

Clasificado (Sorted): el orden de la colección es determinado acorde a unas reglas, basadas en las propiedades de los objetos que la componen. La ordenación natural: alfabética o numérica.

Comparable vs Comparator (artículo)

A través de la Interfaz ‘Comparable’ que define como la instancia de una clase puede ser comparada con otra (la clase persona se ordena por el nombre).

java.lang.Comparable
java.util.Comparator
int objOne.compareTo(objTwo)
int compare(objOne, objTwo)
Returns
negative if objOne < objTwo
zero if objOne == objTwo
positive if objOne > objTwo
Same as Comparable
You must modify the class whose instances you want to sort. You build a class separate from the class whose instances you want to sort.
Only one sort sequence can be created
Many sort sequences can be created
Implemented frequently in the API by:

String, Wrapper classes, Date, Calendar...
Meant to be implemented to sort instances of third-party classes.
public class Employee implements Comparable<Employee>
{
private String name;
private int age;

public Employee(String name, int age)
{
this.name = name;
this.age = age;
}

public int compareTo(Employee e)
{
//comparison strategy
}

public static void main(String[] args)
{
List<Employee> employeeList = new ArrayList<Employee>();
employeeList.add( new Employee("Tim", 10) );
employeeList.add( new Employee("Rolvin", 11) );
employeeList.add( new Employee("Gerald", 12) );

Collections.sort(employeeList);
}
}

A través de la interfaz ‘Comparator’: se pueden implementar otras clases que implementan otros tipos de ordenación (la clase persona se ordena por nombre, o por apellido o por edad).

public class SortByName implements Comparator<Employee>
{
public int compare(Employee e1, Employee e2)
{
//comparison strategy here
}
}
public class SortByAge implements Comparator<Employee>
{
public int compare(Employee e1, Employee e2)
{
//comparison strategy here
}
}
public static void main(String[] args)
{
List<Employee> employeeList = new ArrayList<Employee>();
employeeList.add( new Employee("Tim", 10) );
employeeList.add( new Employee("Rolvin", 11) );
employeeList.add( new Employee("Gerald", 12) );

Collections.sort(employeeList, new SortByName() );//sort by name;
Collections.sort(employeeList, new SortByAge() );//sort by age;

}

La interfaz List

Sus implementaciones son ordenadas por el index.

get(int index), indexOf(Object o), add(int index, Object obj)

ArrayList: es un array con la capacidad de crecer. Ofrece una rápida iteración y acceso. Ordered pero no Sorted.
Vector: lo mismo que ArrayList pero es Synchronized.
LinkedList: mantiene el orden de los objetos según su inserción. Más lento en la iteración que el ArrayList pero más rápido en la inserción y eliminación. Implementa la interfaz java.util.Queue, que proporciona los métodos:

java.util.Queue
peek(), poll(), and offer().

El método peek devuelve, pero no borra, la cabecera de la cola.
El método poll devuelve y borra la cabecera de la cola
El método add inserta un elemento a no ser que se supere la capacidad de la cola, en este caso se lanza una IllegalStateException.
El método offer es igual que add pero devuelve false si existe algun error en la insercción.

La interfaz Set

No permite duplicados.
HashSet: es ‘unsorted and unordered’ no se puede ni ordenar ni clasificar. Usa el hasCode() de los objetos para insertarlos. Para colecciones sin duplicados pero no importa el orden en que se recorran
LinkedHashSet: es una versión ordenada de HashSet. Ordena los elementos en función del orden de inserción.
TreeSet: usa la estructura de árbol Red-Black. Ordena los elementos según se insertan en orden ascendente. Implementa ‘NavigableSet’. Puedes personalizar la clasificación.

La interfaz Map

Tiene un único identificador para un valor. (key /value)
HashMap: es ‘unsorted and unordered’ no se puede ni ordenar ni clasificar. Permite la llave nula y múltiples valores nulos.
HashTable: similar a HashMap pero es Synchronized. Ningún elemento debe ser nulo. LinkedHashmap: mantiene el orden de inserción. TreeMap: Ordena los elementos según se insertan en orden ascendente. Implementa ‘NavigableSet’. Puedes personalizar la clasificación.

La interfaz Queue

Como una pila FIFO (First In – First Out).
PriorityQueue: es una lista de prioridades (Priority In – Priority Out). La prioridad viene determinada por la clasificación de los elementos.

CLASE
MAP
SET
LIST
ORDERED
SORTED
HashMap
X
 
 
NO
NO
HashTable
X
 
 
NO
NO
TreeMap
X
 
 
SORTED
By natural order or custom comparison rules
LinkedHashMap
X
 
 
By insertion order or last access order
NO
HashSet
 
X
 
NO
NO
TreeSet
 
X
 
SORTED
By natural order or

custom comparison rules
LinkedHashSet
 
X
 
By insertion order
NO
ArrayList
 
 
X
BY INDEX
NO
Vecctor
 
 
X
BY INDEX
NO
LinkedList
 
 
X
BY INDEX
NO
PriorityQueue
 
 
 
SORTED
By TO-DO order

ArrayList

Ventaja sobre un array: a) crece dinámicamente, b)inserción y búsqueda mejoradas.
Cómo ordenar un ArrayList:

ArrayList<String> stuff = new ArrayList<String>();
stuff.add("Denver");
stuff.add("Boulder");
stuff.add("Vail");
stuff.add("Aspen");
stuff.add("Telluride");
System.out.println("unsorted " + stuff);
Collections.sort(stuff);
System.out.println("sorted " + stuff);
unsorted [Denver, Boulder, Vail, Aspen, Telluride]
sorted [Aspen, Boulder, Denver, Telluride, Vail]

Utilizando la ordenación de los arrays.

Arrays.sort(arrayToSort)

Búsqueda en Arrays y Collection:
–   Utilizan el método BinarySearch(): Arrays.binarySearch(arrayList,”one”)
–   Las búsquedas satisfactorias devuelven un ‘int’ que representa el índice del elemento.
–   Las búsquedas no satisfactorias devuelven in ‘int’ que representa el punto de insercción.

Convertir Arrays en Listas

String[] sa = {"one", "two", "three", "four"};
List sList = Arrays.asList(sa);

Backed Collections

TreeMap<String, String> map = new TreeMap<String, String>();
map.put("a", "ant"); map.put("d", "dog"); map.put("h", "horse");
SortedMap<String, String> submap;
submap = map.subMap("b", "g"); // #1 create a backed collection
System.out.println(map + " " + submap); // #2 show contents
map.put("b", "bat"); // #3 add to original
submap.put("f", "fish"); // #4 add to copy
map.put("r", "raccoon"); // #5 add to original - out of range
// submap.put("p", "pig"); // #6 add to copy - out of range
System.out.println(map + " " + submap); // #7 show final contents
{a=ant, d=dog, h=horse} {d=dog}
{a=ant, b=bat, d=dog, f=fish, h=horse, r=raccoon} {b=bat, d=dog, f=fish}

TreeMap.subMap(desde el valor inicial, hasta el valor final);
La subcoleción registra las modificaciones realizadas en la colección a la que pertenece.
El dato insertado en la subcoleción también se registra en la colección.

headSet: Empieza al principio y termina en el dato pasado como parámetro.
TreeSet.headSet();                        TreeMap.headSet();

subSet: Indica cuando empieza y acaba con los parámetros.
TreeSet.subSet();                           TreeMap.subSet();

TailSet: desde el parámetro pasado como argumento hasta el final.
TreeSet.tailSet();                            TreeMap.tailSet();

Bibliografia:
http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html
– Libro:  SCJP Sun Certified Programmer for Java 6 Exam 310-065

Anuncios
‘Collection’ en java 1.6

2 comentarios en “‘Collection’ en java 1.6

  1. hernan dijo:

    Una correción, es buena la intención de las definiciones cortas, pero lleva a confusión,
    la palabra Set en inglés significa conjunto, y es diferente al concepto de Lista así que estas
    definiciones confunden

    List: un conjunto de cosas
    Set: cosas únicas

    Mejor sería poner

    List : una lista ordenada
    Set: un conjunto (y como tal sus elementos son únicos, no repetidos) sin orden

Los comentarios están cerrados.