Die Anleitung zu Java Collections Framework

View more categories:

1- Die Vorstellung

Collection ist ein Grundidee des Programms und der Programmierungsprache. Eine Applikation geht oft mit der Collection um wie die Mitarbeiter Information speichern, die Bilder sammeln ... Java wie die anderen Array unterstützende Sprachen gilt als eine meist grundlegende Collection. Aber Umgang mit Array ist in einigen Fallen nicht konvinient denn es ist schwierig, die Elemente der Array zuzusätzen oder löschen  .
Beispiel von einem Array:

2- Zum Beispiel

Zuerst machen wir ein Beispiel mit LinkedList, darin die Anzahl der Element veränderbar ist.
HelloLinkedList.java
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);
	}

}
Das Ergebnis der Beispieldurchführung
Zum Beispiel mit  HashMap. Das ist das Objekt mit der Enthaltung von dem Paar (Key-Value). Zum Beispiel wie das Buch von Telefonenummer, darin der Telefonenummer der Schlüssel ist, und den Nummerbesitzer die Wert. Die Schlüssel (key) überlappen nicht.
HelloHashMap.java
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"));
		 
	}

}
Das Ergebnis durchführen

3- Die Beschränkungen der Benutzung von Array- Eine Hinweise zur Problemslösung

3.1- Der Array- ein grundlegendes Kollektionstyp

  • 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

3.2- Die Element aus dem Array löschen

Die Elemente werden aufeinander folgend in dem Speicher gelegt. So ist es Ihnen schwierig, irgendeine Elemente im Array zu löschen ( Die ununterbrochen Zusammenhang verlieren). Normalerweise ist eine Technik üblich, einen neuen Array für die Speicherung der Object von dem ersten Array zu erstellen und dann die nicht notwendigen Elementen zu löschen . Aber das Programm leistet nicht gut. Bei der Array Ausweiterung benutzen wir die gleichen Technik. Das ist Erstellung eines neuen Array mit der größeren Umfang und dann koppieren Sie die Elemente vom alten Array zum neuen Array.

Es ist so klar, dass Array ist nicht gut für viele Falle von Applikation

3.3- Die gebindete Liste

Linked List ist eine der Verwaltungsart von Datenlist, die die Schwäche von Array überwindet. Allerdings gibt es viele sonstige Art für die Verwaltung der List im Java wie ArrayList.

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 .
LinkedList ist eigentlich eine zweiseitige Verbindung 
Die Element Link ist ein Object, die die Daten zur Verwaltung zu enthalten. Und sie hat 2 Reference zur die Elemente Link vor und nach ihr 
Wie eine Warteschlange braucht jede Person zwei Personnen erinern, wer vor und hinter sie stehen
Ein Element aus LinkedList entwerfen
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.
Die Elemente in LinkedList zusätzen (Am Ende addieren oder in der Mittel einfügen)
So, obwohl wir nur ein Beispiel über die LinkedList haben, verstehen wir besser die package java.util.
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.

4- Die Überblick von Java Collections Framework

Wegen der gesehenen Beschränkungen von Array, hat Java ab Version 1.0 in class  java.util.Vector ein Speicherungsclass der dynamic List von Object. Und  java.util.Hashtable ist class für die Speicherung die Paar   key/value (Schlüssel/Wert) .Danach führt  Java2 platform weiter den Zugang der Collection, sogenannten Collections Framework ein. . java.util.Vector, java.util.Hashtable sind noch vorhanden und einen Teil des großen Array. Die Collection Type wird auf der Basic von einer interface in pacpage java.util.gebaut. Und es wird zu 2 dezentralisierten System, die von  2 interface java.util.Collection für die Enthaltung der Object List und   java.util.Map für die Enthaltung der Paar  key/value.geleitet werden

4.1- Die Interface in Java Collections Framework

Das oben Bild ist die wichtige interface von Java Collections Framework.Wir erläutern das Zweck der interface und die Teilung nach dem Zweck und die Benutzung. In der package java.util führen die class eine oder viele interface. Deshalb hat ein class im java.util viele unterschiedlichen Funktionen. Z.B   java.util.HashMap:
** Hashtable **

