Inhaltsverzeichnis
- Die Vorstellung
- Zum Beispiel
- Die Beschränkungen der Benutzung von Array- Eine Hinweise zur Problemslösung
- Die Überblick von Java Collections Framework
-
Die Gruppe von Collection
- Die Interface in der Gruppe von Collection
- java.util.Collection Interface
- Die Elemente von der Kollektion durchsuchen
- Der Zweige der Kollektion
- java.util.List Interface
- java.util.Set Interface
- java.util.Queue Interface
- Die Inheritance Beziehung in der Klasse der Gruppe Collection
- java.util.ArrayList
- java.util.Vector
- java.util.SortedSet
- Die Gruppe von Map
Die Anleitung zu Java Collections Framework
View more Tutorials:
- Die Vorstellung
- Zum Beispiel
- Die Beschränkungen der Benutzung von Array- Eine Hinweise zur Problemslösung
- Die Überblick von Java Collections Framework
-
Die Gruppe von Collection
- Die Interface in der Gruppe von Collection
- java.util.Collection Interface
- Die Elemente von der Kollektion durchsuchen
- Der Zweige der Kollektion
- java.util.List Interface
- java.util.Set Interface
- java.util.Queue Interface
- Die Inheritance Beziehung in der Klasse der Gruppe Collection
- java.util.ArrayList
- java.util.Vector
- java.util.SortedSet
- Die Gruppe von Map


