Comment utiliser java.util.stream.Collector

table des matières

--Introduction --Créer un collectionneur -Facile à utiliser Collector

• Collectionner des collectionneurs --Générer à partir du collecteur

introduction

--Depuis Java 8, l'API Stream est largement utilisée au lieu de l'instruction for --Stream dispose d'un ensemble de traitements de terminaison, dont le représentant est la méthode de collecte.

• L'argument de la méthode collect est java.util.stream.Collector

Faire un collectionneur

//Collecteur à convertir en ArrayList
Collector<T, ?, List<T>> toArrayList = Collector.of(
        ArrayList::new,
        List::add,
        (l1, l2) -> {
            l1.addAll(l2);
            return l1;
        },
        Characteristics.IDENTITY_FINISH);

//Courir
.stream().collect(toArrayList);

Il existe de nombreux articles d'introduction sur la façon de procéder, alors allez-y.

Le traitement de conversion de flux peut être effectué à l'aide de Collector

Utilisez Collector sans effort

//Exemple de méthode
Stream<String> stream() {
  return Stream.of("1","20","30");
}
//Convertir en liste: [1, 20, 30]
stream().collect(toList());
//Concaténation de chaînes: "<1,20,30>"
stream().collect(joining(",", "<", ">"));
//regroupement: {1=[1], 2=[20, 30]}
stream().collect(groupingBy(String::length));
//Liste qui ne peut pas être modifiée
stream().collect(collectingAndThen(toList(), Collections::unmodifiableList));

• Les collectionneurs utilisent l'importation statique

La conversion de flux peut être effectuée facilement avec les collectionneurs

Cependant, il existe de nombreux articles qui présentent Collector ...

résultat

La voix de l'utilisateur

Utilisateur A: Collector ne fait pas grand chose Utilisateur B: il est difficile d'appeler les collectionneurs à chaque fois Utilisateur C: Je veux que Stream ait toList ou toMap directement comme les autres langues.

C'est vrai, mais collect est une méthode légèrement plus générique

au fait

class Hoge {
	String methodA(String str) {
		if (str == null || str.equals("")) {
			return "A";
		}
		// ..
	}
	String methodB(String str) {
		if (str == null || str.equals("")) {
			return "B";
		}
		// ..
	}
}

Que faire avec ce code?

Commonize (définition)

class StringUtil {
	boolean isEmpty(String str) {
		return str == null || str.equals("");
	}
}

Rendez-le commun (appelez)

class Hoge {
	String methodA(String str) {
		if (isEmpty(str)) {
			return "A";
		}
		// ..
	}
	String methodB(String str) {
		if (isEmpty(str)) {
			return "B";
		}
		// ..
	}
}

Alors qu'est-ce que c'est?

String methodA(List<String> list) {
  list.stream()
    .map(/* ... */)
    .collect(collectingAndThen(toList(),Collections::unmodifiableList));
}
 
String methodB(List<String> list) {
  list.stream()
    .filter(/* ... */)
    .collect(collectingAndThen(toList(),Collections::unmodifiableList));
}

Rendre le collectionneur commun

//Classe d'utilité du collecteur
class Collectors2 {
　　　　//Renvoie un collecteur qui se convertit en une liste non modifiable
  static <T> Collector<T,?,List<T>> toUnmodifiableList() {
    return collectingAndThen(toList(), Collections::unmodifiableList);
  }
}
//Utiliser l'utilitaire
stream()
　　　　.collect(collectingAndThen(toList(),Collections::unmodifiableList));
// ↓
stream()
　　　　.collect(toUnmodifiableList());

Puisqu'il s'agit d'une méthode, le nom est gratuit

• toUnmodifiableList()
• toImmutableList()
• il()

Cependant, il faut tenir compte de la compréhensibilité

Exemple d'utilisation (conversion de flux)

class Collectors2 {
  //Groupe et carte.Collecteur qui renvoie Stream of Entity
  static <T, K> Collector<T, ?, Stream<Map.Entry<K, List<T>>>> grouping(Function<T, K> mapper) {
    return collectingAndThen(
　　　　　　　　　　　　　　　　groupingBy(mapper),
　　　　　　　　　　　　　　　　m -> m.entrySet().stream()
　　　　　　　　);
  }
}
//Regrouper et convertir à nouveau en Stream
stream()
    .collect(groupingBy(String::length)).entrySet().stream();
// ↓
stream()
    .collect(grouping(String::length));

Collect () devient simple et polyvalent en préparant un utilitaire pour Collector comme String.

Traitement commun

//Classe avec historique des événements
@AllArgsConstructor
class History {
    List<String> events;
}

//Faites une liste d'événements
List<String> events = stream().collect(toList());
//Générer l'historique
History history = new History(events);

Peut créer des objets directement

List<String> events = stream().collect(toList());
History history = new History(events);

// ↓

//Convertir directement en historique
History history = stream()
    .collect(collectingAndThen(toList(),　History::new));

collect n'est pas seulement une méthode pour générer des listes et des cartes

Combiner davantage

class Collectors2 {
  //Après la conversion en List, retournez Collector qui exécute la fonction de mappage
　　　　static <T, R> Collector<T, ?, R> toListAnd(Function<List<T>, R> mapper) {
    return collectingAndThen(toList(), mapper);
　　　　}
}

//appel
History history = stream()
  .collect(collectingAndThen(toList(),　History::new));
//　↓
History history = stream()
  .collect(toListAnd(History::new));

Exemple d'utilisation (conversion facultative)

class Collectors2 {
  // toList()Facultatif si est vide.empty(), Facultatif si non vide<List<T>>rends le
  static <T> Collector<T, ?, Optional<List<T>>> toOptionalList() {
    return collectingAndThen(toList(), l -> l.isEmpty() ? Optional.empty() : Optional.of(l));
  }
  //Exécuter la fonction avec cette liste comme argument uniquement lorsque la liste n'est pas vide
  static <T, R> Collector<T, ?, Optional<R>> ifNotEmptyList(Function<List<T>, R> mapper) {
    return collectingAndThen(toOptionalList(), op -> op.map(mapper));
  }
}

//Générer l'historique uniquement lorsque la liste n'est pas vide
Optional<History> history = stream()
    .collect(ifNotEmptyList(History::new));

Exemple d'utilisation (Autre)

//Convertir en Json
stream
    .collect(toJson());
//Convertir en CSV
stream
    .collect(toCsv());
//Convertir en paramètres de demande
stream
    .collect(toRequestParam());
//Convertir en SQL
stream
    .collect(toSql());

Les collecteurs peuvent être réutilisés en combinant des collecteurs à usage général.

Pour une utilisation plus pratique

Comment utiliser le collecteur de gakuzzzz

• Synthesize Java8 Stream API Collector
• Comment utiliser un certain Doma2

Classe utilitaire des collections Eclipse (la source est également utile)

• Collectors2

Résumé

• Puisque Java 8 Stream est une API fréquente --Collector fait partie de l'endroit où Stream est
• La méthode de collecte est générique
• Les collectionneurs peuvent être combinés et partagés --Collector peut être converti en votre objet préféré en fonction de la façon dont vous l'utilisez

Enjoy collecting!!

référence

http://www.ne.jp/asahi/hishidama/home/tech/java/collector.html