17、lambda表达式

一、简介

　　lambda表达式允许你通过表达式来代替功能接口，lambda表达式就和方法一样，它提供了一个正常的参数列表和一个使用这些参数的主体（body，可以是一个表达式或一个代码块），它还增强了集合库，java.util.function包java.util.stream包

　　流就如同迭代器，但附加了许多额外的功能。

二、基本语法

　　(parameters)->expression

　　或

　　(parameters)->{statements;}

例子：输出的->代表一个Consumer接口用来接收一个输入对象并处理，如果需要访问类型T的对象，并对其执行某些操作，就可以使用这个接口。

public class A {
    public static void main(String[] args) {
        IA i=(int c,int d)-> System.out.println(c);
        i.run(100,200);
    }
}
interface IA{
    public void run(int a,int b);
}

三、例子

　　遍历数组（数组变成列表，使用列表的forEach方法遍历，其中System.out::println用来输出当前调用它的对象内容）

public class B {
    public static void main(String[] args) {
        String names[]={"JAKE","MIKE","ROSE"};
        List<String> list= Arrays.asList(names);//数组变成list
        list.forEach(n-> System.out.println(n));
        list.forEach(System.out::println);
    }
}

　　字符数组排序，—>代表Comparator接口用来比较字符串

public class C {
    public static void main(String[] args) {
        String names[]={"MIKE","JAKE","ROSE"};
        Arrays.sort(names,(String s1,String s2)->s1.compareTo(s2));
        List<String> list=Arrays.asList(names);
        list.forEach(System.out::println);
    }
}

四、Lambda内置函数接口和Stream和parallelStream操作（并行流）

