Colecciones

Colecciones

Interface Collection • add(o) Añade un elemento nuevo • clear() Elimina todos los elementos • contains(o) Comprueba membresía • IsEmpty() Comprueba si está vacío • iterator() Devuelve un iterator • remove(o) Elimina un elemento • size() Número de elementos

Interface List • add(i,o) Inserta o en la posición i • add(o) Añade o al final • get(i) Devuelve el i-ésimo elemento • remove(i) Eliminia e i-ésimo elemento • remove(o) Elimina el elemento o • set(i,o) Remplaza el i-ésimo elemento con o

Interface Map • Clear() Elimina todos las asociaciones • containsKey(k) Si contiene una asoc. para k • containsValue(v) Si contiene una asoc. para v • SetentrySet() Conjunto de pares de valores clave • get(k) Valor asociado con k • isEmpty() Si está vacío • keySet() Conjunto de claves • put(k,v) Asociar v con k • remove(k) Eliminar asoc. para k • size() Número de pares • values() Colección de valores

Colecciones concretas colección implementa descripción concreta HashSet Set hash table TreeSet SortedSet balanced binary tree ArrayList List resizable-array LinkedList List linked list Vector List resizable-array HashMap Map hash table TreeMap SortedMap balanced binary tree Hashtable Map hash table

Iterar sobre solecciones interface Iterator : interface Iterator { boolean hasNext(); Object next(); void remove(); } El método iterator() definido en la interface Collection: Iterator iterator()

Uso de Set Set set = new HashSet(); // instancia de un set concreto // ... set.add(obj); // inserta elementos // ... int n = set.size(); // obtiene tamaño // ... if (set.contains(obj)) {...} // verifica miembro // iterata a través del set Iterator iter = set.iterator(); while (iter.hasNext()) { Object e = iter.next(); // downcast e // ... }

Uso de Map Map map = new HashMap(); // instancia un map concreto // ... map.put(key, val); // inserta par llave-valor // ... // obteiene el valor asociado a la llave Object val = map.get(key); map.remove(key); // elimina par llave-valor // ... if (map.containsValue(val)) { ... } if (map.containsKey(kay)) { ... } Set keys = map.keySet(); // obtiene el conjunto de llaves // iterata a través del conjunto de llaves Iterator iter = keys.iterator(); while (iter.hasNext()) { Key key = (Key) iter.next(); // ... }

Cuenta palabras diferentes (I) import java.util.*; import java.io.*; public class CuentaPalabras { static public void main(String[] args) { HashSet words = new HashSet(); BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String delim = " \t\n.,:;?!-/()[]\"\'"; String line; int count = 0;

Cuenta palabras diferentes (II) try { while ((line = in.readLine()) != null) { StringTokenizer st = new StringTokenizer(line, delim); while (st.hasMoreTokens()) { count++; words.add(st.nextToken().toLowerCase()); } } } catch (IOException e) {} System.out.println("Numero total de palabras: " + count); System.out.println("Numero de palabras diferentes : " + words.size()); } }

Frecuencia Palabras (I) static class Count { Count(String word, int i) { this.word = word; this.i = i; } String word; int i; }

Frecuencia Palabras (II) import java.util.*; import java.io.*; public class FrecuenciaPalabras { static public void main(String[] args) { HashMap words = new HashMap(); String delim = " \t\n.,:;?!-/()[]\"\'"; BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String line, word; Count count;

Frecuencia Palabras (III) try { while ((line = in.readLine()) != null) { StringTokenizer st = new StringTokenizer(line, delim); while (st.hasMoreTokens()) { word = st.nextToken().toLowerCase(); count = (Count) words.get(word); if (count == null) { words.put(word, new Count(word, 1)); } else { count.i++; } } } } catch (IOException e) {}

Frecuencia Palabras (IV) Set set = words.entrySet(); Iterator iter = set.iterator(); while (iter.hasNext()) { Map.Entry entry = (Map.Entry) iter.next(); word = (String) entry.getKey(); count = (Count) entry.getValue(); System.out.println(word + (word.length() < 8 ? "\t\t" : "\t") + count.i); } } }

Orden y ordenamiento • Hay dos formas de definir orden entre objetos. • Cada clase puede definir un orden natural entre sus instancias implementando la interface Comparable. int compareTo(Object o) • Un orden arbitrario entre diferentes objetos se puede definir por comparadores, clases que implementan la interface Comparator. int compare(Object o1, Object o2)

Frecuencia Palabras2 public class FrecuenciaPalabras2 { static public void main(String[] args) { TreeMap words = new TreeMap(); .... < igual a FrecuenciaPalabras> } }

Orden definido por el usuario • Orden alfabético inverso de cadenas: public class StringComparator implements Comparator { public int compare(Object o1, Object o2) { if (o1 != null && o2 != null && o1 instanceof String && o2 instanceof String) { String s1 = (String) o1; String s2 = (String) o2; return - (s1.compareTo(s2)); } else { return 0; } } }

Frecuencia Palabras2_1 public class FrecuenciaPalabras2_1 { static public void main(String[] args) { TreeMap words = new TreeMap(new StringComparator( )); .... < igual a FrecuenciaPalabras2> }

Ordenamiento static class CountComparator implements Comparator { public int compare(Object o1, Object o2) { if (o1 != null && o2 != null && o1 instanceof Count && o2 instanceof Count) { Count c1 = (Count) o1; Count c2 = (Count) o2; return (c2.i - c1.i); } else { return 0; } } }

Frecuencia Palabras3 public class FrecuenciaPalabras3{ static public void main(String[ ] args) { < igual a FrecuenciaPalabras2> List list = new ArrayList(words.values()); Collections.sort(list, new CountComparator()); Iterator iter = list.iterator(); while (iter.hasNext()) { count = (Count) iter.next(); word = count.word; System.out.println(word + (word.length() < 8 ? "\t\t" : "\t") + count.i); } } }

Colecciones

Colecciones

Presentation Transcript