[JAVA] Fiche technique des collections Eclipse

Aperçu

Quant à l'explication d'Eclipse Collections elle-même, je pense qu'il y a beaucoup d'autres bons articles, donc ici je vais le télécharger comme une référence à laquelle vous pouvez vous référer immédiatement lorsque vous pensez "Je veux faire XX". Pour le moment, j'ai essayé de lister ceux que j'utilise souvent, mais je peux les ajouter s'ils sortent.

• • Presque seul le type de liste est écrit. *

environnement

Ver.8.0.0

• Je suis désolé, c'est une version que j'utilise habituellement au travail, donc c'est un peu vieux. *

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>

Initialisation

Liste vide

empty

Lists.mutable.empty();

À partir de ce moment, immutable (ImmutableList) peut être utilisé en plus de mutable (MutableList), sauf indication contraire. ImmutableList n'a pas de méthodes telles que add et ne peut pas être modifiée.

• • Veuillez noter que certaines méthodes, telles que les systèmes de tri, ne peuvent être utilisées qu'avec MutableList *

empty

Lists.immutable.empty();

Initialisez tous ensemble

of

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

Initialiser basé sur Iterable

Vous pouvez convertir java.util.List etc. en ImmutableList etc.

ofall

Lists.immutable.ofAll(hogeList);

Collection de motifs fréquente

Extraire uniquement les éléments qui satisfont aux conditions

select

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

Je veux vérifier s'il y a un élément qui remplit les conditions

ʻAnySatisfy` renvoie true s'il y a au moins un élément qui remplit la condition.

anySatisfy

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

Je veux m'assurer que tous les éléments ne remplissent pas les conditions

noneSatisfy renvoie true s'il n'y a aucun élément qui remplit la condition.

noneSatisfy

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

Je veux savoir s'il y a même un élément qui remplit les conditions

detect récupère uniquement le premier des éléments qui remplissent la condition.

detect

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

Convertir des éléments en une nouvelle liste

collect

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

Déduplication

Éliminez la duplication et ne laissez que des éléments uniques.

distinct

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

Il est également possible de préciser les critères pour juger qu'il est unique. À ce stade, seul le premier des éléments en double reste dans la liste des résultats.

distinct

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

Tri

sortThis

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

Il est également possible de spécifier les critères de tri et de trier par ordre décroissant.

sortThisBy

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

répétition

Si vous voulez répéter le processus et continuer à écrire, il y a aussi «tap».

each

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		hogeList
			.each(s ->
				System.out.println(s)
			);
		//Résultat d'exécution
		//hoge
		//fuga
		//piyo

Avec forEachWithIndex, vous pouvez effectuer une boucle avec index.

forEachWithIndex

		ListIterable<String> hogeList = Lists.mutable.of("hoge", "fuga", "piyo");
		hogeList
			.forEachWithIndex((string, index) ->
				System.out.println(String.valueOf(index).concat(string))
			);
		//Résultat d'exécution
		//0hoge
		//1fuga
		//2piyo

Agrégat

Avec groupBy, vous pouvez grouper par la valeur spécifiée. Il revient dans le type ListMultimap et peut être récupéré de différentes manières, mais j'aime l'utiliser comme Pair (discuté ci-dessous) avec la méthodekeyMultiValuePairsView ().

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());
			});
		//Résultat d'exécution
		//4 -> [hoge, fuga, piyo]
		//6 -> [hogera]
		//8 -> [fugafuga, piyopiyo]

total

sumOfInt

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

Je veux obtenir un seul élément

Premier

S'il n'y a aucun élément, null est renvoyé.

getFirst

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

Le dernier

Encore une fois, s'il n'y a aucun élément, null est renvoyé.

getLast

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

Élément qui ne devrait être qu'un

Si vous devez être capable de restreindre les éléments à un seul avec select, etc., utilisez getOnly. IllegalStateException est levé s'il y a plus d'un élément.

getOnly

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

Conversion à partir de la collection standard

Les collections standard telles que java.util.List sont souvent utilisées dans les frameworks utilisés dans les projets. Dans un tel cas, si vous voulez utiliser Eclipse Collections, vous devrez le convertir une fois en type Eclipse Collections avec ʻofAll` etc. comme indiqué ci-dessous, mais ce sera un peu dérangeant si le nombre augmente.

Ont tendance à être comme ça

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

Dans un tel cas, vous pouvez utiliser la méthode des collestions d'éclipse en une seule fois en utilisant ListAdapter. Si c'est ʻArray au lieu de List, il y a aussi ʻArrayAdapter.

C'était bon

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

Il y a aussi ListIterate et ʻArrayIterate` qui ne nécessitent même pas d'adaptation.

ListIterate

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

Autres jeux de données

Je veux garder deux valeurs comme un ensemble

Il est utilisé lorsque vous souhaitez avoir des données sous forme de paire clé et valeur. Deux types d'instances peuvent être créés à partir de «Tuples». Pair<T1, T2> Cliquez ici pour les différents types.

Pair

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

Twin Si vous souhaitez travailler avec des valeurs du même type, vous pouvez l'utiliser.

Twin

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

Gestion des exceptions

Si une exception de vérification se produit dans le lambda, le code qui a été écrit de manière concise sera ruiné. Dans un tel cas, importez statiquement les éléments suivants et utilisez la méthode de lancement.

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.*;

Si une exception se produit lors de la levée, elle l'enveloppera dans une RuntimeException et la relancera. Maintenant, je peux l'écrire de manière concise.

throwing

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