Java8简明学习之Lambda表达式

函数式接口

　　就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，函数式接口可以被隐式转换为lambda表达式。

　　之前已有的函数式接口:
　　java.lang.Runnable
　　java.util.concurrent.Callable
　　java.util.Comparator
　　java.io.FileFilter

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

　　Predicate<T>——接收 T 并返回 boolean （常用）
　　Consumer<T>——接收 T，不返回值 （常用）
　　Function<T, R>——接收 T，返回 R （常用）
　　Supplier<T>——提供 T 对象（例如工厂），不接收值
　　UnaryOperator<T>——接收 T 对象，返回 T
　　BinaryOperator<T>——接收两个 T，返回 T

lambda表达式

　　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:

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

　　总结：

　　关于lambda和Stream的学习暂时先到这，如果日常用的就是1.8版本，这些就慢慢熟悉了，习惯了1.7以前面向对象编程的思维需要一些时间转换。而1.8里面lambda和Stream无疑是让Java更加的拥抱变化，在函数式编程里面也有了一些说话的位置。

　　参考：

　　http://zh.lucida.me/blog/java-8-lambdas-insideout-language-features/

　　https://blog.csdn.net/hanyingzhong/article/details/60965197

　　https://segmentfault.com/a/1190000008876546