Die Anleitung zu Java Collections Framework

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"));
		 
	}

}

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

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

public class Vector<E> extends AbstractList<E>
               implements List<E>, RandomAccess, Cloneable, Serializable

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

}

// 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);
		}
	}

}

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

}

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

	}

}

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 .
	}

}

// 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 .
	}
}

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

}

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

	}
}

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

}