[Ein Muss für einen Java-Ingenieurlehrling] Verwendung der Stream-API

Artikelübersicht

Dieser Artikel befasst sich mit der Verwendung der Stream-API. Viele Beispiele und Erklärungen zum Quellcode werden bereitgestellt, damit auch diejenigen, die mit der Stream-API noch nicht vertraut sind, sie verstehen können. Außerdem wird die angewandte Verwendung wie das Strategiemuster mithilfe der Stream-API eingeführt.

Vorteile des Lernens der Stream-API

――Da die Verarbeitung wie Wörter erfolgt, wird die Lesbarkeit verbessert.

• Klare Ein- und Ausgabe erleichtern das Schreiben von Testcode
• Fehler sind schwer zu verbergen, da sie keine Statusänderungen verursachen --Kombinationsfunktionen beeinflussen sich nicht gegenseitig
• Unterstützt die Parallelverarbeitung

Wann kann ich die Stream-API verwenden?

Es kann an Orten verwendet werden, an denen die Schleifenverarbeitung am häufigsten ausgeführt wird, z. B. für Anweisungen.

Verwendung der Stream-API

Der grundlegende Ablauf besteht darin, eine Stream-Instanz zu erstellen, so viele Prozesse auszuführen, wie Sie möchten (Zwischenoperation) und sie schließlich in den gewünschten Zustand zu bringen (Endpunktoperation).

Vergleichen wir **, wenn Sie die Stream-API nicht verwendet haben ** und **, wenn Sie ** verwendet haben, um sich diesen Prozess vorzustellen.

Der unten geschriebene Code zeigt den Quellcode, der die in der Liste gespeicherte Zeichenfolge in Großbuchstaben konvertiert und nur die 4-stellige Zeichenfolge extrahiert und anzeigt.

//Code, der ohne Verwendung der Stream-API geschrieben wurde
List<String> list2 = Arrays.asList("hoge", "foo", "bar","hoga");
		List<String> stream2 = new ArrayList<String>();
		for(String s :list2){
			String sUpperCase = s.toUpperCase();
			if(sUpperCase.length() == 4){
				stream2.add(sUpperCase);
			}
		}
		for(int i = 0; i < stream2.size(); i++){
			System.out.println(stream2.get(i));
		}

/*
Das Ergebnis ist wie folgt
HOGE
HOGA
*/

//Bei Verwendung der Stream-API
		List<String> list1 = Arrays.asList("hoge", "foo", "bar","hoga");
		List<String> stream1 = list1.stream()
								.map(String::toUpperCase)
								.filter(s -> s.length() == 4)
								.collect(Collectors.toList());
		stream1.forEach(System.out::println);

/*
Das Ergebnis ist wie folgt
HOGE
HOGA
*/

Die Verwendung der Stream-API wie diese ist einfacher zu lesen, da Sie nur schreiben müssen, was Sie deklarativ tun möchten. (Es gibt einen Vorteil, da es keine andere Statusänderung gibt und unnötige Verarbeitung aufgrund von Verarbeitungsverzögerung nicht ausgeführt wird.)

Nachdem Sie eine Vorstellung von der Verwendung der Stream-API haben, werde ich Ihnen die Verwendung ausführlich erläutern.

Ich werde den Stromfluss separat wie folgt erklären. ** 1. Stream-Instanzerstellung ** ** 2. Zwischenbetrieb ** ** 3. Endpunktbetrieb **

1. Erstellen Sie eine Stream-Instanz

Es gibt viele Möglichkeiten, eine Stream-Instanz zu erstellen, aber hier sind vier, die Sie möglicherweise am häufigsten verwenden.

Wie schreibe ich Quellcode

// Collection#stream()
List<String> list = Arrays.asList("hoge", "foo", "bar");
Stream<String> stream = list.stream();

// Arrays#stream (T[] array)
String[] array = {"hoge", "foo", "bar"};
Stream<String> stream2 = Arrays.stream(array);

// Stream#of (T[] array)
Stream<String> stream3 = Stream.of("hoge", "foo", "bar");

