Java8簡明學習之Lambda表達式

時間 2019-11-08

標籤 java8 java 簡明學習 lambda 表達式欄目 Java 简体版

原文原文鏈接

函數式接口java

　　就是一個有且僅有一個抽象方法，可是能夠有多個非抽象方法的接口，函數式接口能夠被隱式轉換爲lambda表達式。es6

　　以前已有的函數式接口:
　　java.lang.Runnable
　　java.util.concurrent.Callable
　　java.util.Comparator
　　java.io.FileFilter編程

　　1.8新增的函數式接口：
　　java.util.function包下segmentfault

　　Predicate<T>——接收 T 並返回 boolean （經常使用）
　　Consumer<T>——接收 T，不返回值（經常使用）
　　Function<T, R>——接收 T，返回 R （經常使用）
　　Supplier<T>——提供 T 對象（例如工廠），不接收值
　　UnaryOperator<T>——接收 T 對象，返回 T
　　BinaryOperator<T>——接收兩個 T，返回 T數組

lambda表達式ide

　　lambda表達式的語法由參數列表、箭頭符號 -> 和函數體組成。函數體既能夠是一個表達式，也能夠是一個語句塊。
　　eg: (int x, int y) -> x + y （表達式）
　　eg：(Integer e) -> {
　　　　double sqrt = Math.sqrt(e);
　　　　double log = Math.log(e);

　　　　return sqrt + log;
　　} （語句塊）
　　意義：傳入參數x和y，返回x和y的和
　　表達式：表達式會被執行而後返回執行結果。
　　語句塊：語句塊中的語句會被依次執行，就像方法中的語句同樣。函數式編程

方法引用:函數

　　方法引用提供了很是有用的語法，能夠直接引用已有Java類或對象（實例）的方法或構造器。
　　方法引用有不少種，它們的語法以下：
　　靜態方法引用：ClassName::methodName
　　實例上的實例方法引用：instanceReference::methodName
　　超類上的實例方法引用：super::methodName
　　類型上的實例方法引用：ClassName::methodName
　　構造方法引用：Class::new
　　數組構造方法引用：TypeName[]::new學習

　　eg:ui

List<String> names5 = Arrays.asList("peter", "anna", "mike", "xenia");
        names5.sort(String::compareTo);
        System.out.println(names5);

public void testFun1() {
// comparing 是 Function<? super T, ? extends U> Function<T, R>——接收 T，返回 R
Person p1 = new Person();
p1.setName("hy");
p1.setAge(18);

Person p2 = new Person();
p2.setName("dax");
p2.setAge(19);

Person[] people = {p1, p2};
Comparator<Person> byName = Comparator.comparing(Person::getName);
Arrays.sort(people, byName);
for (Person person : people) {
System.out.println(person);
}
}

Stream

Stream與 java.io 包裏的 InputStream 和 OutputStream 是徹底不一樣的概念，Stream 是對集合（Collection）對象功能的加強。

eg：內部迭代和外部迭代

 void innerOrOuter() {
        List<Person> list = new ArrayList<>();
        Person p1 = new Person();
        p1.setName("hy");
        p1.setAge(18);

        Person p2 = new Person();
        p2.setName("dax");
        p2.setAge(19);

        list.add(p1);
        list.add(p2);

        for (Person p: list) {
            p.setAge(20);
        }
        System.out.println(list);

        List<Person> list2 = new ArrayList<>();
        Person p21 = new Person();
        p21.setName("hy");
        p21.setAge(18);

        Person p22 = new Person();
        p22.setName("dax");
        p22.setAge(19);

        list2.add(p21);
        list2.add(p22);

        list2.stream().forEach(p->p.setAge(20));
        System.out.println(list2);
    }

　　Stream通用語法：

　　Stream的操做：
　　Intermediate（中間操做）：
　　　　map (mapToInt, flatMap 等)、 filter、 distinct（去重）、 sorted（排序）、 peek（對某個元素作單獨處理生成新的Stream）、
　　　　limit（取前N個元素）、 skip（丟棄前N個元素）、 parallel、 sequential、 unordered

　　Terminal（結束操做，非短路操做）：
　　　　forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

　　Short-circuiting（結束操做，短路操做）：
　　　　anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

　　表明例子：

@Test
public void testNormal() {
    // 1 線程
    new Thread(()-> testThread()).start();

    // 2 遍歷集合
    List<String> list = Arrays.asList("abd", "nba", "cba", "mctrady");
    list.stream().forEach(n-> System.out.println(n));
    list.forEach(n-> System.out.println(n));

    // 3 map運用
    List<Integer> listInt = Arrays.asList(123, 456, 789, 101);
    listInt.stream().map(n->n*10).forEach(n-> System.out.println(n));
    System.out.println(listInt.stream().mapToInt(n->n).sum());
    System.out.println(listInt.stream().mapToInt(n->n).average().getAsDouble());

    // 4 filter
    List<Integer> listInt2 = Arrays.asList(123, 456, 789, 101);
    listInt2.stream().filter(n->n>200).forEach(n-> System.out.println(n));


    // 5 對每一個元素應用函數
    List<Integer> listInt3 = Arrays.asList(123, 456, 789, 101);
    String str = listInt3.stream().map(n->n.toString()).collect(Collectors.joining(","));
    System.out.println(str);
}

private void testThread() {
    System.out.println("線程操做");
}

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });
        System.out.println(names);

        List<String> names1 = Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names1, (String a, String b) -> {
            return b.compareTo(a);
        });
        System.out.println(names1);

        List<String> names2 = Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names2, (String a, String b) -> b.compareTo(a));
        System.out.println(names2);

        List<String> names3 = Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names3, (a, b) -> b.compareTo(a));
        System.out.println(names3);

        List<String> names4 = Arrays.asList("peter", "anna", "mike", "xenia");
        Collections.sort(names4, String::compareTo);
        System.out.println(names4);

        List<String> names5 = Arrays.asList("peter", "anna", "mike", "xenia");
        names5.sort(String::compareTo);
        System.out.println(names5);

        List<String> names6 = Arrays.asList("peter", "anna", "mike", "xenia");
        // 反轉
        names6.sort(Comparator.comparing(String::toString).reversed());
        System.out.println(names6);

public void testStream() throws ClassNotFoundException {
        List<Person> list = new ArrayList<>();
        Person p1 = new Person();
        p1.setName("hy");
        p1.setAge(18);

        Person p2 = new Person();
        p2.setName("dax");
        p2.setAge(19);

        list.add(p1);
        list.add(p2);

        System.out.println(list);

        list.stream().forEach(p -> p.setAge(20));

        System.out.println(list);

        list.stream().filter(s->s.getName().equals("hy")).forEach(p->p.setAge(21));
        System.out.println(list);

        List<Person> listHy = list.stream().filter(s->s.getName().equals("hy") && s.getAge() == 21).collect(Collectors.toList());
        System.out.println(listHy);

        int age = list.stream().mapToInt(s->s.getAge()).sum();
        System.out.println("年齡總和：" + age);

        Optional<Person> firstHy = list.stream()
                .filter(s -> s.getName().equals("hy"))
                .findFirst();
        Person person = firstHy.get();
        System.out.println(person);
    }