package tryAny.effectiveJava;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Anagrams {
public static void main(String[] args) throws IOException {
File dictionary = new File("/application/gradle/getting-started.html");
int minGroupSize = 2;
Map<String, Set<String>> groups = new HashMap<>();
//Beispiel 1 starten
try (Scanner s = new Scanner(dictionary)) {
while (s.hasNext()) {
String word = s.next();
groups.computeIfAbsent(alphabetize(word), (unused) -> new TreeSet<>()).add(word);
}
}
for (Set<String> group : groups.values()) {
if (group.size() >= minGroupSize) {
System.out.println(group.size() + ":" + group);
}
}
//Beispiel 1 Ende
//Beispiel 2 starten(Dies unterscheidet sich von Beispiel 1, da das Anagramm Zeile für Zeile erstellt wird.)
Path dictionary2 = Paths.get("/application/gradle/getting-started.html");
try (Stream<String> words = Files.lines(dictionary2)) {
words.collect(Collectors.groupingBy(word -> word.chars().sorted()
.collect(StringBuilder::new, (sb, c) -> sb.append((char) c), StringBuilder::append).toString()))
.values().stream().filter(group -> group.size() >= minGroupSize)
.map(group -> group.size() + ":" + group).forEach(System.out::println);
}
//Beispiel 2 Ende
//Start von Beispiel 3 (gleiches Ergebnis wie in Beispiel 2)
try (Stream<String> words = Files.lines(dictionary2)) {
words.collect(Collectors.groupingBy(word -> alphabetize(word)))
.values().stream()
.filter(group -> group.size() >= minGroupSize)
.forEach(g -> System.out.println(g.size() + ":" + g));
}
//Beispiel 3 Ende
}
private static String alphabetize(String s) {
char[] a = s.toCharArray();
Arrays.sort(a);
return new String(a);
}
}
package tryAny.effectiveJava;
public class CharStream {
public static void main(String[] args) {
"Hello, world!".chars().forEach(System.out::print);
//72101108108111443211911111410810033 wird angezeigt
System.out.println();
"Hello, world!".chars().forEach(x -> System.out.print((char) x));
// Hello, world!Wird angezeigt
}
}
Wenn Sie eine vorhandene for-Schleife durch einen Stream ersetzen, sollten Sie dies nur tun, wenn dies sinnvoll ist.
Das Folgende kann mit einem Codeblock (** gewöhnliche Wiederholungsanweisung? **) durchgeführt werden, was mit der Stream-Verarbeitung unter Verwendung von Funktionsobjekten nicht möglich ist.
Lambda-Ausdrücke können nur praktisch endgültige lokale Variablen lesen, aber Codeblöcke können alles lesen und ändern.
Mit dem Codeblock können Sie von der einschließenden Methode zurückkehren (** was meinen Sie? **), Sie können break ausführen und von der Schleife fortfahren, und Sie können die deklarierte geprüfte Ausnahme auslösen, aber mit dem Lambda-Ausdruck ist das alles. Das kann ich nicht machen
Folgendes können Sie ganz einfach mit Stream tun:
Einheitliche Elementumwandlung
Elementfilterung
Verarbeitung zum Verbinden von Elementen in einer einzigen Operation (Addition, Mindestwert usw.)
Verarbeitung zum Aggregieren von Elementen in der Sammlung (Gruppierung nach bestimmten Attributen usw.)
Der Prozess der Suche nach Elementen, die bestimmte Kriterien erfüllen
Die Verarbeitung, bei der Elemente in verschiedenen Phasen der Pipeline gleichzeitig verarbeitet werden, ist mit Stream schwierig. Im folgenden Beispiel wird eine Mersenne-Primzahl ausgegeben. Eine Mersenne-Primzahl ist eine Zahl, die durch 2 ^ p-1 dargestellt wird, wenn p eine Primzahl ist und immer eine Primzahl ist. Mit Stream-Verarbeitung Primzahl → Mersenne-Primzahl → Durch 20 trennen → Anzeige Im angezeigten Teil ist es jedoch nicht möglich, auf die ursprüngliche Primzahl zuzugreifen (obwohl diesmal eine Rückrechnung aus dem Ergebnis möglich war).
package tryAny.effectiveJava;
import static java.math.BigInteger.*;
import java.math.BigInteger;
import java.util.stream.Stream;
public class MersennePrimes {
public static void main(String[] args) {
primes().map(p -> TWO.pow(p.intValueExact()).subtract(ONE)).filter(mersenne -> mersenne.isProbablePrime(50))
.limit(20)
// .forEach(System.out::println);
.forEach(mp -> System.out.println(mp.bitLength() + ":" + mp));
}
static Stream<BigInteger> primes() {
return Stream.iterate(TWO, BigInteger::nextProbablePrime);
}
}
Recommended Posts