class: center, middle, first # Software-Entwicklung 2 ### Collections --- # Fragen? > Fragen zur letzten Vorlesung? --- # Nachdenkzettel Interfaces und Applikationsarchitektur Zwei Gruppen zeigen und erklären ihre Nachdenkzettel zu dem Thema! --- # Themen - Collections Einsatzgebiete `Collection`s * `List`s * `Set`s Maps Iterator Utilityklassen Einsatzgebiete & Performance --- # Einsatzgebiete: Elemente gleiche Typs verwalten Eine Bank "hat" Kunden. Ein Brettspiel "hat" Figuren usw. Überall wo Sie im UML Klassendiagramm eine 1 zu * Beziehung haben, brauchen Sie ein Containerobjekt für die "*" Elemente. Containerobjekte nehmen viele Objekte auf (wieviele eigentlich??) Basistypen * `Collection` * `Map` Diverse Implementierungen * Warum? --- # Use Cases für Collections
--- # Basisschnittstellen * **Basisoperationen** zum Erfragen der Elementanzahl und zum Hinzufügen, Löschen, Selektieren und Finden von Elementen * **Mengenoperationen**, um etwa andere Sammlungen einzufügen * **Feldoperationen** bei Collection, um die Sammlung in ein Array zu konvertieren, und bei Map in Operationen, um alternative Ansichten von Schlüsseln oder Werten zu bekommen. --- # Collection Hierarchy
--- # Map Hierarchy
--- # Sonderwünsche? 1. Sollen die Größe während der Entwicklungszeit konfiguriert werden oder sich automatisch anpassen? 2. Wollen wir Typsicherheit bei den Elementen der `Collection`/`Map`? (➡️ Überraschungen vermeiden..) 3. Effizienz auch beim unterschiedlichem Umgang mit den Methoden der `Collection`s (Einfügen, Suchen, Hinzufügen, Entfernen..) 4. Schnelle Verarbeitung der Elemente? 5. Beliebig viele Elemente sollen verwaltet werden können ??? zu 1 und 2: C/M sind memory- und typsicher! zu 3: Dafür gibt es die verschiedenen Implementationen! zu 4: Hm, schauen wir uns das Iterieren über Collections mal an! zu 5: Large-scale distributed key/value stores und stream-Prozessoren! --- # Collections .center[![Center-aligned image](img/collections/collection_interface.png)] _Quelle: http://openbook.rheinwerk-verlag.de/javainsel/16_003.html#u16.1 __ --- # Erstes Beispiel für eine Collection ```java public class MyFirstCollection { private static void fill( Collection
collection ) { collection.add( "Juvy" ); collection.add( "Tina" ); collection.add( "Joy" ); } public static void main( String[] args ) { List
c = new LinkedList
(); fill( c ); System.out.println( c ); // [Juvy, Tina, Joy] Collections.sort( c ); System.out.println( c ); // [Joy, Juvy, Tina] } } ``` _Quelle: http://openbook.rheinwerk-verlag.de/javainsel/16_001.html#u16.1.1 __ --- # Grundsätzlich den Interface Typ verwenden! ```java List
c = new LinkedList
(); ``` > Links vom `=` steht der Interface-Typ, **nicht** die konkrete Klasse! Wenn Sie das so machen, können Sie mit **einer** Änderung im Code eine `LinkedList` durch eine `ArrayList` ersetzen und der Rest bleibt gleich! ```java private static void fill( Collection
c ) ``` > `fill` erklärt sich bereit sogar alles vom Interface Typ "`Collection`" zu akzeptieren. Welcher Typ von `Collection` kann neben `ArrayList` und `LinkedList` dadurch auch noch verarbeitet werden? Tipp: Collection Hierarchy anschauen... _Quelle: http://openbook.rheinwerk-verlag.de/javainsel/16_001.html#u16.1.1 __ --- # Listen Berücksichtigung der Einfüge-Reihenfolge Doppelte Elemente möglich Implementierungen * `ArrayList` * `LinkedList` * `CopyOnWriteArrayList` * (`Vector`) ➡️ veraltet --- # Mengen (Sets) * Keine doppelten Elemente * (Meist) unsortiert Implementierungen * `HashSet` * `TreeSet` * `LinkedHashSet` * `EnumSet` * `CopyOnWriteArraySet` --- # Maps .center[![Center-aligned image](img/collections/maps.png)] _Quelle: http://openbook.rheinwerk-verlag.de/javainsel/16_003.html#u16.3 __ --- # Maps * Assoziativ-Speicher, besser: Key-Value-Store * Zugriff auf Werte mit Schlüssel-Objekt * Implementierungen: * `HashMap` * `TreeMap` * Einfügen mit `put(key, value)` * Holen mit `get(key)` --- # Maps - Beispiel ```java Map
map = new HashMap
(); Point p1 = new Point( 10, 20 ); map.put( p1, "Point p1" ); Point p2 = new Point( 10, 20 ); System.out.println( map.get( p2 ) ); // ?? ``` _Quelle: http://openbook.rheinwerk-verlag.de/javainsel/16_003.html#u16.3 __ --- # Iterator Liest alle enthaltenen Elemente unabhängig der Datenstruktur aus Zentrale Methoden: * `hasNext()` * `next()` --- # Iterator - Beispiel ```java Collection
numbers = new LinkedList
(); numbers.add("28"); numbers.add("49"); numbers.add("8"); numbers.add("32"); Iterator
iter = numbers.iterator(); while(iter.hasNext()){ System.out.println(iter.next()); } ``` --- # Utilityklasse `Collections` Enthaltene Algorithmen: * sortieren, mischen, kopieren, füllen etc. * suchen & finden * Extremwerte bestimmen * Elemente ersetzen * Wrapper um existierende Datenstrukturen legen Alle Methoden sind statisch! --- # Was heißt Objekte einer Klasse "sortieren"? Ein Objekt einer Klasse fragen, ob es > größer > kleiner > oder gleich wie ein anderes Objekt der gleichen Klasse ist! Dazu muss das Objekt eine Methode haben, die die Werte seiner Attribute mit denen des anderen Objekts vergleichen kann --- # Sortierfähigkeit in meiner Klasse implementieren Zwei Möglichkeiten die Sortierfähigkeit zu implementieren: * Interface `Comparable` (eigene Klassen) * Klasse, die `Comparator` implementiert (fremde und eigene Klassen) --- # Comparable Interface ``` Java class Student implements Comparable
{ private int matNo; //Matrikelnummer private int age; public int compareTo(Student st){ if(age == st.getAge()) return 0; else if(age < st.getAge()) return 1; else return -1; } } ``` > `Collections.sort(ArrayList
myList)` verwendet dann `compareTo()` um die Studierenden zu sortieren. --- # Einsatzgebiete |Collection type|Functionality|Typical uses| |--- |--- |--- | |List|Essentially a variable-size array; You can usually add/remove items at any arbitrary position; The order of the items is well defined (i.e. you can say what position a given item goes in in the list).|Most cases where you just need to store or iterate through a "bunch of things" and later iterate through them.| |Set|Things can be "there or not"— when you add items to a set, there's no notion of how many times the item was added, and usually no notion of ordering.|Remembering "which items you've already processed", e.g. when doing a web crawl; Making other yes-no decisions about an item, e.g. "is the item a word of English", "is the item in the database?" , "is the item in this category?" etc.| |Map|Stores an association or mapping between "keys" and "values"|Used in cases where you need to say "for a given X, what is the Y"? It is often useful for implementing in-memory caches or indexes. For example: For a given user ID, what is their cached name/User object? For a given IP address, what is the cached country code? For a given string, how many instances have I seen?| |Queue|Like a list, but where you only ever access the ends of the list (typically, you add to one end and remove from the other).|Often used in managing tasks performed by different threads in an application (e.g. one thread receives incomming connections and puts them on a queue; other "worker" threads take connections off the queue for processing); For traversing hierarchical structures such as a filing system, or in general where you need to remember "what data to process next", whilst also adding to that list of data; Related to the previous point, queues crop up in various algorithms, e.g. build the encoding tree for Huffman compression.| _Quelle: http://www.javamex.com/tutorials/collections/how_to_choose.shtml __ --- # Performance > http://bigocheatsheet.com/ --- class: center, middle # Fragen?