// Stream#iterate (T seed, UnaryOperator f)
Stream<Integer> stream4 = Stream.iterate(2, x -> x * 2);

2. Zwischenbetrieb

Zwischenoperationen sind grob in drei Verarbeitungsmethoden unterteilt.

• Verengen Sie die Elemente
• Verarbeitung von Elementen
• Elemente sortieren

** 1. Ich denke, Sie verstehen, wie eine Stream-Instanz erstellt wird **, daher werde ich die Zwischenoperationen für die generierte Stream-Instanz eingrenzen.

• Es gibt Prädikate und Funktionen, diese werden jedoch später ausführlich erläutert. Derzeit ist der Prozess zur Rückgabe von wahr und falsch in Prediate geschrieben. Bitte denken Sie daran, dass die zu verarbeitende Verarbeitung in Funktion geschrieben ist.

Grenzen Sie die Elemente ein

Da es eingegrenzt ist, ändert sich die Anzahl der Ein- und Ausgänge.

Wie schreibe ich Quellcode

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//Nur 4-stellige Zeichenfolge mit Filter extrahiert
System.out.println("****↓　filter****");
list.stream()
	.filter(s -> s.length() == 4)
	.forEach(System.out::println);

/*
Ausgabeergebnis
hoge
hoga
hoga
*/

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//Mit limit bis zu 3 Strings aus dem ersten Zeichen extrahiert
list.stream()
	.limit(3)
	.forEach(System.out::println);

/*
Ausgabeergebnis
hoge
foo
bar
*/

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//Ich habe überspringen verwendet, um das Element th Zeichenfolge vom ersten Buchstaben zu überspringen
list.stream()
	.skip(1)
	.limit(2)
	.forEach(System.out::println);

/*
Ausgabeergebnis
foo
bar
*/

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga","hoga");
//Doppelte Zeichenfolgen wurden mit different entfernt
list.stream()
	.distinct()
	.forEach(System.out::println);

/*
Ausgabeergebnis
hoge
foo
bar
hoga
*/

Verarbeitung von Elementen

Die Anzahl der Ein- und Ausgänge ändert sich nicht, da sie nur verarbeitet werden. Sie können beispielsweise von unten nach oben oder von Zeichenfolge zu Anzahl der Zeichen in der Zeichenfolge wechseln.

Wie schreibe ich Quellcode

List<String> list = Arrays.asList("hoge", "foo", "bar","hoga");
list.stream()
	.map(String::length)
	.forEach(System.out::println);

/*
Ausgabeergebnis
4
3
3
4
*/

Elemente sortieren

Wie schreibe ich Quellcode

List<Person> people = Arrays.asList(
		new Person("Suzuki",24),
		new Person("Yamada",53),
		new Person("Jean Baljan",9),
		new Person("Yokouchi",39));

//Nach Alter sortiert
people.stream()
		.sorted(comparing(Person::getAge))
		.forEach(s -> System.out.println(s.toString()));
/*
Ausgabeergebnis
Jean Baljan:9
Suzuki:24
Yokouchi:39
Yamada:53
*/


//Nach Name sortieren.reversed()Bei Verwendung in absteigender Reihenfolge
people.stream()
		.sorted(comparing(Person::getName).reversed())
		.forEach(s -> System.out.println(s.toString()));
}

/*
Ausgabeergebnis
Suzuki:24
Yokouchi:39
Yamada:53
Jean Baljan:9
*/

//Personenklasse oben verwendet
public class Person {
	private String name;
	private int age;
	public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public String toString(){
		return name + ":" + age;
	}
}

3. Endpunktbetrieb

Die Endpunktoperation ist die letzte Operation, die eine Stream-Instanz erstellt und Zwischenoperationen abschließt.

Wie schreibe ich Quellcode Da die Menge diesmal groß ist, habe ich ein Beispiel geschrieben, indem ich ungefähr 3 entsprechend extrahiert habe. Es gibt einen optionalen Rückgabewert, der später erläutert wird.

List<Person> people = Arrays.asList(
		new Person("Suzuki",24),
		new Person("Yamada",53),
		new Person("Jean Baljan",9),
		new Person("Yokouchi",39));

