Verwendung von java.util.stream.Collector

Inhaltsverzeichnis

--Einführung --Erstellen Sie einen Collector

• Einfache Verwendung von Collector
• Sammle sammeln
• Generieren Sie vom Sammler

Einführung

• Seit Java 8 wird die Stream-API häufig anstelle von for-Anweisungen verwendet --Stream verfügt über eine Reihe von Beendigungsverarbeitungen, deren Vertreter die Erfassungsmethode ist.
• Das Argument der Methode collect lautet "java.util.stream.Collector"

Machen Sie einen Sammler

//Kollektor zum Konvertieren in ArrayList
Collector<T, ?, List<T>> toArrayList = Collector.of(
        ArrayList::new,
        List::add,
        (l1, l2) -> {
            l1.addAll(l2);
            return l1;
        },
        Characteristics.IDENTITY_FINISH);

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

Es gibt viele einführende Artikel dazu. Gehen Sie also dorthin.

Die Stream-Konvertierungsverarbeitung kann mit Collector durchgeführt werden

Verwenden Sie Collector mühelos

//Beispielmethode
Stream<String> stream() {
  return Stream.of("1","20","30");
}
//In Liste konvertieren: [1, 20, 30]
stream().collect(toList());
//String-Verkettung: "<1,20,30>"
stream().collect(joining(",", "<", ">"));
//Gruppierung: {1=[1], 2=[20, 30]}
stream().collect(groupingBy(String::length));
//Liste, die nicht geändert werden kann
stream().collect(collectingAndThen(toList(), Collections::unmodifiableList));

• Sammler verwenden statischen Import

Die Stream-Konvertierung kann mit Collectors problemlos durchgeführt werden

Es gibt jedoch viele Artikel, die Collector ...

Ergebnis

Benutzerstimme

Benutzer A: Collector macht nicht so viel Benutzer B: Es ist schwierig, jedes Mal Collectors anzurufen Benutzer C: Ich möchte, dass Stream toList oder toMap direkt wie andere Sprachen hat.

Das stimmt, aber sammeln ist eine etwas allgemeinere Methode

Apropos

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

Was tun mit diesem Code?

Commonize (Definition)

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

Machen Sie es gemeinsam (Anruf)

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

Was ist das dann?

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

Machen Sie Collector gemeinsam

//Collector-Dienstprogrammklasse
class Collectors2 {
　　　　//Gibt einen Collector zurück, der in eine nicht änderbare Liste konvertiert wird
  static <T> Collector<T,?,List<T>> toUnmodifiableList() {
    return collectingAndThen(toList(), Collections::unmodifiableList);
  }
}
//Verwenden Sie das Dienstprogramm
stream()
　　　　.collect(collectingAndThen(toList(),Collections::unmodifiableList));
// ↓
stream()
　　　　.collect(toUnmodifiableList());

Da es sich um eine Methode handelt, ist der Name frei

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

Die Verständlichkeit muss jedoch berücksichtigt werden

Anwendungsbeispiel (Stream-Konvertierung)

class Collectors2 {
  //Gruppe und Karte.Kollektor, der den Stream of Entity zurückgibt
  static <T, K> Collector<T, ?, Stream<Map.Entry<K, List<T>>>> grouping(Function<T, K> mapper) {
    return collectingAndThen(
　　　　　　　　　　　　　　　　groupingBy(mapper),
　　　　　　　　　　　　　　　　m -> m.entrySet().stream()
　　　　　　　　);
  }
}
//Gruppieren und erneut in Stream konvertieren
stream()
    .collect(groupingBy(String::length)).entrySet().stream();
// ↓
stream()
    .collect(grouping(String::length));

Collect () wird einfach und vielseitig, indem ein Dienstprogramm für Collector wie String vorbereitet wird.

Gemeinsame Verarbeitung

//Klasse mit Ereignisverlauf
@AllArgsConstructor
class History {
    List<String> events;
}

//Machen Sie eine Liste von Ereignissen
List<String> events = stream().collect(toList());
//Verlauf generieren
History history = new History(events);

Kann Objekte direkt erstellen

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

// ↓

//Direkt in Verlauf konvertieren
History history = stream()
    .collect(collectingAndThen(toList(),　History::new));

Sammeln ist nicht nur eine Methode zum Generieren von Listen und Karten

Weiter kombinieren

class Collectors2 {
  //Geben Sie nach der Konvertierung in List Collector zurück, der die Mapper-Funktion ausführt
　　　　static <T, R> Collector<T, ?, R> toListAnd(Function<List<T>, R> mapper) {
    return collectingAndThen(toList(), mapper);
　　　　}
}

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

Anwendungsbeispiel (Optionale Konvertierung)

class Collectors2 {
  // toList()Optional, wenn leer ist.empty(), Optional, wenn nicht leer<List<T>>Gib es zurück
  static <T> Collector<T, ?, Optional<List<T>>> toOptionalList() {
    return collectingAndThen(toList(), l -> l.isEmpty() ? Optional.empty() : Optional.of(l));
  }
  //Führen Sie die Funktion mit dieser Liste nur dann als Argument aus, wenn die Liste nicht leer ist
  static <T, R> Collector<T, ?, Optional<R>> ifNotEmptyList(Function<List<T>, R> mapper) {
    return collectingAndThen(toOptionalList(), op -> op.map(mapper));
  }
}

//Generieren Sie den Verlauf nur, wenn die Liste nicht leer ist
Optional<History> history = stream()
    .collect(ifNotEmptyList(History::new));

Anwendungsbeispiel (Andere)

//In Json konvertieren
stream
    .collect(toJson());
//In CSV konvertieren
stream
    .collect(toCsv());
//In Anforderungsparameter konvertieren
stream
    .collect(toRequestParam());
//In SQL konvertieren
stream
    .collect(toSql());

Collector kann durch Kombination von Allzweck-Collectors wiederverwendet werden

Für eine praktischere Verwendung

Verwendung von gakuzzzz's Collector

• Java8 Stream API Collector synthetisieren
• Verwendung eines bestimmten Doma2

Utility-Klasse von Eclipse-Sammlungen (Quelle ist ebenfalls hilfreich)

• Collectors2

Zusammenfassung

• Da Java 8 Stream eine häufige API ist --Collector ist ein Teil von Stream
• Die Erfassungsmethode ist generisch
• Sammler können kombiniert und geteilt werden --Collector kann je nach Verwendung in Ihr Lieblingsobjekt konvertiert werden

Enjoy collecting!!

Referenz

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