Java Collection (java.util.Collection) es una de las interfaces raíz de Java el cual maneja "Collection" que en Java equivalen a estructuras de datos lo cuales contienen y procesan conjuntos de datos de tamaño variable o dinámico.
Un ejemplo claro es si tu aplicación guardar objetos del tipo "personas", con una implementación de la estructuras de datos usando Collection puedes guarda N cantidad de objetos de tipo "personas".
Existen varios subtipos de estructuras de datos que se manejan la interfaz Collection debido a esta clase no se le puede crear una instancia de forma directa sino a través de sus subtipos los cuales son los siguientes:
1-) Map Y HashMap
La interfaz Map define un objeto en el cual asocia una Clave (Key) a un valor. Un mapa no puede contener claves duplicadas y solo pueden estar asignados a un valor a la vez.
HashMap es una clase mas eficiente de la interfaz Map.
Código:
package ejemplocollection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class EjemploMap {
public static void main(String[] args) {
// Las claves o Keys son de tipo Strings
// los objetos son de tipo Strings
Map<string string=""> mMap = new HashMap<string string="">();
mMap.put("Ford", "Mustang");
mMap.put("Chevrolet", "Corsa");
mMap.put("Renault", "priz");
//Salida
for (String key : mMap.keySet()) {
System.out.println(key +" "+ mMap.get(key));
}
System.out.println("Modificando datos");
//Agregando un nuevo item al map
mMap.put("Ferrari", "Enzo");
// Eliminando un item al map
mMap.remove("Ford");
System.out.println("Nueva Salida:");
//Salida
for (String key : mMap.keySet()) {
System.out.println(key +" "+ mMap.get(key));
}
}
}
El código anterior es una muestra de la implementación de Maps usando HashMap, también existen otras implementaciones tales como:
- java.util.HashMap
- java.util.Hashtable
- java.util.EnumMap
- java.util.IdentityHashMap
- java.util.LinkedHashMap
- java.util.Properties
- java.util.TreeMap
- java.util.WeakHashMap
Ejemplo:
Map mapA = new Hashtable(); Map mapB = new TreeMap();
Si se quiere usar un Map que venga previamente ordenado se puede usar la clase SortedMap el cual es un subtipo de la interfaz Map con la ventataja que sus elementos se ordenan internamente.
El Sortemap ordena por defecto sus elementos de menor a mayor o se puede usar un objeto de la clase Comparator para indicarle en que orden se quiere los elementos.
Ejemplo de como crear un SortedMap:
SortedMap mapA = new TreeMap(); Comparator comparator = new MyComparator(); SortedMap mapB = new TreeMap(comparator);
2-) Listas, Arraylist y LinkedList
Las listas vienen representados por la interfaz List que permite guardar N cantidad de objetos en un contenedor de tamaño variable.
La interfaz Arraylist se implementa como un vector de tamaño modificable.
La interfaz LinkeList se implementa como una lista doble enlazada, se diferencia de la Arraylist porque tiene mejor rendimiento a la hora de agregar y remover elementos pero a sus vez los métodos set() y get () tienen peor rendimiento que la Arraylist.
Código:
package ejemplocollection;
import java.util.ArrayList;
import java.util.List;
public class EjemploList {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(2);
list.add(1);
list.add(4);
list.add(5);
list.add(6);
list.add(6);
for (Integer integer : list) {
System.out.println(integer);
}
}
}
Obviamente para implementar la lista puedes enviar cualquier tipo de dato u objeto entre los simbolos "<Tipo dato u objeto>"
List<String> list = new ArrayList<String>(); List<Double> list = new ArrayList<Double>(); List<Objeto_persona> list = new ArrayList<Objeto_persona>();
3-) Set
La clase Set es un subtipo de la clase Collection, representa un conjunto de objetos en los cuales cada objeto solo puedes existir una vez en el conjunto.
package ejemplocollection;
import java.util.HashSet;
import java.util.Set;
public class ejemploSet {
public static void main(String[] args) {
Set setA = new HashSet(); // se crea un Objeto de tipo set con el subtipo de HashSet
String elemento = "elemento 1";
setA.add(elemento); //Agrego un elemento al Set
System.out.println( setA.contains(elemento) );// Usando el metodo Contains puedo saber si existe el elemento o no, true si esta o false si no lo esta
Set<Integer> set = new HashSet<Integer>(); // Creo un Set de tipo Integer
set.add(1);
set.add(2);
set.add(3);
for(Integer var : set){//recorreo el conjunto
System.out.println(var);
}
}
}
Siendo Set una interfaz se necesita instanciar una implementación concreta de la interface para ser usada y viene representada por la siguientes clases:
- java.util.EnumSet
- java.util.HashSet
- java.util.LinkedHashSet
- java.util.TreeSet
Ejemplo:
Set setA = new EnumSet(); Set setB = new HashSet(); Set setC = new LinkedHashSet(); Set setD = new TreeSet();
Cada implementación tiene sus propias diferencias y sus propios comportamiento respecto al ordenamiento de sus elementos cuando se hace iteraciones y el tiempo que toma en la inserción o eliminación de elementos.
HashSet se apoya en HashMap lo que hace que no haya garantía cual es la secuencia de los elementos mientras se hacen iteracciones.
En cambio el LinkedHashSet garantiza que el orden de la iteración de los elementos sea el mismo orden con el cual fueron agregados.
TreeSet garantiza el orden de los elementos según como fueron agregados, obviamente también permite utilizar objetos como Comparator para reordenar la secuencia de sus elementos.
También se puede crear Set ordenados de forma interna usando la implementación SortedSet.
Ejemplo:
SortedSet setA = new TreeSet(); Comparator comparator = new MyComparator(); SortedSet setB = new TreeSet(comparator);
4-) Queue (Colas)
Queue es un subtipo de Collection que asume el comportamiento de una cola.
Ejemplo:
package ejemplocollection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
public class EjemploCola {
public static void main(String[] args) {
Queue queueA = new LinkedList();//Implementando con Likedlist
Queue queueB = new PriorityQueue(); //Implementado con PriorityQueue
queueA.add("elemento 1");
queueA.add("elemento 2");
queueA.add("elemento 3");
//Iteraciones usando la interfaz Iterator
Iterator iterator = queueA.iterator();
while(iterator.hasNext()){
String elemento = (String) iterator.next();
System.out.println(elemento);
}
//Iteraciones con el ciclo FOR
for(Object object : queueA) {
String elemento = (String) object;
System.out.println(elemento);
}
//Cola generica instanciables a cualquier tipo de dato u objeto
Queue<Integer> queue = new LinkedList<Integer>();
queue.add(1);
queue.add(2);
queue.add(3);
for(Integer INT : queue) {
System.out.println(INT);
}
}
}
5-) Deque (Bicolas)
Deque es otro subtipo Collection en la cual emula el comportamiento de una bicola, en el cual es esencialmente una cola en la cual se puede agregar elementos al inicio o al final.
package ejemplocollection;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedList;
public class ejemploBicola {
public static void main(String[] args) {
Deque dequeA = new LinkedList();
Deque dequeB = new ArrayDeque();
dequeA.add ("elemento 1"); //Usando este metodo todo elemento se agrega a la cola
dequeA.addFirst("element 2"); //Usando este metodo todo elemento se agrega al comienzo de la cola
dequeA.addLast ("element 3"); //Usando este metodo todo elemento se agrega al final de la cola
//Usando la interfaz Iterator
Iterator iterator = dequeA.iterator();
while(iterator.hasNext()){
String elemento = (String) iterator.next();
System.out.println(elemento);
}
//Usando el ciclo FOR
for(Object object : dequeA) {
String elemento = (String) object;
System.out.println(elemento);
}
//Bicola generica
Deque<Integer> deque = new LinkedList<Integer>();
deque.add(1);
deque.add(2);
deque.add(3);
for(Integer val : deque){
System.out.println(val);
}
}
}
6-) Stack (Pilas)Stack es otro subtipo de Collection y actúa como una pila, es decir, los datos ingresan y salen según el método "ultimo entrar es el primero en salir".
package ejemplocollection;
import java.util.Stack;
public class ejemploPila {
public static void main(String[] args) {
Stack stack = new Stack();
stack.push("1");
stack.push("2");
stack.push("3");
//Busca el objeto que esta en el tope en la pila ("3"),sin sacarlo de la pila.
Object objTop = stack.peek();
Object obj3 = stack.pop(); //la cadena "3" esta en el tope.
Object obj2 = stack.pop(); //la cadena "2" esta en el tope.
Object obj1 = stack.pop(); //la cadena "1" esta en el tope.
stack.push("1");
stack.push("2");
stack.push("3");
//Con el siguiente metodo retorna la posición de un valor dentro de la pila de abajo hacia arriba
int index = stack.search("3"); //index = 3
}
}
La clase Stack tiene los siguientes metodos:- El método push() coloca un elemento al elemento de una pila
- El método peek() retorna el elemento que esta en el tope de la pila pero sin removerlo.
- El método pop() retorna elemento que esta en el tope de la pila y lo remueve.
7-) Usando el metodo Collection.sort y Comparator
El metodo Collection.sort permite ordenar el conjunto de valores de menor a mayor en cualquier estructura que sea subtipo de Collection:
Ejemplo:
package ejemplocollection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ejemploSort {
public static void main(String[] args) {
List <Integer>list = new ArrayList<Integer>();
list.add(5);
list.add(4);
list.add(3);
list.add(7);
list.add(2);
list.add(1);
Collections.sort(list);
for (Integer integer : list) {
System.out.println(integer);
}
}
}
Tambien se puede usar la interfaz Comparator para crear tus propios criterios de ordenamiento
Ejemplo:
Clase que compara:
package ejemplocollection;
import java.util.Comparator;
public class Micomparador implements Comparator<Integer>{
public int compare(Integer o1, Integer o2) {
return (o1>o2 ? -1 : (o1==o2 ? 0 : 1));
}
}
Lista ordenada usando el comparador:
package ejemplocollection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ejemplolistaOrdenandacomparator {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(5);
list.add(4);
list.add(3);
list.add(7);
list.add(2);
list.add(1);
Collections.sort(list, new Micomparador());
for (Integer integer : list) {
System.out.println(integer);
}
}
}
Aquí resumo todas las estructuras de datos que derivan de la clase Collection y como pueden ser usadas.
Espero que les sea de utilidad y próximamente añadiré ejemplos mas avanzados
pusat taruhan sabung ayam di bali
ResponderEliminar