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<>();
//Exemple 1 début
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);
}
}
//Exemple 1 fin
//Exemple 2 début(Ceci est différent de l'exemple 1 car l'anagramme est pris ligne par ligne.)
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);
}
//Exemple 2 fin
//Exemple 3 début (même résultat que l'exemple 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));
}
//Exemple 3 fin
}
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 s'affiche
System.out.println();
"Hello, world!".chars().forEach(x -> System.out.print((char) x));
// Hello, world!Est affiché
}
}
Lorsque vous remplacez une boucle for existante par un flux, vous ne devriez le faire que lorsque cela a du sens.
Ce qui suit peut être fait avec un bloc de code (** instruction répétitive ordinaire? **), ce qui ne peut pas être fait avec un traitement de flux utilisant des objets fonctionnels.
Les expressions Lambda ne peuvent lire que des variables locales pratiquement finales, mais les blocs de code peuvent lire et modifier n'importe quoi.
Avec le bloc de code, vous pouvez revenir de la méthode englobante (** que voulez-vous dire? **), vous pouvez opérer break et continuer à partir de la boucle, et vous pouvez lancer l'exception vérifiée déclarée, mais avec l'expression lambda, c'est tout. Je ne peux pas faire ça.
Voici ce que vous pouvez facilement faire avec le flux:
Conversion d'élément uniforme
Filtrage des éléments
Traitement pour connecter des éléments en une seule opération (ajout, valeur minimale, etc.)
Traitement pour agréger des éléments en collection (regroupement par certains attributs, etc.)
Le processus de recherche des éléments qui répondent à des critères spécifiques
Le traitement qui gère des éléments à différentes étapes du pipeline en même temps est difficile avec stream. Dans l'exemple suivant, un nombre premier de Mersenne est émis. Le nombre premier de Mersenne est un nombre représenté par 2 ^ p-1 lorsque p est un nombre premier, et est toujours un nombre premier. Avec traitement de flux Nombre premier → Nombre premier de Mersenne → Séparé par 20 → Affichage Cependant, dans la partie affichée, il n'est pas possible d'accéder au nombre premier d'origine (bien que cette fois il était possible de recalculer à partir du résultat).
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