JAVA8 Lambda表达式(下)

体会到Lambda表达式的优雅与简洁，进一步记录下一步操作，

四大内置核心函数式接口，StramAPI等操作。

Java 内置四大核心函数式接口

1、消费型接口

* 抽象方法有参数无返回值

* Interface Consumer<T>：

* void accept(T t)

@Test
    public void test(){
        Consumer<String> con=(x) -> System.out.println(x);
        con.accept("KK.get()");
    }

2、供给型

* 抽象方法：有返回值无参

* Interface Supplier<T>：

* T get()

@Test
    public void test(){
        Supplier<Employee> sup=()->new Employee();
    }

3、函数型

* 抽象方法：有参有返回值

* Interface Function<T,R>：

* R apply(T t)

4、断言型

* 抽象方法：返回值是boolean

* Interface Predicate<T>：

* boolean test(T t)

这四种是内置的函数型接口，接口的子接口一样通用，但是这样的方法我们发现一个问题，就是每次调用的时候都需要创建一个方法的实现。

方法引用与构造器引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

格式：

方法引用：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。

如下三种主要使用情况：

l 对象::实例方法名

l 类::静态方法名

l 类::实例方法名

@Test
  public void test(){
//    Comparator<String> c = (t1,t2) -> t1.compareTo(t2);
    Comparator<String> c = String::compareTo;
  }

@Test
  public void test(){
    Runnable run = () -> System.out.println("hello");//不能使用方法引用，因为没有参数
    
//消费型：void accept(T t)
//    Consumer<String> c = t -> System.out.println(t);
    Consumer<String> c = System.out::println;
  }

一句话就是：实现抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

例如：

@FunctionalInterface
public interface Consumer<T> {

/**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
void accept(T t);
 }

Consumer的参数列表是一个，返回值是void，实现方法println

public void println(String x) {
synchronized (this) {
            print(x);
            newLine();
        }
    }

也是一个参数，返回值是void

构造器引用

Lambda体是通过构造一个对象完成的，而且Lambda表达式的形参，正好是传给构造器的实参

构造器一般用于实例化对象，用于new方法；

例如：

@Test
public void test4(){
        Supplier<Employee> sup=()->new Employee();
        Supplier<Employee> sups=Employee::new;
        System.out.println(sups.get());
//构造器取决于调用方法的构造器
    }

调用方法的supplier是无参构造器，那么调用的Employee的构造器也是无参的。如果换做其他参数列表的方法，那么对应的Employee也要有对用的参数构造器。

Stream API

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式；

流式调用一般用于处理数据，比如io流，多媒体流等，在Stream中关键词是计算；

Stream 的操作三个步骤：

1- 创建 Stream

一个数据源（如：集合、数组），获取一个流

2- 中间操作

一个中间操作链，对数据源的数据进行处理

3- 终止操作(终端操作)

一旦执行终止操作，就执行中间操作链，并产生结果

创建 Stream方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

l default Stream<E> stream() : 返回一个顺序流

l default Stream<E> parallelStream() : 返回一个并行流

创建 Stream方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

l static <T> Stream<T> stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

l public static IntStream stream(int[] array)

l public static LongStream stream(long[] array)

l public static DoubleStream stream(double[] array)

创建 Stream方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

l public static<T> Stream<T> of(T... values) : 返回一个流

创建 Stream方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

迭代：public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

生成：public static<T> Stream<T> generate(Supplier<T> s) :

@Test
    public void test3(){
        //创建流
employees.stream()
          .filter((e)->e.getSalary()>5000)//中间操作
          .limit(2)
          .forEach(System.out::println);//终止操作
employees.stream()
         .map(Employee::getName)//映射  应用函数作为参数
         .forEach(System.out::println);
        }

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值/延迟加载”。

1-筛选与切片

终止操作时才进行一次性的操作，其中的foreach有内部操作，叫内部迭代

 employees.stream()
                 .filter((e)->e.getAge()>35)
                 .distinct()//需要重写hashcode与equals方法
                 .forEach(System.out::println);//内部迭代
        Iterator<Employee> it = employees.iterator();//外部迭代
        while (it.hasNext()){
            System.out.println(it.next());
        }
        }

到此大多数方法测试完成，顺便记录下欠的工作：

1.重装Vmware客户端

2.配合安装ActiveMQ完成MQ的结尾文章

3.测试webpack打包

希望尽快抽时间完成吧

本公众号意在记录学习过程，日常开发遇到的问题及解决方案，欢迎投稿，指正