package org.o7planning.tutorial.javacollection.helloworld; import java.util.LinkedList; public class HelloLinkedList { public static void main(String[] args) { // LinkedList erstellen LinkedList<String> list = new LinkedList<String>(); // Ein Element in die Liste einfügen. list.add("F"); list.add("B"); list.add("D"); list.add("E"); list.add("C"); // Ein Element am Ende der Liste einfügen. list.addLast("Z"); // Ein Element an die erste Stelle der Liste. list.addFirst("A"); // Ein Element an die Stelle, deren Index 1 ist, einfügen. list.add(1, "A2"); // Alle Elemente der Liste aufschreiben: System.out.println("Original contents of list: " + list); // Ein Element aus der Liste entwerfen list.remove("F"); // Die Element in die Stelle mit Index 2 entwerfen. list.remove(2); // Die Liste nach der Löschung von 2 Elemente drucken. System.out.println("Contents of list after deletion: " + list); // Das erste und letzte Element in die Liste entwerfen. list.removeFirst(); list.removeLast(); // Die Liste nach der Löschung ausdrucken. System.out.println("List after deleting first and last: " + list); // Das Elemetn in der Index 2 ausnehmen. Object val = list.get(2); // Das Element in die Stelle mit Index 2 wieder setzen. list.set(2, (String) val + " Changed"); System.out.println("List after change: " + list); } }

package org.o7planning.tutorial.javacollection.helloworld; import java.util.HashMap; public class HelloHashMap { public static void main(String[] args) { // Ein Objekt HashMap zur Speicherung der Paare erstellen, // das sind die Code der Arbeitnehmer und das Gehalt. // String key: Die Arbeitnehmerscode // Float value: Das Gehalt. HashMap<String, Float> salaryMap = new HashMap<String, Float>(); salaryMap.put("E01", 1000f); salaryMap.put("E02", 12000f); salaryMap.put("E03", 12300f); salaryMap.put("E04", 1000f); salaryMap.put("E05", 300.5f); // Das Gehalt des Arbeitnehmer 'E02' ausnehmen Float salary= salaryMap.get("E01"); System.out.println("Salary of employee E01 = "+ salary); // Das Gehalt für den Arbeitnehmer 'E05' aktuallisieren salaryMap.put("E05", 400f); System.out.println("Salary of employee E05 = "+ salaryMap.get("E05")); } }

- Array ist sehr basic und gewöhnlich .
- die Reference Type und die primitive Type speichern
- int[] myArray=new int[]{1,4,3};
- Object[] myArrayObj =new Object[]{"Object",new Integer(100)};
- Array hat eine feste Größe und die Dimensionsanzahl.
- schwierige Array Ausweiterung
- Die Elemente werden aufeinander folgend in dem Speicher gelegt und verwiesen.
- schwierig, ein Element aus Array zu löschen

Es ist so klar, dass Array ist nicht gut für viele Falle von Applikation
Sehen Sie die Eigenschaften von LinkedList:
- Die Elemente im List können unterbrochen in dem Speicher liegen .
- Das ist eine zweiseitige Verbindung zwischen Elementen.
- Jede Elemente in List nimmt eine Reference um die Element vor ihr und nach ihr zu verweisen .

Wie eine Warteschlange braucht jede Person zwei Personnen erinern, wer vor und hinter sie stehen
Ein Elemente aus LinkedList löschen ist gleich wie ein Person aus eine Warteschlange entziehen. Die 2 Personen, wer neben die entgezogen Person stehen, sollen die Information von der Personnen aktuellisieren, wer vor und nach ihnen stehen.


Beachten Sie: LinkedList ist eine der Beschränkungslösung von Array. ArrayList ist Verwaltung der Datencollection, löscht die Beschränkungen von Array aber die Verwaltungsmethode ist unterschiedlich.

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
4.2- Die zwei Hierarchiesystem, die durch die 2 Interface Collection und Map geführt werden - Die Methode zur Daten Lagerung
- Die Collection für die Speicherung der Object.
- 3 untergeordnete Zweige in Collection: Queue, List, Set .
- die Elemente können gleich sein oder unabhängig von 3 obengenannten Zweige (wird später gemeint) .
- Die gruppe Map für die Speicherung der Paar key/value
- Die Paar key/value im Map haben immer die unterschiedlichen key zwischen die PaarenWe
- Key kann die angemessene Wert value nehmen .

Collection<String> c=new ArrayList<String>(); // Ein Element in der Kollektion einfügen. c.add("One"); Map<Integer,String> m=new LinkedHashMap<Integer,String>(); Integer key=new Integer(123); String value="One two three"; // Ein Paar 'key/value' in Map m. einfügen // Wenn 'key' schon existiert, wird 'value' durch eine neue Wert ersetzt. m.put(key,value); // Die 'key' entsprechende Wert ausdrucken System.out.println(m.get(new Integer(123));
- java.util.Iterator
- wie eine Schleife Maschine um die Daten zu erhalten, abwechselnder Zugang der Elemente.
- java.util.RandomAccess
- der zufällige Zugang, zum Beispiel für die Elemente Position und Entziehung dieser Element aus Collection
- Beispiel java.util.Vector implementieren auf diese interface, das die Elemente zufällig auf vector.get(int index) nehmen.
- Die Collection kann abwechselnd durch Aufruf der Methode iterator() zugreiffen um die Object Iterator zu nehmen.
- java.util.Collection wird aus interface java.lang.Iterable (kann geschleift werden) ausgeweitert. Deshalb erbt es die Methode public Iterator<E> iterator(), die Schleife Iterator für die Zustimmung der Elemente von Collection .

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
zugreiffen.
Notiz: Für die Object in List können Sie die Object ListIterator entnehmen, diese Schleife genehmigt Ihnen vorwärts oder rückwärts den Mauszeiger zu bewegen statt nur Mauszeiger vorwärts wie Iterator.


public interface Collection<E> extends java.lang.Iterable<E> { // // Add element to collection // return true if this collection changed as a result of the call // boolean add(E o); // // Adds all of the elements in the specified collection to this collection. // return true if this collection changed as a result of the call // boolean addAll(Collection<? extends E> c); // Removes all of the elements from this collection (optional operation). // The collection will be empty after this method returns. void clear(); // Returns true if this collection contains the specified element. boolean contains(Object o); // Returns true if this collection contains all of the elements // in the specified collection. boolean containsAll(Collection<?> c); // Compares the specified object with this collection for equality boolean equals(Object o); int hashCode(); // Returns true if this collection contains no elements. boolean isEmpty(); // // Removes a single instance of the specified element from this // collection, if it is present (optional operation). // boolean remove(Object o); // Removes all of this collection's elements that are also contained in the // specified collection (optional operation) boolean removeAll(Collection<?> c); // // Retains only the elements in this collection that are contained in the // specified collection (optional operation) // boolean retainAll(Collection<?> c); // Returns the number of elements in this collection int size(); // Returns an array containing all of the elements in this collection Object[] toArray(); <T> T[] toArray(T[] a); // Returns an iterator over the elements in this collection. Iterator<E> iterator(); }

package org.o7planning.tutorial.javacollection.collection; import java.util.Collection; import java.util.Iterator; import java.util.Vector; public class CollectionAndIterator { public static void main(String[] args) { // Ein leeres Collection Objekt. // Eine Kollektion enthaltet nur String. Collection<String> coll = new Vector<String>(); coll.add("Collection"); coll.add("Queue"); coll.add("List"); coll.add("Map"); // Die Anzahl der Elemente der Kollektion ausdrucken. System.out.println("Size:" + coll.size()); // Das Objekt Iterator um in die Element der Kollelktion zuzugreifen. // Das Objekt Iterator enthaltet nur String. Iterator<String> ite = coll.iterator(); // Prüfen Sie, ob Iteractor das nächste Element hat oder nicht? while (ite.hasNext()) { // Das Element in der Stelle des Mauzeiger danach bewegen Sie den Mauszeiger 1 Schritt String s = ite.next(); System.out.println("Element:" + s); } } }



java.util.Queue | java.util.List | java.util.Set |
Die überschlappten Elementen enthalten dürfen | Die überschlappten Elementen enthalten dürfen | Die überschlappten Elementen enthalten nicht dürfen |
die Element null enthalten nicht dürfen | die Elemente null enthalten dürfen | Die Abhängigkeit von der Klasse, die Set implementiert, unterstützt das null Element oder nicht. Wenn ja, enthaltet es nur am meisten ein Null Element |
List
Queue

Set

Achtung: SortedSet ist eine Sub-Interface von Set, die die angeordneten Elementen enthalten
- Die doppelte Elemente genehmigen
- 0 oder viele Elemente null genehmigen.
- Eine sequentielle Collektion .
// Das Objekt ListIterator zurückgeben um die Elemente der Liste durchzusehen. public ListIterator<E> listIterator() // Das Objekt ListIterator zurückgeben um die Elemente // von der bestimmten Stelle (mit 'index') zu der Ende der Liste durchzusuchen public ListIterator<E> listIterator(int index)
package org.o7planning.tutorial.javacollection.list; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class ListAndListIterator { public static void main(String[] args) { // Ein Objekt List erstellen (nur String enthalten). List<String> list = new ArrayList<String>(); list.add("One"); list.add("Two"); list.add("Three"); list.add("Four"); // Das Objekt ListIterator nehmen um die Elemente der Liste durchzusuchen. // (Nach der Anordnung). ListIterator<String> listIterator = list.listIterator(); // Der Mauszeiger steht in der ersten Position vom Iterator. // in die Stelle mit Index 0 stehen // das erste Element im Iterator nehmen, der Mauszeiger bewegt einen Schritt vorwarts. String first = listIterator.next(); System.out.println("first:" + first);// -->"One" // Jetzt steht der Mauszeiger in die Stelle mit der Index 1. // das nächste Element herausnehmen. String second = listIterator.next(); System.out.println("second:" + second);// -->"Two" // Prüfen, ob der Mauszeiger einen Position rückwärts bewegen kann oder nicht. if (listIterator.hasPrevious()) { // Einen Schritt rückwärts springen String value = listIterator.previous(); System.out.println("value:" + value);// -->"Two" } System.out.println(" ----- "); while (listIterator.hasNext()) { String value = listIterator.next(); System.out.println("value:" + value); } } }


- Bezeichnung einer Collection, die keine identischen Elemente enthalten darf
- Die Elemente null enthalten können, und nur ein Elemente null wenn ja
package org.o7planning.tutorial.javacollection.set; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class HashSetExample { public static void main(String[] args) { // Ein Objekt Set mit der initialen Kapazität von 10 Elemente. // Wenn die Anzahl der Elemente mehr als die Kapazität ist, // wird die Kapazität sich automatikal 80% erhöhen // Die Eigenschaften vom HashSet liegt darin, // dass das später eingefügte Element erst stehen wird. Set<String> set = new HashSet<String>(10, (float) 0.8); set.add("One"); set.add("Two"); // Wenn die Überlappung passiert. // Mit dem HashSet: Es fügt das neue Element ein und löscht das alte Element set.add("One"); set.add("Three"); Iterator<String> it = set.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }

- Eine collection genehmigt die identischen Elementen.
- Keine Elemente null.enthalten
- java.util.LinkedList
- java.util.PriorityQueue
PriorityQueue speichert die Elemente nach der natürlichen Reihe von Elemente (Wenn die Elemente sind Comparable Type), oder nach der Comparator , der für die PriorityQueue.gesetzt wird
Throws exception | Returns special value | |
Insert | add(e) |
offer(e) |
Remove | remove() |
poll() |
Examine | element() |
peek() |
boolean add(E)

boolean offer(E)

E remove()

E poll()

E element()

E peek()

Bewerten
package org.o7planning.tutorial.javacollection.queue; import java.util.LinkedList; import java.util.Queue; public class QueueDemo { public static void main(String[] args) { Queue<String> names = new LinkedList<String>(); // offer(E): ein Element in die Warteschlange einfügen (queue). // Mit der Warteschlange LinkedList wird das Element am Ende des Warteschlange eingefügt. // Es ist true wenn erfolgreich. // Es ist false wenn die Warteschlange keinen Platz hat. names.offer("E"); names.offer("A"); names.offer("M"); // add(E): das Element in die Warteschlange einfügen. // Mit der Warteschlange LinkedList wird das Element am Ende des Warteschlange eingefügt // Es ist true wenn erfolgreich // Eine Ausnahme wird geworfern wenn die Warteschlange keinen Platz hat. // names.add("G"); names.add("B"); while (true) { // Das erste Element aus der Warteschlange herausnehmen und löschen // Es gibt null rück wenn es keine Elemente in der Warteschlange gibt. String name = names.poll(); if (name == null) { break; } System.out.println("Name=" + name); } } }

package org.o7planning.tutorial.javacollection.queue; import java.util.PriorityQueue; import java.util.Queue; public class PriorityQueueDemo { public static void main(String[] args) { // Mit der Warteschlange (queue) PriorityQueue werden // die Elemente nach der natürlichen Anordnung gestellt. Queue<String> names = new PriorityQueue<String>(); // offer(E): die Elemente in die Warteschlange einfügen (queue). // Es ist true wenn erfolgreich. // Es ist false wenn die Warteschlange keinen Platz hat. names.offer("E"); names.offer("A"); names.offer("M"); // add(E): ein Element in der Warteschlange einfügen (queue). // Es ist true wenn erfolgreich // Eine Ausnahme wird geworfern wenn die Warteschlange keinen Platz hat. names.add("G"); names.add("B"); while (true) { // poll(): Das erste Element aus der Warteschlange herausnehmen und löschen // Es gibt null rück wenn es keine Elemente in der Warteschlange gibt. String name = names.poll(); if (name == null) { break; } System.out.println("Name=" + name); } } }


Implementations
|
|||||||
Hash Table | Resizable Array | Balanced Tree | Linked List | Hash Table + Linked List | |||
Interfaces | Set | HashSet | TreeSet | LinkedHashSet | |||
List | ArrayList |
package org.o7planning.tutorial.javacollection.list; import java.util.ArrayList; public class ArrayListDemo { public static void main(String[] args) { // Ein Objekt ArrayList zur Enthaltung der Integer Element erstellen. ArrayList<Integer> list = new ArrayList<Integer>(10); // Die Element einfügen list.add(123); list.add(245); list.add(new Integer(345)); // ArrayList erlaubt, das null Element einzufügen (die Eigenschaft von List) list.add(null); // Die Anzahl des Element im ArrayList ausdrucken. System.out.println("Size:" + list.size());// =4 // Der random Zugang zum Element der Index 1. Integer i = list.get(1); System.out.println("Element index 1 =" + i);// =245 Integer newInt = 1000; // Das Element in der Stelle mit Index 1 ersetzen. // Die Methode gibt das alte Element rück Integer old = list.set(1, newInt); // System.out.println("Old value:" + old);// =245 . System.out.println("New value:" + list.get(1));// =1000 . } }

Die Methode von Vector sind synchronisiert, deshalb läuft es bei der Multiple Thread Applikation gut
// Legacy method from 1.0, get element at index position // Like get(index) public E elementAt(int index) // Method inherited from the List interface, get element at position index. public E get(int index) // Replaces the element at the specified position in this list with the specified element // Return old element. // setElementAt(int,E) like set(int,E) public void setElementAt(int index, E element); // Replaces the element at the specified position in this list with the specified element // Return old element. public E set(int index, E element)
package org.o7planning.tutorial.javacollection.list; import java.util.Vector; public class VectorDemo { public static void main(String[] args) { // Ein Vector Objekt erstellen. // Mit der erste Kapazität von 10 Elemente. // automatisch die Kapazität von 5 erhöhen wenn // die Anzahl der Elemente mehr als die aktuellen Kapazität ist. Vector<Integer> v = new Vector<Integer>(10, 5); v.add(123); v.add(245); v.add(new Integer(345)); v.add(null); // Die Anzahl des Element in Vector ausdrucken (nicht die Kapazität) System.out.println("Size:" + v.size());// =4 // Das Element in der Index 1 ausnehmen. // Wie die Methode get(int). Integer i = v.elementAt(1); System.out.println("v.elementAt(1)=" + i);// 245 // Das Element in der Index 1 ersetzen. // Replace element at index 1. v.setElementAt(1, 1000); // System.out.println("New value:" + v.get(1));// =1000 . } }
Deshalb müssen die Elemente von Collection miteinander verglichen sein. Sie sind die Object von java.lang.Comparable (vergleichbar), Wenn Sie eine Elemente, die nicht Object von Comparable ist, einfügen, bekommen Sie eine Ausnahme

Die Player können auf der Grundsatz verglichen werden:
- Wer mehre Gold Medaille bekommt, im höheren Platz steht er .
- Wenn 2 Personnen die gleiche Anzahl von der Gold Medaille bekommen, dann wer mehre Silver Medaille bekommt, im höheren Platz steht er..
- Wenn 2 Personnen die gleiche Anzahl von der Gold Medaille und Silver Medaille bekommen, dann wer mehre Bronze Medaille bekommt, im höheren Platz steht er..
- Und die Übrigen stehen in die gleichen Platz.
package org.o7planning.tutorial.javacollection.sortedset; public class Player implements Comparable<Player> { private String name; private int goldMedal; private int silverMedal; private int bronzeMedal; public Player(String name, int goldMedal, int silverMedal, int bronzeMedal) { this.name = name; this.goldMedal = goldMedal; this.silverMedal = silverMedal; this.bronzeMedal = bronzeMedal; } // Der Vergleich von diesem Player mit anderen Player (Player other). // Wenn der Wert < 0 rückgeben, d.h das Player < Player other. // Wenn der Wert > 0 rückgeben, d.h das Player > Player other. // Wenn der Wert = 0 rückgeben, d.h das Player = Player other. @Override public int compareTo(Player other) { // Die Anzahl von Goldmedaille vergleichen int value = this.goldMedal - other.goldMedal; if (value != 0) { return value; } // Die Anzahl von Silvermedaille vergleichen value = this.silverMedal - other.silverMedal; if (value != 0) { return value; } // Die Anzahl von Bronzemedaille vergleichen value = this.bronzeMedal - other.bronzeMedal; return value; } @Override public String toString() { return "[" + this.name + ", Gold: " + this.goldMedal // + ", Silver: " + this.silverMedal + ", Bronze: " // + this.bronzeMedal + "]"; } }
package org.o7planning.tutorial.javacollection.sortedset; import java.util.SortedSet; import java.util.TreeSet; public class SortedSetDemo { public static void main(String[] args) { // Das SortedSet durch die Sub-Klasse TreeSet erstellen SortedSet<Player> players = new TreeSet<Player>(); Player tom = new Player("Tom", 1, 3, 5); Player jerry = new Player("Jerry", 3, 1, 3); Player donald = new Player("Donal", 2, 10, 0); // Die Elemente in die Kollektion einfügen. // Sie werden steigend automatisch angeordnet (steigend). players.add(tom); players.add(jerry); players.add(donald); // Die Elemente ausdrucken for (Player player : players) { System.out.println("Player: " + player); } } }



SN | Methods with Description |
---|---|
1 | void clear( )
Removes all key/value pairs from the invoking map.(optional operation). |
2 | boolean containsKey(Object k)
Returns true if the invoking map contains k as a key. Otherwise, returns false. |
3 | boolean containsValue(Object v)
Returns true if the map contains v as a value. Otherwise, returns false |
4 | Set<Map.Entry<K,V>> entrySet( )
Returns a Set that contains the entries in the map. The set contains objects of type Map.Entry. This method provides a set-view of the invoking map. |
5 | boolean equals(Object obj)
Returns true if obj is a Map and contains the same entries. Otherwise, returns false. |
6 | Object get(K k)
Returns the value associated with the key k. |
7 | int hashCode( )
Returns the hash code for the invoking map. |
8 | boolean isEmpty( )
Returns true if the invoking map is empty. Otherwise, returns false. |
9 | Set<K> keySet( )
Returns a Set that contains the keys in the invoking map. This method provides a set-view of the keys in the invoking map. |
10 | Object put(K k, V v)
Puts an entry in the invoking map, overwriting any previous value associated with the key. The key and value are k and v, respectively. Returns null if the key did not already exist. Otherwise, the previous value linked to the key is returned.(optional operation). |
11 | void putAll(Map<? extends K,? extends V> m)
Puts all the entries from m into this map.(optional operation). |
12 | Object remove(Object k)
Removes the entry whose key equals k. (optional operation). |
13 | int size( )
Returns the number of key/value pairs in the map. |
14 | Collection values( )
Returns a collection containing the values in the map. This method provides a collection-view of the values in the map. |
import java.util.Collection; import java.util.Map; import java.util.Set; public class MyMap<K,V> implements Map<K,V>{ ..... // Wenn Sie diese Methode aufrufen, wird eine Ausnahme bedingunglos geworfen @Override public void clear() { throw new java.lang.UnsupportedOperationException(); } }
package org.o7planning.tutorial.javacollection.map; import java.util.HashMap; import java.util.Map; import java.util.Set; public class MapDemo { public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); map.put("01000005", "Tom"); map.put("01000002", "Jerry"); map.put("01000003", "Tom"); map.put("01000004", "Donald"); // Eine Kollektion von der Schlüssel (key) enthalten. // Die Kollektion wird nicht angeordnet Set<String> phones = map.keySet(); for (String phone : phones) { System.out.println("Phone: " + phone + " : " + map.get(phone)); } } }


package org.o7planning.tutorial.javacollection.map; import java.util.HashMap; import java.util.Map; import java.util.Set; import java.util.Map.Entry; public class MapEntryDemo { public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); map.put("01000005", "Tom"); map.put("01000002", "Jerry"); map.put("01000003", "Tom"); map.put("01000004", "Donald"); // Eine Kollektion von Entry ausnehmen. // Die Entry können nach dem Schlüssel (key) sortieren. Set<Entry<String, String>> entries = map.entrySet(); for (Entry<String, String> entry : entries) { System.out.println("Phone: " + entry.getKey() + " : " + entry.getValue()); } } }

SN | Methods with Description |
---|---|
1 | Comparator comparator( )
Returns the invoking sorted map's comparator. If the natural ordering is used for the invoking map, null is returned. |
2 | Object firstKey( )
Returns the first key in the invoking map. |
3 | SortedMap headMap(Object end)
Returns a sorted map for those map entries with keys that are less than end. |
4 | Object lastKey( )
Returns the last key in the invoking map. |
5 | SortedMap subMap(Object start, Object end)
Returns a map containing those entries with keys that are greater than or equal to start and less than end |
6 | SortedMap tailMap(Object start)
Returns a map containing those entries with keys that are greater than or equal to start. |
package org.o7planning.tutorial.javacollection.sortedmap; import java.util.Map; import java.util.Set; import java.util.TreeMap; public class SortedMapDemo { public static void main(String[] args) { Map<String, String> map = new TreeMap<String, String>(); map.put("01000005", "Tom"); map.put("01000002", "Jerry"); map.put("01000003", "Tom"); map.put("01000004", "Donald"); // Die Kollektion wird steigend sortiert . Set<String> keys = map.keySet(); for (String key : keys) { System.out.println("Phone: " + key); } System.out.println("-----"); // Die Kollektion wird nach key angeordnet Set<Map.Entry<String, String>> entries = map.entrySet(); for (Map.Entry<String, String> entry : entries) { System.out.println("Phone: " + entry.getKey()); } } }