　　Stream(这个Stream不是之前那个流，而是lambda下的流）是对集合的包装，通常和lamabda一起使用，是java8的新特性，它不是集合元素，不是数据结构，并不保存数据，它是有关算法和计算的，它更像一个高级版本的Iterator。原始版本的Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的Stream，用户只要给出需要对其包含的元素执行什么操作，比如“过滤掉长度大于10的字符串”、“获取每个字符串的首字母”等，Stream会隐式的在内部进行遍历，做出相应的数据转换。Stream就如同一个迭代器：单向，不可重复，数据只能遍历一次，遍历过一次后即用尽了。

　　Stream和迭代器不同点：Stream可以支持并行化操作，迭代器只能命令式、串行化操作（在迭代器中，每个item读完之后，再读下一个,而Stream则将数据分段，每个段都在不同的线程中处理）

　　Stream的另一个特点是：数据源本身可以是无限的（元素个数不限）。

　　使用lambdas可以支持许多操作，如 map（汇总mapreduce）、filter(过滤）、limit（限制）、sorted、count、min、max、sum、collect等等。

　　使用Stream使用懒运算，他们并不会真正的读取所有数据，遇到像getFirst()这样的方法就会结束 链式语法。

接口一：consumer：

　consumer接口使用：consumer接口下自带一个方法accept(),用来接收对象传给consumer变量p，然后在后面对其操作。foreach方法需要consumer形参，对consumer中元素遍历

package com.zxc.P;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

/**
 * Created by Administrator on 2018/2/9 0009.
 */
public class D {
   private List<Person> list=new ArrayList<Person>(){
        {
            add(new Person(100,"JACK"));
            add(new Person(200,"MIKE"));
            add(new Person(300,"ROSE"));
        }
    };
    @Test
    public void test(){
        Consumer<Person> consumer=(p)->{System.out.println(p.getName());};
        consumer.accept(new Person(200,"MIKE"));
    }
    @Test
    public void test1(){
        Consumer<Person> consumer=(p)->{
            p.setAge(p.getAge()+10);
            System.out.println(p.getAge());
        };
        list.forEach(consumer);
    }
}

class Person{
    private int age;
    private String name;

    public Person() {
    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

接口二、Streams-Predicate接口（断言、断定、判断）

　　java.util.fuction.Predicate<T>接口定义了一个名叫test的抽象方法，它接收泛型T对象，并返回一个boolean。在需要表示一个涉及类型T的布尔表达式时，就可以使用这个借口。比如：可以定义一个接收String对象的Lambda表达式。

　　1、过滤器：filter

　　　　可以接受一个predicate接口类型的变量，并将所有流对象中的元组进行过滤。该操作是一个中间操作，因此它允许我们在返回结果的基础上再进行其他的流操作（forEach）

　　 以下是一个过滤器filter，用来过滤100到200之间的

package com.zxc.P;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
/**
 * Created by Administrator on 2018/2/9 0009.
 */
public class E {
    private List<Person> list=new ArrayList<Person>(){
        {
            add(new Person(100,"JACK"));
            add(new Person(200,"MIKE"));
            add(new Person(300,"ROSE"));
        }
    };
    @Test
    public void test(){
        //Predicate<Person> predicate=(p)->(p.getAge()>100);
        //Predicate<Person> predicate1=(p)->(p.getAge()<300);
        list.stream()
                .filter((p)->(p.getAge()>100))
                .filter((p)->(p.getAge()<300))
                .forEach((p)-> System.out.println(p.getAge()));
    }
}

　　2、test()方法用来测试数据，negate()方法去数据反向

 public void test2(){
        Predicate<String> predicate=(p)->(p.length()>3);
        System.out.println(predicate.test("哈尔滨"));//true
        System.out.println(predicate.negate().test("哈尔滨"));//false

        Predicate<String> predicate1= Objects::nonNull;//静态方法，判断是否为空无堆
        System.out.println("--"+predicate1.test("123"));

        Predicate<String> predicate2=Objects::isNull;//静态方法，判断是否为空有堆
        System.out.println("--"+predicate2.test("456"));

        Predicate<String> predicate3=String::isEmpty;//静态方法，判断是否为空有堆
        System.out.println("--"+predicate3.test("456"));
    }

　　3、limit()方法取出限制数量的数据，限制的顺序对过滤出来的信息有影响

 public void test4(){
        Predicate<String> predicate=(p)->(p.length()>3);
        list.stream()
                .limit(2)
                .forEach((p)-> System.out.println(p.getName()));
        list.stream()
                .limit(1)
                .filter((p)->p.getName().equals("ROSE"))
                .forEach((p)-> System.out.println(p.getName()));
    }

　　4、match方法用来匹配

 public void test7(){
        System.out.println(StringCollection.stream().anyMatch((p)->p.startsWith("J")));
        System.out.println(StringCollection.stream().allMatch((p)->p.startsWith("J")));
        System.out.println(StringCollection.stream().noneMatch((p)->p.startsWith("J")));
    }

接口三、comparator(比较）

　　comparator是老java中的经典接口，新的java在此之上添加了多种默认方法。

　　compare方法用来比较字符串，返回前一个参数首字符减去后一个参数首字符的数字

　　sorted()方法可以比较两个参数，让其进行比较。

　　collect()方法可以将结果集收集成一个数组列表。

　　max() min()方法取最大最小值

   public void test(){
        Comparator<Person> comparator=(p1,p2)->p1.getName().compareTo(p2.getName());
        System.out.println(comparator.compare(new Person(100,"MIKE"),new Person(200,"Rose")));
        List<Person> nlist=list.stream()
                .sorted((p1,p2)->p1.getAge()-p2.getAge()>0?p1.getName().compareTo(p2.getName()):p1.getAge()-p2.getAge())
                .limit(3)
                //.max((p1,p2)->p1.getAge()-p2.getAge()).get.getName();
                .collect(Collectors.toList());
                //.forEach((p)-> System.out.println(p.getName()));
        System.out.println(nlist.size());
    }

接口四、function流水线接口（Suppliers接口同function一样，但是没有输入参数）

利用Suppliers接口来实例化一个对象

//初始化默认构造器，不可以初始化非默认的  
public void test5(){
        Supplier<Person> supplier=Person::new;
        Person p=supplier.get();
        p.setName("MIke");
    }

　　apply()方法：应用：类似于Predicate接口下的test()方法，用于放入数据到流水线中　　　　

　　andThen(）流水线下一步操作

 public void test(){
        Function<String,Integer> function=Integer::valueOf;
        Function<String,String> function1=function.andThen(String::valueOf);
        System.out.println(function.apply("123")) ;
    }

　　map()方法：分类。是一个对于流对象的中间操作，通过给定的方法，它能够把流对象中的每一个元素对应到另外一个对象上。

  public void test1(){
        List<String> list1=list.stream()
                .map(Person::getName)//定义就是在聚集的时候执行该对象的定义
                .collect(Collectors.toList());
        list1.forEach((s)-> System.out.println(s));

        System.out.println(list.stream()
                .map(Person::getName)//定义就是在聚集的时候执行该对象的定义
                .collect(Collectors.joining("*")));
    }

　　reduce():汇总、折叠操作。（map将集合类（例如列表）元素进行转换，reduce函数可以将所有值合并成一个，类似于SQL中的sum() count()  avg()等聚集函数，接收多个值，返回一个值）

    @Test
    public void test3(){
        List<Integer> costBeforeTax = Arrays.asList(100,200,300,400,500);
        System.out.println(costBeforeTax.stream()
                .map((a)->a*0.5+a)
                .reduce((sum,a)->sum+=a)
                .get());
    }

接口五：Optional接口

    public void test6(){
        Optional empty=Optional.ofNullable(null);
        System.out.println(empty);

        Optional<String> s=Optional.ofNullable(null);
        System.out.println(s.isPresent());
        //System.out.println(s.get());
        System.out.println(s.orElse("fallback"));
    }

接口六：ToIntFunction：

　　方法：summaryStatistic用来计算统计

    public void test(){
        List<Integer> numbers= Arrays.asList(1,2,3,4,5,6,7,8,9);
        IntSummaryStatistics is=numbers.stream().mapToInt((x)->x+1).summaryStatistics();
        System.out.println(is.getCount());
        System.out.println(is.getAverage());
        System.out.println(is.getMax());
        System.out.println(is.getMin());
        System.out.println(is.getSum());
    }

五、lambda的环绕式

package com.zxc.P;
import org.junit.Test;
/**
 * Created by Administrator on 2018/2/9 0009.
 */
public class I {
    @Test
     public void test(){
        System.out.println("start");
        System.out.println(ok((p)->p+p+p+p+p+p));
        System.out.println("end");
     }
     @FunctionalInterface
    public interface Iok{
         String process(String s);
     }
     public String ok(Iok iok){
         return iok.process("ok");
     }
}