Aplicació de les estructures d'emmagatzematge en la programació orientada a objectes.

  • Les col·leccions són objectes que referencien un conjunt d'objectes.
  • Es tracta d'estructures dinàmiques.
  • Qualsevol objecte pot ser emmagatzemat en una col·lecció.
  • Poden proveir o no l'ordenació d'elements, inserir i esborrar elements, tenir o no els elements duplicats...

L'iterador:

  • Modela el recorregut seqüencial a través dels elements de qualsevol col·lecció de forma abstracta.
  • Defineix una interfície estàndard que et lliura de conèixer els detalls de la representació interna del tipus de dades.
  • Tenim dos mètodes principals:
  • hasNext().
  • next().
  • remove() (opcional).

Per exemple:

Collection<T> coleccion = new ArrayList<>();

Iterator itr = coleccion.iterator();

while(itr.hasNext()) {

   T element = itr.next();

System.out.print(element + " ");

Col·leccions al JDK (Java Development Kit).

La interfície Collection identifica qualsevol col·lecció d'objectes, amb o sense duplicats.

  • Set: Hereta de Collection, però no permet la duplicació d'elements o objectes.
  • List: Hereta de Collection, permet tenir duplicats, expressa relacions d'ordre d'indexació i posició.
  • Map (taula de dispersió): no hereta ni de set ni de collection. Són col·leccions de parells clau-valor (K,V) (key, Value).

API.

Interfície set

Correspon a la definició matemàtica de conjunt (no es permeten duplicats).

La interfície és idèntica a la de Collection.

Els constructors han de crear una col·lecció sense duplicats, el mètode add no pot afegir un element que ja es trobi al set.

Implementacions de Set:

  • HashSet: Implementat amb una hash table (taula de dispersió). No té ordenació d'elements.
  • TreeSet (implementació de SortedSet), implementat utilitzant un arbre. Garanteix l'ordenació d'elements. Inclou mètodes per aprofitar l'ordre:
  • first().
  • last().
  • headSet(e).
  • tailSet(e).
  • subSet(e1,e2).

Exemple 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

  • Correspon a un grup d'elements que expressen una relació d'ordre lineal, l'un rere l'altre.
  • Permet duplicats.
  • Extén de la interfície Collection.
  • Accés als elements mitjançant índexs, com els arrays.
  • add (int, Object).
  • get(int).
  • remove(int).
  • set(int,Object).
  • indexOf(Object).
  • lastIndexOf(Object).
  • subList(int fromIndex, int toIndex).
  • Iterator especialitzat: ListIterator (next(), previous(), …)

Altres consideracions:

  • add (Object), afegeix al final de la llista.
  • remove (Object), elimina del principi de la llista.

Per a més informació, consulteu l'API.

Implementacions de List

  • ArrayList:
  • Llista implementada com un array.
  • Un element pot ser accedit, consultat, introduït o eliminat mitjançant el seu índex o rang (nombre d'elements que el precedeixen).
  • Permet un accés aleatori, molt ràpid als elements però realitza lentament les operacions d'introduir i eliminar al mig de la llista.

LinkedList:

  • Implementació basada en una llista doblement enllaçada.
  • Més eficient que l'ArrayList per a insercions i eliminacions, però és pitjor per accedir als elements.

Exemple 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);

 }

}

Exemple 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());

 }

}

Interfície Map

Un Map emmagatzema parelles clau/valor (hash).

Els elements s'anomenen entrades (entry). Cada entrada és una parella d'elements (k,v), on k és la clau i v és el valor.

entry = (k,v).

No permet duplicitats, per a una clau, un valor.

Quan s'afegeix una nova entrada, si ja existeix una entrada amb la mateixa clau, es sobreescriu el valor desat anteriorment.

Per a més informació, consulteu l'API.

Implementacions de Map

HashMap

Implementació basada en una hash table.

No ordena les parelles (clau,valor).

TreeMap

Implementació amb un arbre de cerca equilibrat red-black.

Les parelles (clau,valor) estan ordenades per clau.

Inclou mètodes per aprofitar l'ordre:

  • firstKey()
  • lastKey()
  • headMap(k)
  • tailMap(k)
  • subMap(k1, k2).

Per a més informació, podem consultar l'API.