第5章示例代码

Author: ipofss

src/main/java/com/wbs/java8lambda/chapter5/BuildingStreams.java

@@ -0,0 +1,95 @@
+package com.wbs.java8lambda.chapter5;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.function.IntSupplier;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+/**
+ * TODO
+ *
+ * @author: wangbingshuai
+ * @create: 2019-10-31 20:06
+ **/
+public class BuildingStreams {
+    public static void main(String[] args) throws IOException {
+        Stream<String> stream = Stream.of("Java 8", "Lambdas", "In", "Action");
+        stream.map(String::toUpperCase).forEach(System.out::println);
+
+        Stream<Object> emptyStream = Stream.empty();
+
+        System.out.println("---");
+
+        int[] numbers = {2, 3, 5, 7, 11, 13};
+        System.out.println(Arrays.stream(numbers).sum());
+
+        System.out.println("---");
+
+        Stream.iterate(0, n -> n + 2)
+                .limit(10)
+                .forEach(System.out::println);
+
+        System.out.println("---");
+
+        Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
+                .limit(10)
+                .forEach(t -> System.out.println("(" + t[0] + ", " + t[1] + ")"));
+
+        System.out.println("---");
+
+        Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
+                .limit(10)
+                .map(t -> t[0])
+                .forEach(System.out::println);
+
+        System.out.println("---");
+
+        Stream.generate(Math::random)
+                .limit(5)
+                .forEach(System.out::println);
+
+        System.out.println("---");
+
+        IntStream.generate(() -> 1)
+                .limit(5)
+                .forEach(System.out::println);
+
+        System.out.println("---");
+
+        IntStream.generate(new IntSupplier() {
+            @Override
+            public int getAsInt() {
+                return 2;
+            }
+        }).limit(5)
+                .forEach(System.out::println);
+
+        System.out.println("---");
+
+        IntSupplier fib = new IntSupplier() {
+            private int previous = 0;
+            private int current = 1;
+
+            @Override
+            public int getAsInt() {
+                int nextValue = this.previous + this.current;
+                this.previous = this.current;
+                this.current = nextValue;
+                return this.previous;
+            }
+        };
+        IntStream.generate(fib).limit(10).forEach(System.out::println);
+
+        System.out.println("---");
+
+        long uniqueWords = Files.lines(Paths.get("/Users/wangbingshuai/MyOwnProject/java8-lambda/src/main/resources/lambdasinaction/chap5/data.txt"), Charset.defaultCharset())
+                .flatMap(line -> Arrays.stream(line.split(" ")))
+                .distinct()
+                .count();
+        System.out.println("There are " + uniqueWords + " unique words in data.txt");
+    }
+}

src/main/java/com/wbs/java8lambda/chapter5/Filtering.java

@@ -0,0 +1,46 @@
+package com.wbs.java8lambda.chapter5;
+
+import com.wbs.java8lambda.chapter4.Dish;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * TODO
+ *
+ * @author: wangbingshuai
+ * @create: 2019-10-31 19:33
+ **/
+public class Filtering {
+    public static void main(String[] args) {
+        List<Dish> vegetarianMenu = Dish.menu.stream()
+                .filter(Dish::getVegetarian)
+                .collect(Collectors.toList());
+        vegetarianMenu.forEach(System.out::println);
+
+        System.out.println("---");
+
+        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
+        numbers.stream()
+                .filter(n -> n % 2 == 0)
+                .distinct()
+                .forEach(System.out::println);
+
+        System.out.println("---");
+
+        List<Dish> dishesLimit3 = Dish.menu.stream()
+                .filter(d -> d.getCalories() > 300)
+                .limit(3)
+                .collect(Collectors.toList());
+        dishesLimit3.forEach(System.out::println);
+
+        System.out.println("---");
+
+        List<Dish> dishesSkip2 = Dish.menu.stream()
+                .filter(d -> d.getCalories() > 300)
+                .skip(2)
+                .collect(Collectors.toList());
+        dishesSkip2.forEach(System.out::println);
+    }
+}

src/main/java/com/wbs/java8lambda/chapter5/Finding.java

@@ -0,0 +1,41 @@
+package com.wbs.java8lambda.chapter5;
+
+import com.wbs.java8lambda.chapter4.Dish;
+
+import java.util.Optional;
+
+/**
+ * TODO
+ *
+ * @author: wangbingshuai
+ * @create: 2019-10-31 19:53
+ **/
+public class Finding {
+    public static void main(String[] args) {
+        if (isVegetarianFriendMenu()) {
+            System.out.println("Vegetarian friendly");
+        }
+
+        System.out.println(isHealthyMenu());
+        System.out.println(isHealthyMenu2());
+
+        Optional<Dish> dish = findVegetarianDish();
+        dish.ifPresent(d -> System.out.println(d.getName()));
+    }
+
+    private static boolean isVegetarianFriendMenu() {
+        return Dish.menu.stream().allMatch(Dish::getVegetarian);
+    }
+
+    private static boolean isHealthyMenu() {
+        return Dish.menu.stream().allMatch(d -> d.getCalories() < 1000);
+    }
+
+    private static boolean isHealthyMenu2() {
+        return Dish.menu.stream().noneMatch(d -> d.getCalories() >= 1000);
+    }
+
+    private static Optional<Dish> findVegetarianDish() {
+        return Dish.menu.stream().filter(Dish::getVegetarian).findAny();
+    }
+}

src/main/java/com/wbs/java8lambda/chapter5/Laziness.java

@@ -0,0 +1,29 @@
+package com.wbs.java8lambda.chapter5;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * TODO
+ *
+ * @author: wangbingshuai
+ * @create: 2019-10-31 20:02
+ **/
+public class Laziness {
+    public static void main(String[] args) {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
+        List<Integer> twoEvenSquares = numbers.stream()
+                .filter(n -> {
+                    System.out.println("filtering " + n);
+                    return n % 2 == 0;
+                })
+                .map(n -> {
+                    System.out.println("mapping " + n);
+                    return n * n;
+                })
+                .limit(2)
+                .collect(Collectors.toList());
+        System.out.println(twoEvenSquares);
+    }
+}

src/main/java/com/wbs/java8lambda/chapter5/Mapping.java

@@ -0,0 +1,47 @@
+package com.wbs.java8lambda.chapter5;
+
+import com.wbs.java8lambda.chapter4.Dish;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * TODO
+ *
+ * @author: wangbingshuai
+ * @create: 2019-10-31 19:41
+ **/
+public class Mapping {
+    public static void main(String[] args) {
+        List<String> dishNames = Dish.menu.stream()
+                .map(Dish::getName)
+                .collect(Collectors.toList());
+        System.out.println(dishNames);
+
+        System.out.println("---");
+
+        List<String> words = Arrays.asList("Hello", "World");
+        List<Integer> wordLengths = words.stream()
+                .map(String::length)
+                .collect(Collectors.toList());
+        System.out.println(wordLengths);
+
+        System.out.println("---");
+
+        words.stream()
+                .flatMap(line -> Arrays.stream(line.split("")))
+                .distinct()
+                .forEach(System.out::println);
+
+        System.out.println("---");
+
+        List<Integer> numbers1 = Arrays.asList(1, 2, 3, 4, 5);
+        List<Integer> numbers2 = Arrays.asList(6, 7, 8);
+        List<int[]> pairs = numbers1.stream()
+                .flatMap(i -> numbers2.stream().map(j -> new int[]{i, j}))
+                .filter(pair -> (pair[0] + pair[1]) % 3 == 0)
+                .collect(Collectors.toList());
+        pairs.forEach(pair -> System.out.println("(" + pair[0] + ", " + pair[1] + ")"));
+    }
+}

src/main/java/com/wbs/java8lambda/chapter5/NumericStreams.java

@@ -0,0 +1,49 @@
+package com.wbs.java8lambda.chapter5;
+
+import com.wbs.java8lambda.chapter4.Dish;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+/**
+ * TODO
+ *
+ * @author: wangbingshuai
+ * @create: 2019-11-01 16:07
+ **/
+public class NumericStreams {
+    public static void main(String[] args) {
+        List<Integer> numbers = Arrays.asList(3, 4, 5, 1, 2);
+        Arrays.stream(numbers.toArray()).forEach(System.out::println);
+
+        int calories = Dish.menu.stream()
+                .mapToInt(Dish::getCalories)
+                .sum();
+        System.out.println("Number of calories:" + calories);
+
+        OptionalInt maxCalories = Dish.menu.stream()
+                .mapToInt(Dish::getCalories)
+                .max();
+        int max;
+        if (maxCalories.isPresent()) {
+            max = maxCalories.getAsInt();
+        } else {
+            max = 1;
+        }
+        System.out.println(max);
+
+        IntStream evenNumbers = IntStream.rangeClosed(1, 100)
+                .filter(n -> n % 2 == 0);
+        System.out.println(evenNumbers.count());
+
+        Stream<int[]> pythagoreanTriples = IntStream.rangeClosed(1, 100).boxed()
+                .flatMap(a -> IntStream.rangeClosed(a, 100)
+                        .filter(b -> Math.sqrt(a * a + b * b) % 1 == 0)
+                        .boxed()
+                        .map(b -> new int[]{a, b, (int) Math.sqrt(a * a + b * b)}));
+        pythagoreanTriples.forEach(t -> System.out.println(t[0] + ", " + t[1] + ", " + t[2]));
+    }
+}

src/main/java/com/wbs/java8lambda/chapter5/PuttingIntoPractice.java

@@ -0,0 +1,81 @@
+package com.wbs.java8lambda.chapter5;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.toList;
+
+/**
+ * TODO
+ *
+ * @author: wangbingshuai
+ * @create: 2019-11-01 16:18
+ **/
+public class PuttingIntoPractice {
+    public static void main(String[] args) {
+        Trader raoul = new Trader("Raoul", "Cambridge");
+        Trader mario = new Trader("Mario", "Milan");
+        Trader alan = new Trader("Alan", "Cambridge");
+        Trader brian = new Trader("Brian", "Cambridge");
+
+        List<Transaction> transactions = Arrays.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)
+        );
+
+        // Query 1: Find all transactions from year 2011 and sort them by value (small to high).
+        List<Transaction> tr2011 = transactions.stream()
+                .filter(transaction -> transaction.getYear() == 2011)
+                .sorted(comparing(Transaction::getValue))
+                .collect(toList());
+        System.out.println(tr2011);
+
+        // Query 2: What are all the unique cities where the traders work?
+        List<String> cities = transactions.stream()
+                .map(transaction -> transaction.getTrader().getCity())
+                .distinct()
+                .collect(toList());
+        System.out.println(cities);
+
+        // Query 3: Find all traders from Cambridge and sort them by name.
+        List<Trader> traders = transactions.stream()
+                .map(Transaction::getTrader)
+                .filter(trader -> trader.getCity().equals("Cambridge"))
+                .distinct()
+                .sorted(comparing(Trader::getName))
+                .collect(toList());
+        System.out.println(traders);
+
+        // Query 4: Return a string of all traders’ names sorted alphabetically.
+        String traderStr = transactions.stream()
+                .map(transaction -> transaction.getTrader().getName())
+                .distinct()
+                .sorted()
+                .reduce("", (n1, n2) -> n1 + n2);
+        System.out.println(traderStr);
+
+        // Query 5: Are there any trader based in Milan?
+        boolean milanBased = transactions.stream()
+                .anyMatch(transaction -> transaction.getTrader().getCity().equals("Milan"));
+        System.out.println(milanBased);
+
+        // Query 6: Update all transactions so that the traders from Milan are set to Cambridge.
+        transactions.stream()
+                .map(Transaction::getTrader)
+                .filter(trader -> trader.getCity().equals("Milan"))
+                .forEach(trader -> trader.setCity("Cambridge"));
+        System.out.println(transactions);
+
+        // Query 7: What's the highest value in all the transactions?
+        int highestValue =
+                transactions.stream()
+                        .map(Transaction::getValue)
+                        .reduce(0, Integer::max);
+        System.out.println(highestValue);
+    }
+}