public class HashMap<K,V> extends AbstractMap<K,V>
                           implements Map<K,V>, Cloneable, Serializable
** Vector **
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  .
Die Collection für die Datenspeicherung ist die Reference Type, Die Map speichert die Paaren key/value.
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));

4.3- Interface Iterator und interface RandomAccess - Die Methode zur Datenzugang

  • 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 .
Auf dem Beispiel gibt es 2 Interface Iterator & RandomAccess, sie vertreten 2 Zugangsweg in die Elemente in einer Collection
Die Klasse  Vector ​​​​​​​sehen:
** Vector **
public class Vector<E> extends AbstractList<E>
               implements List<E>, RandomAccess, Cloneable, Serializable
Nach Vector in Collection können Sie ihre Elemente durch Iterator zugreiffen und zufällig durch die Method get(index).
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.

5- Die Gruppe von Collection

5.1- Die Interface in der Gruppe von Collection

3 intergeordnete interface von Collection sind  Queue, List, Set. Davon wird Queue ab der Version 1.5 mit der Bedeutung wie eine Wartschlange eingeführt. Queue hat auch die untergeordnete interface BlockingQueue. Aber die interface liegt in der Package java.util.concurrent, ( in dieser Unterlagen meinen wir es nicht). Queue ist eine interface mit vielen Begriffe und die Organisation der Element zu großer Sorge. 2 interface Queue, List , Set sind 3 Zweige in Collection gesehen. Sehen Sie die Überblick über interface Collection bevor Sie in Details lesen

5.2- java.util.Collection Interface

Die Inheritance Beziehung:
** java.util.Collection **
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();
}

5.3- Die Elemente von der Kollektion durchsuchen

Iterator ist für die Elemente in der Collection zuzustimmen
beispiel: Iterator ist für die Elemente von Collection zu zugegriffen
 
CollectionAndIterator.java
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);
		}
	}

}
Ergebnis von Beispiel

5.4- Der Zweige der Kollektion

Wie oben gemeint hat Collection die 3 untergeordneten interface Queue, List und  Set.  Und die Unterschied ist die Speicherung der Daten
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

Eine Liste ( List) ist eine engeordnete Liste der Objekte, wo die gleichen Objekten ein Mal oder mehrmals auftreten. Zum Beispiel: [1, 7, 1, 3, 1, 1, 1, 5]. Und Sie können die "N th" Element in der Liste sprechen. Sie können ein Element in einer Stelle der Liste einfügen, ändern oder löschen

Queue

Eine Warteschlange ( Queue) ist auch eine angeordneten Kollektion aber Sie können nur das erste Element der Warteschlange berühren (touch). Alle Elemente werden am Ende der Warteschlange eingefügt und löscht das erste Element. Sie können wissen, wieviel Elemente es in der Warteschlange gibt, aber Sie können die N th Element nicht finden oder sprechen. Sie können nur es sehen wenn es in der erste Stelle von der Warteschlange stehen

Set

Set  ist eine unangeordnete Kollektion und kann nicht wiederholen. Sie können das N th Element oder sogar das erste Element sprechen denn sie sind nicht in einer Anordnung. Sie können das Element einfügen oder löschen und auch finden wenn es existiert (Zum Beispiel "Liegt 7 in der Kollektion?").

Achtung: SortedSet ist eine Sub-Interface von Set, die die angeordneten Elementen enthalten

5.5- java.util.List Interface

List ist eine untergeordnete interface von Collection. es hat alle Funktionen von Collection, und gleichzeigtig einige besonderen Eigenschaften:
  • Die doppelte Elemente genehmigen
  • 0 oder viele Elemente null genehmigen.
  • Eine sequentielle Collektion .
Gleichzeitig außer Zugang mit Iterator können Sie durch ListIterator. ListIterator zugreiffen, die den Mauszeiger vorwärts oder rückwärts bewegen kann.
// 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)
ListAndListIterator.java
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);
		}
	}

}
Ergebniss von Beispiel

5.6- java.util.Set Interface

