fscotto/fpgym
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Algoritmi di collector

Browse Source
This commit is contained in:
Fabio Scotto di Santolo
2019-11-21 17:43:50 +01:00
parent 0f0ae0ccec
commit 60630cd7f1
1 changed files with 109 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
modern-java/src/main/java/org/gym/fp/moderjava/StreamTest.java
View File

@@ -1,11 +1,13 @@
package org.gym.fp.moderjava;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import static java.lang.System.out;
import static java.util.Arrays.asList;
import static java.util.Comparator.comparingInt;
import static java.util.stream.Collectors.*;
public class StreamTest {
@@ -14,13 +16,14 @@ public class StreamTest {
doStreamMappingDemo();
doStreamFindOrMatchingDemo();
doStreamReducingDemo();
doStreamCollectingDemo();
}
private static void doStreamFilterDemo() {
out.println("FILTER EXAMPLE");
getDishes().stream()
.filter(Dish::isVegetarian)
.collect(Collectors.toList())
.collect(toList())
.forEach(out::println);
out.println("----------------------------------------");
out.println("DISTINCT EXAMPLE");
@@ -42,26 +45,26 @@ public class StreamTest {
}
private static void doStreamMappingDemo() {
List<String> words = Arrays.asList("Hello", "World");
List<String> words = asList("Hello", "World");
List<String> uniqueCharacters = words.stream()
.map(word -> word.split(""))
.flatMap(Arrays::stream)
.distinct()
.collect(Collectors.toList());
.collect(toList());
out.println(uniqueCharacters);
out.println("----------------------------------------");
out.println("Permutations");
List<Integer> numbers1 = Arrays.asList(1, 2, 3);
List<Integer> numbers2 = Arrays.asList(3, 4);
List<Integer> numbers1 = asList(1, 2, 3);
List<Integer> numbers2 = asList(3, 4);
List<int[]> pairs1 = numbers1.stream()
.flatMap(i -> numbers2.stream().map(j -> new int[]{i, j}))
.collect(Collectors.toList());
.collect(toList());
pairs1.forEach(pair -> out.println(Arrays.toString(pair)));
out.println("----------------------------------------");
List<int[]> pairs2 = numbers1.stream()
.flatMap(i -> numbers2.stream().map(j -> new int[]{i, j}))
.filter(pair -> (pair[0] + pair[1]) % 3 == 0)
.collect(Collectors.toList());
.collect(toList());
pairs2.forEach(pair -> out.println(Arrays.toString(pair)));
out.println("----------------------------------------");
}
@@ -89,7 +92,7 @@ public class StreamTest {
dish.ifPresent(out::println);
out.println("----------------------------------------");
out.println("FINDFIRST EXAMPLE");
List<Integer> someNumbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> someNumbers = asList(1, 2, 3, 4, 5);
someNumbers.stream()
.map(n -> n * n)
.filter(n -> n % 3 == 0)
@@ -118,26 +121,26 @@ public class StreamTest {
Trader mario = new Trader("Mario", "Milan");
Trader alan = new Trader("Alan", "Cambridge");
Trader brian = new Trader("Brian", "Cambridge");
List<Transaction> transactions = Arrays.asList(
List<Transaction> transactions = asList(
new Transaction(brian, 2011, 300),
new Transaction(raoul, 2012, 1000),
new Transaction(raoul, 2011, 400),
new Transaction(mario, 2012, 710),
new Transaction(mario, 2012, 700),
new Transaction(alan, 2012, 950)
);
);
out.println("1)");
transactions.stream()
.filter(t -> t.getYear() == 2011)
.sorted(Comparator.comparing(Transaction::getValue))
.collect(Collectors.toList())
.collect(toList())
.forEach(out::println);
out.println("2)");
transactions.stream()
.map(Transaction::getTrader)
.map(Trader::getCity)
.distinct()
.collect(Collectors.toList())
.collect(toList())
.forEach(out::println);
out.println("3)");
transactions.stream()
@@ -145,7 +148,7 @@ public class StreamTest {
.filter(trader -> "Cambridge".equalsIgnoreCase(trader.getCity()))
.distinct() // anche se sul testo non è specificato che dovevano essere diversi
.sorted(Comparator.comparing(Trader::getName))
.collect(Collectors.toList())
.collect(toList())
.forEach(out::println);
out.println("4)");
String result = transactions.stream()
@@ -180,19 +183,107 @@ public class StreamTest {
.flatMap(a -> IntStream.rangeClosed(a, 100)
.mapToObj(b -> new double[]{a, b, Math.sqrt(a * a + b * b)})
.filter(t -> t[2] % 1 == 0)
)
)
.limit(5)
.forEach(triple -> out.printf("(%.0f, %.0f, %.0f)\n", triple[0], triple[1], triple[2]));
out.println("----------------------------------------");
Stream.iterate(new int[] {0, 1}, t -> new int[] {t[1], t[0] + t[1]})
Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
.limit(20)
.forEach(pair -> out.printf("(%d, %d) ", pair[0], pair[1]));
out.println();
out.println("----------------------------------------");
}
private static void doStreamCollectingDemo() {
List<Dish> menu = getDishes();
long howManyDishes = menu.stream().count();
out.println(howManyDishes);
out.println("----------------------------------------");
Comparator<Dish> dishCaloriesComparator = comparingInt(Dish::getCalories);
menu.stream()
.collect(maxBy(dishCaloriesComparator))
.ifPresent(out::println);
out.println("----------------------------------------");
int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));
out.println(totalCalories);
out.println("----------------------------------------");
double avgCalories = menu.stream().collect(averagingInt(Dish::getCalories));
out.println(avgCalories);
out.println("----------------------------------------");
IntSummaryStatistics menuStatistics = menu.stream().collect(summarizingInt(Dish::getCalories));
out.println(menuStatistics);
out.println("----------------------------------------");
String shortMenu = menu.stream()
.map(Dish::getName)
.collect(joining(", "));
out.println(shortMenu);
out.println("----------------------------------------");
Map<Dish.Type, List<Dish>> dishesByType = menu.stream().collect(groupingBy(Dish::getType));
out.println(dishesByType);
out.println("----------------------------------------");
Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect(groupingBy(dish -> {
if (dish.getCalories() <= 400) return CaloricLevel.DIET;
else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT;
}));
out.println(dishesByCaloricLevel);
out.println("----------------------------------------");
Map<Dish.Type, List<Dish>> caloricDishesByType =
menu.stream()
.collect(groupingBy(Dish::getType,
filtering(dish -> dish.getCalories() > 500,
toList())));
out.println(caloricDishesByType);
out.println("----------------------------------------");
Map<Dish.Type, List<String>> dishNamesByType =
menu.stream()
.collect(groupingBy(Dish::getType,
mapping(Dish::getName, toList())));
out.println(dishNamesByType);
out.println("----------------------------------------");
Map<String, List<String>> dishTags = Map.of(
"pork", asList("greasy", "salty"),
"beef", asList("salty", "roasted"),
"chicken", asList("fried", "crisp"),
"french fries", asList("greasy", "fried"),
"rice", asList("light", "natural"),
"season fruit", asList("fresh", "natural"),
"pizza", asList("tasty", "salty"),
"prawns", asList("tasty", "roasted"),
"salmon", asList("delicious", "fresh")
);
Map<Dish.Type, Set<String>> dishNamesByType2 =
menu.stream()
.collect(groupingBy(Dish::getType,
flatMapping(dish -> {
// FIXME: The example of book is not safety
List<String> tags = dishTags.get(dish.getName());
if (tags != null) {
return tags.stream();
}
return Stream.empty();
}, toSet())));
out.println(dishNamesByType2);
out.println("----------------------------------------");
Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishesByTypeCaloricLevel =
menu.stream()
.collect(groupingBy(Dish::getType, groupingBy(dish -> {
if (dish.getCalories() <= 400)
return CaloricLevel.DIET;
else if (dish
.getCalories() <= 700)
return CaloricLevel.NORMAL;
else
return CaloricLevel.FAT;
})));
out.println(dishesByTypeCaloricLevel);
out.println("----------------------------------------");
}
enum CaloricLevel {DIET, NORMAL, FAT}
private static List<Dish> getDishes() {
List<Dish> dishes = Arrays.asList(
List<Dish> dishes = asList(
new Dish("pork", 300, Dish.Type.MEAT),
new Dish("salad", 50, Dish.Type.VEGETARIAN),
new Dish("chicken", 100, Dish.Type.MEAT),
@@ -200,7 +291,7 @@ public class StreamTest {
new Dish("tomato", 30, Dish.Type.VEGETARIAN),
new Dish("tunny", 120, Dish.Type.FISH),
new Dish("potato", 70, Dish.Type.VEGETARIAN)
);
);
return Collections.unmodifiableList(dishes);
}