[JAVA] Eclipse Sammlungen Cheet Sheet

Überblick

Was die Erklärung der Eclipse-Sammlungen selbst betrifft, denke ich, dass es viele andere gute Artikel gibt. Deshalb werde ich sie hier als Referenz hochladen, auf die Sie sofort verweisen können, wenn Sie denken, "Ich möchte XX machen". Vorerst habe ich versucht, diejenigen aufzulisten, die ich oft benutze, aber ich kann sie hinzufügen, wenn sie herauskommen.

• • Es wird fast nur der Listentyp geschrieben. * *

Umgebung

Ver.8.0.0

• Es tut mir leid, es ist eine Version, die ich normalerweise bei der Arbeit benutze, also ist es ein bisschen alt. * *

pom.xml

		<dependency>
			<groupId>org.eclipse.collections</groupId>
			<artifactId>eclipse-collections-api</artifactId>
			<version>8.0.0</version>
		</dependency>
		<dependency>
			<groupId>org.eclipse.collections</groupId>
			<artifactId>eclipse-collections</artifactId>
			<version>8.0.0</version>
		</dependency>

Initialisieren

Leere Liste

empty

Lists.mutable.empty();

Ab diesem Zeitpunkt kann unveränderlich (ImmutableList) zusätzlich zu mutable (MutableList) verwendet werden, sofern nicht anders angegeben. ImmutableList verfügt nicht über Methoden wie add und kann nicht geändert werden.

• • Bitte beachten Sie, dass einige Methoden, wie z. B. Sortiersysteme, nur mit MutableList verwendet werden können. *

empty

Lists.immutable.empty();

Alle zusammen initialisieren

of

Lists.mutable.of(first, second, third);

Initialisieren Sie basierend auf Iterable

Sie können java.util.List usw. in ImmutableList usw. konvertieren.

ofall

Lists.immutable.ofAll(hogeList);

Häufige Mustersammlung

Extrahieren Sie nur Elemente, die die Bedingungen erfüllen

select

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		assertThat(
				hogeList
					.select(s -> s.contains("g"))
					.makeString()
				, is("hoge, fuga")
			);

Ich möchte überprüfen, ob es ein Element gibt, das die Bedingungen erfüllt

anySatisfy gibt true zurück, wenn mindestens ein Element die Bedingung erfüllt.

anySatisfy

		ListIterable<String> hogeList = Lists.mutable.of("hoge", null, "fuga");
		assertThat(
				hogeList.anySatisfy(s -> s == null)
				, is(true)
			);

Ich möchte sicherstellen, dass nicht alle Elemente die Bedingungen erfüllen

noneSatisfy gibt true zurück, wenn keine Elemente vorhanden sind, die die Bedingung erfüllen.

noneSatisfy

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		assertThat(
				hogeList.noneSatisfy(s -> s.equals("hogera"))
				, is(true)
			);

Ich möchte wissen, ob es überhaupt ein Element gibt, das die Bedingungen erfüllt

"Erkennen" ruft nur das erste der Elemente ab, die die Bedingung erfüllen.

detect

		ListIterable<String> hogeList = Lists.mutable.of(null, "hoge", "fuga");
		assertThat(
				hogeList.detect(s -> s != null).toString()
				, is("hoge")
			);

Konvertieren Sie Elemente in eine neue Liste

collect

		ListIterable<String> hogeList = Lists.mutable.of("hogehoge", "fuga", "piyopi");
		assertThat(
				hogeList
					.collect(s -> s.length())
					.makeString()
				, is("8, 4, 6")
			);

Deduplizierung

Beseitigen Sie Doppelarbeit und lassen Sie nur eindeutige Elemente übrig.

distinct

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo", "fuga", "piyo");
		assertThat(
				hogeList
					.distinct()
					.makeString()
				, is("hoge, fuga, piyo")
			);

Es ist auch möglich, die Kriterien anzugeben, anhand derer beurteilt werden kann, ob es eindeutig ist. Zu diesem Zeitpunkt verbleibt nur das erste der doppelten Elemente in der Ergebnisliste.

distinct

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo", "fugafuga", "piyopiyo");
		assertThat(
				hogeList
					.distinct(HashingStrategies.fromFunction(s -> s.length()))
					.makeString()
				, is("hoge, fugafuga")
			);

Sortierung

sortThis

		MutableList<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		assertThat(
				hogeList
					.sortThis()
					.makeString()
				, is("fuga, hoge, piyo")
			);

Es ist auch möglich, die Sortierkriterien anzugeben und in absteigender Reihenfolge zu sortieren.

sortThisBy

		MutableList<String> hogeList = Lists.mutable.of("hogehoge", "fuga", "piyopi");
		assertThat(
				hogeList
					.sortThisBy(s -> s.length())
					.reverseThis()
					.makeString()
				, is("hogehoge, piyopi, fuga")
			);

Wiederholung

Wenn Sie den Vorgang wiederholen und dann weiter schreiben möchten, gibt es auch "Tippen".