Set ist eine untergeordnete Interface von  Collection, sie hat alle Funktionen von Collection, und einige anderen Eigenschaften:
  • Bezeichnung einer Collection, die keine identischen Elemente enthalten darf
  • Die Elemente null enthalten können, und nur ein Elemente null wenn ja
HashSetExample.java
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());
		}
	}

}
Ergebnis von Beispiel

5.7- java.util.Queue Interface

Queue (Warteschlange) ist eine untergeordnete Interface von Collection, er hat alle Funktionen der Collection, er ist ziemlich gleich mit List, Aber der Benutzungzweck ändert. Mit  Queue können Sie  nur die erste Elemente der Warteschlange zugreiffen und auch die erste Elemente der Warteschlange löschen. Es funktioniert wie die Warteschlange im Supermarkt. Nur die erste Person in der Warteschlange wird seviert. Die neue Person wird in der Warteschlange eingefügt und kann nicht am Ende eingefügt. Der Position der eingefügten Elemente ist abhängig von der Warteschlange Type und die Priorität der Elemente 
  • Eine collection genehmigt die identischen Elementen.
  • Keine Elemente null.enthalten
2 Class implementieren die Interface  Queue.
  • java.util.LinkedList
  • java.util.PriorityQueue
LinkedList ist eine Warteschlange. Und LinkedList implementieren 2 interface  List unds  Queue.

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
Beachten Sie, ein Class kann 2 Interface List und  Queue implementieren, deshalb versorgen Sie nicht wie die Elemente innerhalb der oben Class Object geordnet werden. Wenn Sie es wie eine Wartschlange sehen, bitte sehen Sie die Zugang zur Elemente von Wartschlange. Sehen Sie bitte die Typische Methode von Queue, es bezeichnet die Warteschlange wie die Warteschlange im Supermarkt.
  Throws exception Returns special value
Insert add(e) offer(e)
Remove remove() poll()
Examine element() peek()

boolean add(E)

Ein Element in der Warteschlange einfügen kann ohne die Beschränkung der Umfang sofort gemacht werden. Wenn es erfolgreich ist, bekommen Sie true und umgekehrt wird eine Ausnahme IllegalStateException geworfen wenn es keinen Platz in der Warteschlange gibt 

boolean offer(E)

Eine Elemente in der Warteschlange einfügen kann ohne die Beschränkung der Umfang sofort gemacht werden. Wenn die Warteschlange ist beschränkt, ist die Method ziemlich gleich wie add(E), Aber die Methode wirf keine Ausnahme bei der Einfügung der Elemente in der Warteschlange, sondern zeigt es false in diesen Fall.

E remove()

Die erste Elemente der Warteschlange entziehen und löschen. Die Method ändert poll()  nur wenn die Warteschlange hat keine Ausnahme.

E poll()

Die erste Elemente der Warteschlange entziehen und löschen or  null zeigen wenn es gibt keine Elemente in der Warteschlange.

E element()

Die erste Elemente der Warteschlange entziehen aber nciht löschen. Sie hat einen Unterchied mit peek(). Das ist : Wenn die Warteschlange keine Elemente hat, ist eine Ausnahme geworfen.

E peek()

Die erste Elemente der Warteschlange entziehen aber nicht löschen oder es zeigt null wenn die Warteschlange hat keine Elemente

Bewerten

Keine oben Methode von Warteschlange genehmigen Sie die anderen Elementen außer der ersten Elemente zuzugreiffen. Sie können nicht auch die Position der eingefügten Elemente bestimmen
QueueDemo.java
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);
		}

	}

}
Ergebnis des Beispiel
Beispiel: Eine Warteschlange hat die Priorität PriorityQueue. Diese Warteschlange speichert die Elementen nach der natürlichen Reihe (wenn die Elemente miteinander verglichen werden könenn, implementieren Sie Comparable) oder ein Comparator, der für die PriorityQueue. gesetzt wird
String ist ein Class für die Implementierung der Interface  Comparable. Sie können miteinander verglichen werden und nach der Alphabet Reihe geordnet werden.
PriorityQueueDemo.java
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);
      }

   }

}
Ergebnis des Beipiel

5.8- Die Inheritance Beziehung in der Klasse der Gruppe Collection

Einige üblichen Class
 
