Java8 函数式编程

1.引言

Java 8的最大变化是引入了Lambda表达式，——一种紧凑的,传递行为的方式。它使开发者在写回调函数和事件处理程序时，不必纠缠于匿名内部类的冗繁和可读性，函数式编程让事件处理系统变得更加简。
Lambda表达式是一个匿名方法，将行为像数据一样传递。
Lambda表达式需要"函数式接口"的支持，
函数式接口：接口中只有一个抽象方法的接口称为函数式接口，可以使用注解@FunctionalInterace修饰。

2.Lambda表达式

2.1 Lambda表达式基本形式

// 1.不包含参数
//使用空括号()表示没有参数，返回类型为void
Runnable thread = () -> System.out.println("hello");

// 2.包含一个参数
// 如下表达式包含且只包含一个参数，可以省略参数的括号
ActionListener one = event -> System.out.println("hello");

// 3.表达式的主体是一段代码块
Runnable thread () -> {
  System.out.println("hello");
  System.out.println("hello1");
}

// 4.表达式包含多个参数
BinaryOperator<long> add = (x,y) -> x+y;

// 5.显示声明参数类型
BinaryOperator<long> add = (long x,long y) -> x+y;

2.2 java 8 内置四大函数式核心接口

Consumer<T> : 消费型接口

void accept(T t);

Supplier<T> : 供给型接口

T get();

Function<T, R> : 函数型接口

R apply(T t);

Predicate<T> : 断言型接口

boolean test(T t);

2.3 举个例子

• 1.消费型接口

// 消费型接口
    @Test
    public void test1(){
        goHappy(1000.2,(m) -> System.out.println(m));
    }
    public void goHappy(Double money , Consumer<Double> consumer){
        consumer.accept(money);
    }

• 2.供给型接口

//供给型接口
    @Test
    public void test2(){
        List<Integer> list = getNumList(10, () -> (int) (Math.random() * 100));
        list.stream().forEach(System.out::println);
    }

    public List<Integer> getNumList(int num , Supplier<Integer> supplier){
        List<Integer> list = new ArrayList<>();
        for(int i = 0;i< num; i++){
            Integer integer = supplier.get();
            list.add(integer);
        }
        return list;
    }

• 3.函数型接口

// 函数型接口
    @Test
    public void test3(){
        String handler = Handler("\t\t 可口可乐 \t\t", str -> str.trim());
        System.out.println(handler);
    }
    public String Handler(String str , Function<String , String> function){
        return function.apply(str);
    }

• 4.断言型接口

// 断言型接口
    @Test
    public void test4(){
        List<String> list = Arrays.asList("Hadoop" , "hive" , "HBase","Zookeeper" , "Spark");
        List<String> filter = filter(list, (str) -> str.length() > 5);
        filter.forEach(System.out::println);
    }

    public List<String> filter(List<String> list , Predicate<String> predicate){
        List<String> tmpList = new ArrayList<>();
        for (String s : list) {
            if(predicate.test(s)){
                tmpList.add(s);
            }
        }
        return tmpList;
    }

3.Stream

Stream是用函数式编程方式在集合类上进行复杂操作的工具。

Java 开发人员在处理集合时，一个通用的做法是在集合上进迭代，然后处理返回的每一个元素。
如，从ArrayList集合中统计字符"a"的出现次数，传统做法：

   Iterator<String> iterator = list.iterator();
        int count = 0;
        while (iterator.hasNext()){
            if(iterator.next().equals("a")){
                count++;
            }
        }

使用Stream:

long count = list.stream().filter(item -> item.equals("a")).count();

是不是很简洁！

3.1 Stream的创建

Stream共有四种创建方式：

 /**
         * 1.可以通过Collection 系列集合提供的stream()或parallelStream()
         */
         ArrayList<String> list = new ArrayList<>();
         Stream<String> stream1 = list.stream();

        /**
         * 2.通过Arrays中的静态方法stream()获取数组流
         */
         Stream<String> stream2 = Arrays.stream(new String[]{"a", "b", "c"});

        /**
         * 3.通过Stream类中的静态方法 of()
         */
         Stream<String> stream3 = Stream.of("a", "b", "c");

        /**
         * 4.创建无限流
         */
         Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);

3.2 Stream的筛选与切片操作

• 1.filter

List<Employee> employees = Arrays.asList(
            new Employee("zhangsan", 19, 1000.0),
            new Employee("lisi", 20, 1002.0),
            new Employee("wangwu", 21, 1003.0),
            new Employee("xiaohong", 22, 1004.0),
            new Employee("xiaoming", 23, 1005.0)
    );

    @Test
    public void test1(){
        employees.stream()
                .filter(e -> e.getAge()>=21)
                .forEach(System.out::println);
    }

• 2.limit

@Test
    public void test2(){
        employees.stream()
                .limit(2)
                .forEach(System.out::println);
    }

• 3.skip

@Test
    public void test3(){
        employees.stream()
                .skip(2)
                .forEach(System.out::println);
    }

3.3 Stream的映射操作

• 1.map

@Test
    public void test5(){
         List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
         list.stream()
                 .map(str -> str.toUpperCase())
                 .forEach(System.out::println);
    }

3.4 Stream的排序操作

• 1.sorted

@Test
    public void test6(){
        List<String> list = Arrays.asList("eee","aaa", "bbb", "ccc", "ddd");
        list.stream()
                .sorted()
                .forEach(System.out::println);
    }

• 2.sorted(Compare comp)

 @Test
    public void test7(){
        employees.stream()
                .sorted((e1,e2) -> {
                    return e1.getName().compareTo(e2.getName());
                })
                .forEach(System.out::println);
    }

3.5 Stream的查找与匹配操作

• 1.allMatch

@Test
    public void test8(){
         boolean b = employees.stream()
                .allMatch(e -> e.getName().equals("lisi"));
        System.out.println(b);
    }

• 2.anyMatch

@Test
    public void test9(){
        boolean b = employees.stream()
                .anyMatch(e -> e.getName().equals("lisi"));
        System.out.println(b);
    }

• 3.noneMatch

@Test
    public void test10(){
        boolean b = employees.stream()
                .noneMatch(e -> e.getName().equals("lisi"));
        System.out.println(b);
    }

• 4.findFirst

@Test
    public void test11(){
         Employee employee = employees.stream()
                .findFirst()
                .get();
        System.out.println(employee.toString());
    }

3.6 Stream的规约与收集操作

• T reduce(T identity, BinaryOperator<T> accumulator);
  将流中的元素反复结合起来，得到一个值。

 @Test
    public void test12(){
         List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
         Integer num = integers.stream()
                .reduce(0, (x, y) -> x + y);
        System.out.println(num);
    }

• collect
  将流转换为其他式，接收一个Collector接口的实现。

@Test
    public void test13(){
         List<String> list = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());
         list.forEach(System.out::println);
    }