Was ist neu in der Java 6.0 Collections API?

In diesem Artikel werde ich über die neuen Collections-APIs schreiben, die in Java 6.0 eingeführt wurden. Mustang hat einige interessante Änderungen an den Collections-APIs, eine davon ist die Deque. Deque wird für die bidirektionale Durchquerung verwendet. Es gibt verschiedene Implementierungen, einschließlich BlockingDeque, ArrayDeque usw. Ich werde über das Deque und seine verschiedenen Implementierungen sprechen, außerdem über einige weitere Änderungen in der Collectiona-API in Java 6.0.

lesen Sie auch:

  • Neue Funktionen in Java 6.0 – Teil 1
  • Neue Funktionen in Java 6.0 – Teil 2
  • Java 6.0 Compiler-API

Java 6.0 New Collection APIs – eine Übersicht

Im Folgenden sind die neuen Sammlungs-APIs aufgeführt, die in Java 6.0 eingeführt wurden. Ich liste sie als Schnittstellen und Klassen auf.

Neue Schnittstellen

  • Deque
  • BlockingDeque
  • NavigableSet
  • Navigierbare Karte

Neue Klassen

  • ArrayDeque
  • LinkedBlockingDeque
  • ConcurrentSkipListSet
  • ConcurrentSkipListMap
  • AbstractMap.SimpleEntry
  • AbstractMap.SimpleImmutableEntry

Aktualisierte Klassen in Java 6.0

  • LinkedList
  • TreeSet
  • TreeMap
  • Sammlungen

Deque und ArrayDeque

Deque ist die Abkürzung für „Double Ended Queue“. Eine Sammlung, die es uns ermöglicht, an beiden Enden Elemente hinzuzufügen (oder zu entfernen). Deque unterstützt die Gesamtgröße der Sammlung sowohl für feste als auch für nicht spezifizierte Größenbeschränkungen.

Die Deque-Implementierung kann als Stack (Last in First Out) oder Queue (First in First Out) verwendet werden. Für jedes Einfügen, Abrufen und Entfernen von Elementen aus der Deque gibt es Methoden in zwei Varianten. Einer löst eine Ausnahme aus, wenn ein Vorgang fehlschlägt, und ein anderer gibt den Status oder einen Sonderwert für jeden Vorgang zurück.

BetriebSonderwertmethodeMethode zum Auslösen einer Ausnahme
Einfügung am KopfofferFirst(e)addFirst(e)
Entfernung am KopfpollFirst()removeFirst()

Apportieren am Kopf

peekFirst()getFirst()
Einfügung am SchwanzofferLast(e)addLast(e)
Entfernung am HeckpollLast()RemoveLast()

Rückholung am Schwanz

peekLast()getLast()

Die Implementierung von Deque erfordert nicht das Verhindern des Einfügens von Null, aber wenn wir die Sonderwertmethode verwenden, wird Null zurückgegeben, um anzuzeigen, dass die Sammlung leer ist. Es wird daher empfohlen, das Einfügen von Nullen nicht zuzulassen.

ArrayDeque ist eine Klasse, die Deque implementiert. Es gibt keine Kapazitätsbeschränkungen. Bei Verwendung als Stack ist die Leistung schneller als der Stack und bei Verwendung als Warteschlange schneller als die verknüpfte Liste. ArrayDeque ist nicht threadsicher. Das folgende Beispiel erklärt, wie man ein Programm mit ArrayDeque schreibt.

Beispiel

import java.util.ArrayDeque;
import java.util.Iterator;