Implementations
Hash Table Resizable Array Balanced Tree Linked List Hash Table + Linked List
Interfaces Set HashSet   TreeSet   LinkedHashSet
List   ArrayList      

5.9- java.util.ArrayList

ArrayList hat alle Eigenschaften der Interface List. Gleichzeitig kann es die Elemente zufällig zugreiffen (wegen der Inheritance aus interface RandomAccess)
Auf der Wesen ist es gleich wie class Vector, Der Unterschied ist die methode von Vector werden synchronisiert und ArrayList nicht. ArrayList passt zur 1 Thread Applikation
ArrayListDemo.java
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 .
	}

}
Ergebnis von Beispiel

5.10- java.util.Vector

Das ist ein Class, der wie ArrayList ähnlich ist. Der Unterschied ist: die Method von Vector sind synchronisiert und der ArrayList nicht
Die Methode von Vector sind synchronisiert, deshalb läuft es bei der Multiple Thread Applikation gut
Vector hat die anderen Methode. Diese Methode sind die Heritage von der Java Version 1.0 bevor der Begriff von dem Collection Grundsatz im Java entstand
// 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)
VectorDemo.java
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 .
	}
}
Ergebnis des Beispiel

5.11- java.util.SortedSet

SortedSet ist die untergeordnete Interface von der Interface Set,. Es hat alle Eigenschaften von Set. SortedSet ist eine Collection mit der Ordnung. Die in Collection neu eingefügten Elemente stehen automatisch in einem angemessenen Platz um die angeordneten Collection zu guarantiern (steigend oder abnehmend) 

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 
Ein der Class, die die Interface SortedSetTreeSet.implementieren
Sehen Sie, die class Player besteht aus die Informationen: der Name, die Anzahl der Gold Medaille, Die Anzahl der Silver Medaille, Die Anzahl der bronze Medaille .

Die Player können auf der Grundsatz verglichen werden:
  1. Wer mehre Gold Medaille bekommt, im höheren Platz steht er .
  2. Wenn 2 Personnen die gleiche Anzahl von der Gold Medaille bekommen, dann wer mehre Silver Medaille bekommt, im höheren Platz steht er..
  3. 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..
  4. Und die Übrigen stehen in die gleichen Platz.
Class Player implementiert die Interface  java.lang.Comparable.
Player.java
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 + "]";
	}

}
SortedSetDemo.java
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);
		}
	}

}
Ergebnis der Durchführung von class SortedSetDemo:

6- Die Gruppe von Map

6.1- Die Interface in der Gruppe Map

Die Gruppe Map wird durch die  interface java.util. Map geleitet- Die   Interface hat 2 untergeordneten Interfac- Das sind java.util.SortedMap und java.util.concurrent. ConcurrentMap . ConcurrentMap gehört zur Package java.util nicht. Sie wird ab der Java Version 1.5 eingeführt. Wir erwähnen sie nicht in diesem Unterlagen. Die Gruppe Map ist typisch mit der Speicherung der Daten durch die Paaren 

6.2- Die Klasse in der Gruppe Map

6.3- java.util.Map Interface

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.

Die Optional operation können auf der Implementierung class unterstützen oder nicht. Wenn nicht, kann sie eine Ausnahme UnsupportedOperationException: werfen
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();        
    }  

}
So unterstützt der Class MyMap die pratische Bedeutung von Method clear() nicht. Wenn der Benutzer absichtlich die Methode von MyMap benutzt, bekommt er eine Ausnahme .
MapDemo.java
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));
		}

	}

}
Ergebniss von Beispiel
Sie können die Daten von Map durch Map.Entry zugreiffen. Sehen Sie bitte das unten Beispiel:
MapEntryDemo.java
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());
		}

	}
}
Ergebnis von Beispiel

6.4- java.util.SortedMap Interface

Interface SortedMap ist eine untergeordnete Interface von Map. Sie bewährt, dass die Paare key/value steigend nach key angeordnet werden
Nur eine Class in der package java.util implementiert die Interface SortedMap, Das ist TreeMap.
Die Operation von SortedMap:
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.

SortedMapDemo.java
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());
		}
	}

}
Ergebnis von Beispiel

View more categories: