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
40.406683
-3.628032
Comentarios recientes