each

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		hogeList
			.each(s ->
				System.out.println(s)
			);
		//Ausführungsergebnis
		//hoge
		//fuga
		//piyo

Mit forEachWithIndex können Sie eine Schleife mit dem Index erstellen.

forEachWithIndex

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		hogeList
			.forEachWithIndex((string, index) ->
				System.out.println(String.valueOf(index).concat(string))
			);
		//Ausführungsergebnis
		//0hoge
		//1fuga
		//2piyo

Aggregat

Mit groupBy können Sie nach dem angegebenen Wert gruppieren. Es kommt vom Typ "ListMultimap" zurück und kann auf verschiedene Arten abgerufen werden, aber ich verwende es gerne als "Pair" (siehe unten) mit der Methode "keyMultiValuePairsView ()".

groupBy

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "hogera", "fuga", "fugafuga", "piyo", "piyopiyo");
		hogeList
			.groupBy(s -> s.length())
			.keyMultiValuePairsView()
			.each(p ->{
				System.out.println(p.getOne() + " -> " + p.getTwo());
			});
		//Ausführungsergebnis
		//4 -> [hoge, fuga, piyo]
		//6 -> [hogera]
		//8 -> [fugafuga, piyopiyo]

gesamt

sumOfInt

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		assertThat(
				hogeList
					.sumOfInt(s -> s.length())
				, is(12L)
			);

Ich möchte nur ein Element erhalten

Erster

Wenn keine Elemente vorhanden sind, wird null zurückgegeben.

getFirst

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		assertThat(
				hogeList
					.select(s -> s.contains("g"))
					.getFirst()
				, is("hoge")
			);

Letzter

Auch hier wird null zurückgegeben, wenn keine Elemente vorhanden sind.

getLast

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		assertThat(
				hogeList
					.select(s -> s.contains("g"))
					.getLast()
				, is("fuga")
			);

Element, das nur eines sein sollte

Wenn Sie in der Lage sein sollten, die Elemente mit select usw. auf nur eines einzugrenzen, verwenden Sie getOnly. IllegalStateException wird ausgelöst, wenn mehr als ein Element vorhanden ist.

getOnly

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		assertThat(
				hogeList
					.select(s -> s.contains("i"))
					.getOnly()
				, is("piyo")
			);

Umstellung von Standard Collection

Standardauflistungen wie "java.util.List" werden häufig in den in Projekten verwendeten Frameworks verwendet. Wenn Sie in einem solchen Fall Eclipse-Sammlungen verwenden möchten, müssen Sie diese einmal mit "ofAll" usw. in den Typ "Eclipse-Sammlungen" konvertieren, wie unten gezeigt. Wenn sich die Anzahl erhöht, ist dies jedoch etwas störend.

Neigen dazu, so zu sein

List<String> hogeList = Arrays.asList("konna", "fuuni", "shiteita");
ImmutableList<String> fugaList = Lists.immutable.ofAll(hogeList);
fugaList.select(s -> s.length > 4);

In einem solchen Fall können Sie die Eclipse Collestions-Methode in einem Schuss verwenden, indem Sie "ListAdapter" verwenden. Wenn es "Array" anstelle von "Liste" ist, gibt es auch "ArrayAdapter".

Das war gut

List<String> hogeList = Arrays.asList("kore", "de", "yokatta");
ListAdapter.adapt(hogeList)
           .select(s -> s.length > 4);

Es gibt auch "ListIterate" und "ArrayIterate", die nicht einmal angepasst werden müssen.

ListIterate

List<String> hogeList = Arrays.asList("adapt", "mo", "shinai");
ListIterate.select(hogeList, s -> s.length > 4);

Andere Datensätze

Ich möchte zwei Werte als Satz behalten

Es wird verwendet, wenn Sie Daten als Schlüssel- und Wertpaar haben möchten. Aus "Tupeln" können zwei Arten von Instanzen erstellt werden. Pair<T1, T2> Klicken Sie hier für verschiedene Typen.

Pair

Pair<String, Object> keyValuePair = Tuples.pair("key", value);
String key = keyValuePair.getOne();
Object value = keyValuePair.getTwo();

Twin Wenn Sie mit Werten desselben Typs arbeiten möchten, können Sie diese verwenden.

Twin

Twin<String> keyValueTwin = Tuples.twin("key", "valiue");
String key = keyValueTwin.getOne();
String value = keyValueTwin.getTwo();

Ausnahmebehandlung

Wenn im Lambda eine Prüfausnahme auftritt, wird der präzise geschriebene Code ruiniert. Importieren Sie in einem solchen Fall statisch Folgendes und verwenden Sie die Wurfmethode.

import static org.eclipse.collections.impl.block.factory.Procedures.*;
import static org.eclipse.collections.impl.block.factory.Functions.*;
import static org.eclipse.collections.impl.block.factory.Predicates.*;

Wenn beim Auslösen eine Ausnahme auftritt, wird sie in eine RuntimeException eingeschlossen und erneut ausgelöst. Jetzt kann ich es kurz schreiben.

throwing

		hogeList
			.each(throwing(Fuga::piyo)
			;