//Nach Alter sortieren und in Liste speichern
List<Person> sortedPeople = people.stream()
								.sorted(comparing(Person::getAge))
								.collect(Collectors.toList());
System.out.println(sortedPeople);
/*
Ausgabeergebnis
[Jean Baljan:9,Suzuki:24,Yokouchi:39,Yamada:53]
 */

//Sortieren Sie nach Alter in absteigender Reihenfolge und erhalten Sie die erste Person
Optional<Person> firstPerson = people.stream()
								.sorted(comparing(Person::getAge).reversed())
								.findFirst();
System.out.println(firstPerson);
/*
Ausgabeergebnis
Optional[Yamada:53]
*/

//Richtig, wenn alle Personen 10 Jahre oder älter sind, andernfalls falsch
boolean ss = people.stream()
					.allMatch(p -> p.getAge() > 10);
System.out.println(ss);
/*
Ausgabeergebnis
false
*/

Über Optional

Was ist optional?

Ein Containerobjekt, das mit oder ohne Nicht-Null-Werten gespeichert werden kann. Es ist nicht erforderlich, eine Null-Po-Verarbeitung wie if (xxx == null) durchzuführen. Bitte lesen Sie es, da es in einem leicht verständlichen Dokument organisiert ist. https://docs.oracle.com/javase/jp/8/docs/api/java/util/Optional.html

Verwendung Optional

Dies ist ein Beispiel für die Methode ifPresent (Consumer <? Super T> consumer). Dieses Programm gibt den ersten Wert aus, der gefunden wird, wenn die Anzahl der Zeichen im Nachnamen 3 oder mehr beträgt.

//Wenn Optional nicht verwendet wird
List<String> people = Arrays.asList("Yamada","Tanaka","Suzuki");
String firsPerson = null;
for(String s : people){
	if(s.length() == 3){
		firsPerson = s;
		break;
	}
}
//Nullprüfung
if(firsPerson != null){
	System.out.println(firsPerson);
}

//Verwenden Sie Optional und führen Sie es nur aus, wenn der Wert vorhanden ist
Optional<String> firstPerson = Stream.of("Yamada","Tanaka","Suzuki")
									.filter(s -> s.length() == 3)
									.findFirst();
firstPerson.ifPresent(System.out::println);

Ruft den angegebenen Verbraucher mit diesem Wert auf, falls vorhanden, andernfalls wird nichts unternommen.

Predicate

Was ist Prädikat?

Gibt den Booleschen Wert des Verarbeitungsergebnisses zurück. Sie können auch Prozesse verbinden, wenn es also einen Prozess gibt, der eine große Anzahl von if-Anweisungen verbindet Es kann effektiv eingesetzt werden.

Verwendung von Predicate

Implementieren Sie einen Prozess, der einen Wert vom Typ T als Argument verwendet und einen booleschen Wert zurückgibt. Der Wert von boolean wird zurückgegeben, indem der Testmethode das Argument T gegeben wird.

Predicate<String> predicate = s -> s.length() == 5;
System.out.println(predicate.test("tarou"));

Function

Was ist Funktion?

Stellt eine Funktion dar, die ein Argument akzeptiert und ein Ergebnis erzeugt.

So verwenden Sie die Funktion

Implementieren Sie den Prozess des Empfangens eines T-Typ-Arguments und des Zurückgebens eines R-Typ-Werts. Sie kann ausgeführt werden, indem Sie der Methode apply das Argument T geben.

Function<String,String> toUpper = s -> s.toUpperCase();
System.out.println(toUpper.apply("tarou"));

Consumer

Was ist optional?

Verwendung Optional

Empfängt einen T-Typ-Wert als Argument und implementiert die Verarbeitung ohne Rückgabewert. Sie kann ausgeführt werden, indem Sie der Methode accept das Argument T geben.

Consumer<String> consumer = string -> System.out.println("Cunsumer : " + string);
consumer.accept("tarou");

Parallelverarbeitung

comming soon

Rekursive Verarbeitung durch verzögerte Auswertung

comming soon