public class DequeExample
{
	public static void main(String as[])
	{
		ArrayDeque adObj = new ArrayDeque();

		//Insertion by using various methods
		adObj.add('Oracle');
		adObj.addFirst('DB2');
		adObj.offerFirst('MySQL');   //returns boolean - true R false
		adObj.offerLast('Postgres');   //returns boolean - true R false

		//Retrievals
		System.out.println('Retrieving First Element :' + adObj.peekFirst());
		System.out.println('Retrieving Last Element  :'+ adObj.peekLast());

		//Removals
		System.out.println('Removing First  Element  :'+ adObj.pollFirst());
		System.out.println('Removing Last  Element   :'+ adObj.pollLast());

		//Reverse traversal
		System.out.println('Remaining Elements :');
		Iterator it = adObj.descendingIterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

Ausgabe:

Retrieving First Element :MySQL
Retrieving Last Element  :Postgres
Removing First  Element  :MySQL
Removing Last  Element   :Postgres
Remaining Elements :
Oracle
DB2

BlockingDeque und LinkedBlockingDeque

Eine BlockingDeque ähnelt Deque und bietet zusätzliche Funktionalität. Wenn wir versuchen, ein Element in eine BlockingDeque einzufügen, die bereits voll ist, kann gewartet werden, bis Platz zum Einfügen eines Elements verfügbar wird. Wir können auch die Wartezeit festlegen.

BlockingDeque-Methoden sind in vier Varianten verfügbar

  • Methoden lösen eine Ausnahme aus
  • Methoden geben einen besonderen Wert zurück
  • Methoden, die blockieren (wartet auf unbestimmte Zeit, bis Speicherplatz verfügbar ist)
  • Methoden, bei denen eine Zeitüberschreitung auftritt (wartet eine bestimmte Zeit lang, bis Speicherplatz verfügbar wird)
BetriebBesonderer WertLöst eine Ausnahme ausBlöckeDie Zeit ist abgelaufen
Einfügung am KopfaddFirst(e)offerFirst(e)putFirst(e)offerFirst(e,time,unit)
Entfernung vom Kopfremovefirst()pollFirst()takeFirst()takeFirst(time,unit)
Rückholung vom KopfgetFirst()peekfirst()N / AN / A
Einschub am SchwanzaddLast(e)offerLast(e)putLast(e)offerLast(e,time,unit)
Entfernung vom SchwanzRemoveLast()pollLast()takeLast()takeLast(time,unit)
Rückholung vom SchwanzgetLast()peekLast()N / AN / A

Eine LinkedBlockingDeque ist eine Collection-Klasse, die die BlockingDeque-Schnittstelle implementiert, in der wir bei Bedarf die maximale Kapazität angeben können. Wenn wir die Kapazität nicht angegeben haben, ist die maximale Kapazität Integer.MAX_VALUE.

import java.util.concurrent.*;
class BlockingDequeExample implements Runnable
{
	LinkedBlockingDeque lbd = new LinkedBlockingDeque(1);
	volatile boolean b = true;
	public void run()
	{
		try
		{
			/*First thread once enters into the block it modifies
			  instance variable b to false and prevents second
			  thread to enter into the block */
			 if(b)
			{
				b = false;
				Thread.sleep(5000);//Makes the Thread to sleep for 5 seconds
				System.out.println('Removing '+lbd.peek());
				lbd.poll();//Removing an element from collection
			}
			else
			{
				System.out.println('Waiting ');
				/*This method makes to wait till the first thread removes an elements*/
				lbd.put('B');
				System.out.println('Inserted '+lbd.peek());
			}
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	public static void main(String[] args) throws Exception
	{
		BlockingDequeExample bdeObj = new BlockingDequeExample();
		bdeObj.lbd.offer('A');
		System.out.println('Inserted '+bdeObj.lbd.peek());
		Thread tMainObj = new Thread(bdeObj);
		tMainObj.start();
		Thread tSubObj = new Thread(bdeObj);
		tSubObj.start();
	}
}

Ausgabe:

Inserted A
Waiting
Removing A
Inserted B

NavigableSet und ConcurrentSkipListSet

Angenommen, wir haben eine Anforderung aus sortierten Mengenelementen [5,10,15,20]
Wir wollen nur wenige solcher Dinge

  • Rufen Sie das Element ab, das unmittelbar größer oder kleiner als Element 15 ist
  • Rufen Sie alle Elemente ab, die größer oder kleiner als 10 sind

Mit Hilfe bestehender Methoden müssen wir nur wenige Risiken eingehen, um diese Ziele zu erreichen. Bei NavigableSet-Methoden handelt es sich jedoch lediglich um einen Methodenaufruf. NavigableSet-Methoden werden verwendet, um die ähnlichsten Übereinstimmungen von Elementen für die angegebenen Elemente in der Sammlung zurückzugeben. ConcurrentSkipListSet ist eine der Klassen, die NavigableSet implementiert.

Beispiel

import java.util.concurrent.*;
import java.util.*;
class SkipListSetTest
{
	public static void main(String[] args)
	{
		ConcurrentSkipListSet csls = new ConcurrentSkipListSet();
		csls.add(15);
		csls.add(20);
		csls.add(5);
		csls.add(10);
		System.out.println('Elements in the collections are');
		for(Integer i: csls)
		{
			System.out.println(i);
		}
		/* Retrieve immediate element less than or equal to  the given element */
		System.out.println('Floor    '+csls.floor(12));
		/* Retrieve immediate  element greater than or equal to the given element */
		System.out.println('Ceiling  '+csls.ceiling(12));
		/* Retrieve immediate element less than the given element */
		System.out.println('Lower    '+csls.lower(10));
		/* Retrieve immediate element greater than the given element */
		System.out.println('heigher  '+csls.higher(10));
		System.out.println('Head Elements ');
		Set cslsHeadView =  csls.headSet(10);
		//HeadSet excludes the given element
		for(Integer i: cslsHeadView)
		{
			System.out.println(i);
		}
		Set cslsTailView =  csls.tailSet(10);
		//TailSet includes the given element
		System.out.println('Tail Elements');
		for(Integer i: cslsTailView)
		{
			System.out.println(i);
		}
	}
}

Ausgabe:

Elements in the collections are
5
10
15
20
Floor    10
Ceiling  15
Lower    5
heigher  15
Head Elements
5
Tail Elements
10
15
20

NavigableMap und ConcurrentSkipListMap

NaviagableMap ähnelt NaviagableSet. In NavigableSet werden Methoden verwendet, um Werte zurückzugeben, in NaviagableMap werden Methoden jedoch verwendet, um das Schlüssel-Wert-Paar zurückzugeben. ConcurrentSkipListMap ist die Klasse, die NaviagableMap implementiert.

import java.util.*;
import java.util.concurrent.*;

class NavigableMapExample
{
	public static void main(String[] args)
	{
		NavigableMap nm = new ConcurrentSkipListMap();
		nm.put(1,'One');
		nm.put(2,'Two');
		nm.put(3,'Three');
		nm.put(4,'Four');
		nm.put(5,'Five');
		/* Retrieves the key,value pair immediately lesser than the given key */
		Map.Entry ae = nm.lowerEntry(5);
		/* Map.Entry is a Static interface nested inside Map
		   interface,just use to hold key and value */
		System.out.println('Key' + ae.getKey());
		System.out.println('Value'+	ae.getValue());
		/* Retrieves key,value pairs equal to and greater then the given key */
		SortedMap mm = nm.tailMap(3);
		Set s = mm.keySet();
		System.out.println('Tail elements are');
		for(Integer i:s)
		{
			System.out.println('Key '+ i + 'Value '+ mm.get(i));
		}
	}
}

Ausgabe

Key 4
Value Four
Tail elements are
Key 3  Value Three
Key 4  Value Four
Key 5  Value Five
Notes :
floorEntry method retrieves less than or equal to the givenkey (or) null
lowerEntry method retrieves always less than the givenkey (or) null
headMap method retrieves all elements less than  the givenkey
tailMap method retrieves all elements greater than or equal to the givenkey

AbstractMap.SimpleEntry und AbstractMap.SimpleImmutableEntry

AbstractMap.SimpleEntry und AbstractMap.SimpleImmutableEntry sind statische Klassen, die in der abstractMap-Klasse verschachtelt sind. Die Instanz dieser Klassen wird verwendet, um das Schlüssel-Wert-Paar eines einzelnen Eintrags in einer Map zu speichern. Der Unterschied zwischen diesen beiden Klassen besteht darin, dass die erstere dies ermöglicht Legen Sie den Wert fest. Wenn wir später versuchen, den Wert festzulegen, wird eine UnsupportedOperationException ausgelöst

Modifizierte Klassen

Klassen werden geändert, um die neuen Schnittstellen in den vorhandenen Klassen zu implementieren. LinkedList wird geändert, um Deque zu implementieren. TreeSet wird geändert, um NavigableSet zu implementieren.TreeMap wird geändert, um NavigableMap zu implementieren. In Collections werden zwei neue Methoden newSetFromMap und asLifoQueue hinzugefügt.

Abschluss

Mit Java6.0-Sammlungen wird die bidirektionale Durchquerung einfacher und das Abrufen von Elementen auf die von uns gewünschte Weise ist ebenfalls möglich. Besonderes Augenmerk wird auch auf gleichzeitige Vorgänge in der Sammlung gelegt.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen