Java8新特性 - lambda、stream、optional

一、lambda表達式：   至關於一個匿名內部類，匿名內部類使用外部的變量，外部變量必須是 final 類型。

    

    幾種 lambda 語法構成：（參數1, 參數2 ... ) -> { 邏輯代碼語句 }；  （參數1, 參數2 ...）-> expression ;

    在 jdk 內置的接口都加上了 @FunctionInterface 註解，代表該接口是一個函數式接口，同時支持 lambda 表達式。

        

    下面是 java8中 java.util.Function 包下的 經常使用類的 lambda 表達式的練習。

    方法推導 Method Reference      語法格式：類 : : 方法名

由於在自定義的Consumer中，是接受一個字符串，而後經過輸出打印，不須要返回值。

而 System.out.println() 方法也是接受一個object對象，作打印輸出，不須要返回值，所以能夠進行方法推導。

    

 

 

二、stream 流

注意：stream流只能使用一次。不能重複使用

 

建立Stream的幾種方式：

package createStream;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class CreateStream {

    public static void main(String[] args) {
        createStreamFormList().forEach(System.out::println);
        System.out.println("========");
        createStreamFormStreamOfMethod().forEach(System.out::println);
        System.out.println("========");
        createStreamFromArrays().forEach(System.out::println);
        System.out.println("========");
        createStreamFromFile();
        System.out.println("========");
        createStreamFromIterator().forEach(System.out::println);
        System.out.println("========");
        createStreamFromGenerator().forEach(System.out::println);
        System.out.println("========");
        createStreamFromMyObj();

    }

    public static Stream<String> createStreamFormList() {
        List<String> nameList = Arrays.asList("Alex", "John", "Mike", "David");
        return nameList.stream();
    }

    public static Stream<String> createStreamFormStreamOfMethod() {
        return Stream.of("Alex", "John", "Mike", "David");
    }

    public static Stream<String> createStreamFromArrays() {
        return Arrays.stream(new String[]{"Alex", "John", "Mike", "David"});
    }

    public static void createStreamFromFile() {
        Path path = Paths.get("G:\\my_project\\java8\\java8-sharing\\src\\main\\java\\createStream\\CreateStream.java");
        try {
            Files.lines(path, StandardCharsets.UTF_8).forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Stream<Integer> createStreamFromIterator() {
        return Stream.iterate(0, (n) -> {return n + 2;}).limit(10);
    }

    public static Stream<Double> createStreamFromGenerator() {
        return Stream.generate(Math::random).limit(10);
    }

    public static Stream<MyObj> createStreamFromMyObj() {
        return Stream.generate(new MyObj(100, "name")).limit(10);
    }

    /**
     * 自定義的對象 MyObj，做爲生成的 Stream 的 generate方法的參數
     */
    public static class MyObj implements Supplier<MyObj> {
        private int id;
        private String name;

        public MyObj() {
        }

        public MyObj(int id, String name) {
            int index = new Random().nextInt(id);
            this.id = index;
            this.name = name + "->" + index;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "MyObj{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }

        @Override
        public MyObj get() {
            return this;
        }
    }
}

 

Stream流的經常使用 API 練習：

filter方法使用：

、

 

map方法使用：

 

match方法：

 

reduce方法：

 

find方法：    find方法主要是講返回值 Optional<T>。 該類賊強大

 

NumericStream 和 Stream 之間的轉換： 下面的案例是 Integer 拆箱轉 Int，減小空間

 

Java8 in Action -- Stream綜合練習

package stream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

import static java.util.stream.Collectors.toList;

/**
 * 來自 Java8 in Action 書籍第5章 5.5的練習題
 */
public class StreamPractice {

    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)
        );

        /*List<Boolean> collect = transactions.stream().map((transaction -> transaction.getYear() == 2011))
                .collect(toList());
        System.out.println(collect);*/

        // question one -- Find all transactions in the year 2011 and sort them by value (small to high).
        List<Transaction> transactionList = transactions.stream().
                // 篩選出年份是 2011 的
                filter(transaction -> transaction.getYear() == 2011)
                // 提取value
                .sorted(Comparator.comparingInt(Transaction::getValue))
                // stream轉成新的集合
                .collect(toList());
        System.out.println(transactionList);

        // question two -- What are all the unique cities where the traders work?
        List<String> collect = transactions.stream()
                .map(transaction -> transaction.getTrader().getCity())
                .distinct()
                .collect(toList());
        System.out.println(collect);


        // question three -- Find all traders from Cambridge and sort them by name.
        List<String> stringList = transactions.stream()
                // 篩選出城市是 Cambridge 的
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                // 排序
                .sorted(Comparator.comparing(transaction -> transaction.getTrader().getName()))
                // 提取名字
                .map(transaction -> transaction.getTrader().getName())
                // 去重
                .distinct()
                // stream轉成新的集合
                .collect(toList());
        System.out.println(stringList);

        // question four -- Return a string of all traders’ names sorted alphabetically.
        List<String> stringList1 = transactions.stream()
                // 獲取名字集合
                .map(transaction -> transaction.getTrader().getName())
                // name 去重
                .distinct()
                // 轉爲字符數組
                // .map(name -> name.split(""))
                // 數組再轉成流
                // .flatMap(Arrays::stream)
                // 排序
                .sorted(String::compareTo)
                // stream轉成新的集合
                .collect(toList());
        System.out.println(stringList1);

        // question five -- Are any traders based in Milan?
        long count = transactions.stream()
                // 篩選出城市是 Milan 的
                .filter(transaction -> transaction.getTrader().getCity().equals("Milan"))
                // 提取名字
                .map(transaction -> transaction.getTrader().getName())
                // 去重
                .distinct()
                // 統計
                .count();
        List<String> milan = transactions.stream()
                // 篩選出城市是 Milan 的
                .filter(transaction -> transaction.getTrader().getCity().equals("Milan"))
                // 提取名字
                .map(transaction -> transaction.getTrader().getName())
                // 去重
                .distinct()
                // stream轉成新的集合
                .collect(toList());
        System.out.println(count);
        System.out.println(milan);

        // question six -- Print all transactions’ values from the traders living in Cambridge.
        List<Integer> cambridge = transactions.stream()
                //  篩選出城市是 Cambridge 的
                .filter(transaction -> transaction.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                // stream轉成新的集合
                .collect(toList());
        System.out.println(cambridge);

        // question seven -- What’s the highest value of all the transactions?
        Optional<Integer> max = transactions.stream()
                //  篩選出城市是 Cambridge 的
                .map(Transaction::getValue)
                // 比較出最大值
                .max(Integer::compareTo);
        System.out.println(max.get());

        // question eight -- Find the transaction with the smallest value.
        Optional<Transaction> max1 = transactions.stream()
                // 比較出最大值
                .min(Comparator.comparingInt(Transaction::getValue));
        System.out.println(max1.get());
    }
}

 

三、Optional類：源碼Source Code不算多，推薦先看一遍Optional類的全部方法