Aplicación de las estructuras de almacenamiento en la programación orientada a objetos.
- Las colecciones son objetos que referencian a un conjunto de objetos.
- Se trata de estructuras dinámicas.
- Cualquier objeto puede ser almacenado en una colección.
- Pueden proveer o no el ordenamiento de elementos, insertar y borrar elementos, tener o no los elementos duplicados....
El iterador:
- Modela el recorrido secuencial a través de los elementos de cualquier colección de forma abstracta.
- Define una interfaz estándar que te libra de conocer los detalles de la representación interna del tipo de datos.
- Tenemos dos métodos principales:
- hasNext().
- next().
- remove() (opcional).
- Por ejemplo:
Collection<T> coleccion = new ArrayList<>();
Iterator itr = coleccion.iterator();
while(itr.hasNext()) {
T element = itr.next();
System.out.print(element + " ");
|
Colecciones en el JDK (Java Development Kit).
La interfaz Collection identifica cualquier colección de objetos, con o sin duplicado.
- Set: Hereda de Collection, pero no permite la duplicación de elementos o objetos.
- List: Hereda de Collection, permite tener duplicados, expresa relaciones de orden de indexación y posición.
- Map (tabla de dispersión): no hereda ni de set ni de collection. Són colecciones de pares llave-valor (K,V) (key, Value).
API.
Interfaz set
Corresponde a la definición matemática de conjunto (no se permiten duplicados).
La interfaz es idéntica a la de Collection.
Los constructores tienen que crear una colección sin duplicados, el método add no puede añadir un elemento que ya se encuentre en el set.
Implementaciones de Set:
- HashSet: Implementado con una hash table (tabla de dispersión). No tiene ordenación de elementos.
- first().
- last().
- headSet(e).
- tailSet(e).
- subSet(e1,e2).
Ejemplo TreeSet
package Colecciones;
import java.util.*;
public class TreeSet_Ejemplo {
public static void main(String[] args) {
Set<Integer> s = new TreeSet<>();
String numerosIntroducidos = new String();
for(String valor : args){
numerosIntroducidos += " " + valor;
}
System.out.println("Numeros introducido: " + numerosIntroducidos);
for (String arg : args) {
if (!s.add(Integer.parseInt(arg))) {
System.out.println("Duplicado detectado: " + arg);
}
System.out.println( s.size() + " Palabras diferentes detectadas: " + s);
}
}
}
|
Interfaz list
- Corresponde a un grupo de elementos que expresan una relación de orden lineal, uno tras el otro.
- Permite duplicados.
- Extiende de la interfaz Collection.
- Acceso a los elementos mediante índices, como los arrays.
- add (int, Object).
- get(int).
- remove(int).
- set(int,Object).
- indexOf(Object).
- lastIndexOf(Object).
- subList(int fromIndex, int toIndex).
- Iterator especializado: ListIterator (next(), previous(), …)
- Otras consideraciones:
- add (Object), añade al final de la lista.
- remove (Object), elimina del principio de la lista.
Implementaciones de List
- ArrayList:
- Lista implementada como un array.
- Un elemento puede ser accedido, consultado, introducido o eliminado mediante su índice o rango (número de elementos que lo preceden).
- Permite un acceso aleatorio, muy rápido a los elementos pero realiza lentamente las operaciones de introducir y eliminar al medio de la lista.
- LinkedList:
- Implementación basada en una lista doblemente enlazada.
- Más eficiente que el ArrayList para inserciones y eliminaciones, pero es peor para acceder a los elementos.
Ejemplo ArrayList
package Colecciones;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayList_Ejemplo {
public static void main(String args[]) {
List<Integer> l = new ArrayList<> ();
for (int i = 0; i < args.length; i++){
l.add(Integer.parseInt(args[i]));
}
System.out.println(l);
l.add(l.size(),Integer.parseInt(args[0]));
System.out.println(l);
Collections.shuffle(l);
System.out.println(l);
Collections.shuffle(l);
System.out.println(l);
}
}
|
Ejemplo LinkedList
package Colecciones;
import java.util.*;
public class LinkedList_Ejemplo {
private LinkedList<Integer> list = new LinkedList<>();
public void push (Integer o){
list.addFirst(o);
}
public Object top(){
return list.getFirst();
}
public Object pop (){
return list.removeFirst();
}
public static void main(String args[]) {
LinkedList_Ejemplo s = new LinkedList_Ejemplo();
s.push(1);
s.push(2);
s.push(3);
s.push(5);
s.push(4);
System.out.println(s.list.toString());
System.out.println(s.pop()); // Saca el último número introducido.
System.out.println(s.list.toString());
System.out.println(s.top()); // Muestra el último número introducido
System.out.println(s.list.toString());
}
}
|
Interfaz Map
Un Map almacena parejas llave/valor (hash).
Los elementos se llaman entradas (entry). Cada entrada es una pareja de elementos (k,v), donde k es la llave y v es el valor.
entry = (k,v).
No permite duplicidades, para una llave, un valor.
Cuando se añade una nueva entrada, si ya existe una entrada con la misma llave, se sobreescribe el valor guardado anteriormente.
Implementaciones de Map
HashMap
Implementación basada en una hash table.
No ordena las parejas (llave,valor).
TreeMap
Implementación con un árbol de búsqueda equilibrado red-black.
Las parejas (clave,valor) están ordenadas por llave.
Incluye métodos para aprovechar el orden:
- firstKey()
- lastKey()
- headMap(k)
- tailMap(k)
- subMap(k1, k2).
Cap comentari :
Publica un comentari a l'entrada