Java8新特性

环境：JDK1.8以上

Lambada表达式

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

语法：(parameters) -> expression或(parameters) ->{statements; }
1.可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

2.可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

3.可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

4.可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在lambda 内部修改定义在域外的局部变量，否则会编译错误。

        String var = "var";
        //stream流式对象
        List<String> list = Arrays.asList("1","2","3");
        list.stream().filter(s->s!="2").forEach(o->System.out.println(o));

        Optional.ofNullable(list).get().forEach(o->{
            System.out.println(o+var);
        });

方法引用

方法引用通过方法的名字来指向一个方法。
方法引用使用一对冒号 ::

实例循环打印：
 Optional.ofNullable(list).get().forEach(System.out::println);

流Stream 仅进行逻辑处理

Stream（流）是一个来自数据源的元素队列并支持聚合操作

元素：是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。

数据源 ：流的来源。可以是集合，数组，I/O channel，产生器generator等。

聚合操作： 类似SQL语句一样的操作，比如filter, map, reduce, find,match, sorted等。

• 生成流

stream() −为集合创建串行流。
parallelStream() − 为集合创建并行流。多线程异步任务的一种实现，不会按原有的集合顺序进行，有线程不安全问题。
示例：
    List<String> list=Arrays.asList("1","2","3","11","22","33","12","22","32");
    list.stream().filter(s->s!="2").forEach(o->System.out.println(o));
    System.out.println("--------");
    list.parallelStream().forEach(o->System.out.println(o));

• 逻辑处理用到的方法

1.foreach():遍历循环每一个元素，返回void。
2.map(): 遍历循环操作每一个元素，返回流对象；且map方法内需要有返回值，即操作每个元素的返回值。
    示例：
        List<Integer> listNumber = Arrays.asList(1,2,3,4,4,5,5);
        List<Integer> temp = new ArrayList<>();
        temp=listNumber.stream().map(i->i++).distinct().collect(Collectors.toList());
3.filter()：设置过滤条件，返回 满足过滤条件或返回值为true的 元素。
  anyMatch()：根据方法匹配任意一个，匹配到元素则返回true否则false。
  allMatch()：全匹配。
  示例：
        List<Integer> listNumber = Arrays.asList(1,2,3,4,4,5,5);
        temp2=listNumber.stream().filter(i->i==1).collect(Collectors.toList()); //返回的temp2集合中只有 数字1 一个元素
4.limit(n):取流中前n个元素
5.sorted():给流中的元素排序
6.收集流：
    collect()：将流中的数据进行逻辑操作后，将操作结果保存到集合或数组或Map中。
    reduce()：将流中的各元素按一定规则产生一个结果值。reduce(起始值，累加器)
    示例：
         Integer total = listNumber.stream().reduce(200,(x,y)->x+y);//在初始值基础上累加元素，返回累加结果
         Integer total2 = listNumber.stream().reduce((x,y)->x+y).get();//直接累加，使用get()方法获取累加结果
7.Collectors提供规约操作，将流转换成集合和聚合元素。Collectors可用于返回集合或map或字符串。
    示例：
        listNumber.stream().distinct().collect(Collectors.toList()); //list集合
        Map<String,String> map = list.stream().collect(Collectors.toMap(k->k, v->v)); //map
        map.entrySet().forEach(i->{
            System.out.println(i.getKey()+" : "+i.getValue());
        });
        String joinStr=list.stream().collect(Collectors.joining(",")); //字符串
        System.out.println(joinStr);
8.统计
    mapToInt()获取一个IntStream流，用于统计计算。
    类似地有mapToDouble,mapToLong等。通过相应的SummaryStatistics对象可以获取统计的个数、最大值、总和、最小值和平均数等
    示例：
        List<String> list = Arrays.asList("1","2","3","11","212","33","12","22","32");
        IntSummaryStatistics intSummaryStatistics = list.stream().mapToInt(i->Integer.valueOf(i)).summaryStatistics();
        System.out.println(intSummaryStatistics.toString());

Optional对象

• Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
• Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。

注意：与流对象的不同是，流对象是对其中每一个元素进行逻辑操作，而Optional是存储整个对象的容器，操作时是对整个对象进行操作。

ofNullable():判空，若为空则返回一个保存null的Optional对象。
isPresent(function):判断值是否存在，存在则进入方法。
orElse(other):如果存在该值，返回值，否则返回 other。
get():如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException。
还有更多方法。
    示例：
        List<Integer> tmp=Arrays.asList(1,2,3,4);
        List<Integer> tempArray=Arrays.asList(1,2,3,4);
        Optional.ofNullable(tempArray).filter(i->!i.get(0).equals(2)).ifPresent(f->{
            System.out.println(f);
        });
        List<Integer> integerList = Optional.ofNullable(tmp).filter(i->i.size()<0).orElse(Arrays.asList(9,3));
        integerList.forEach(System.out::println);
        integerList = Optional.ofNullable(tempArray).filter(i->!i.get(0).equals(2)).get();
        integerList.forEach(System.out::println);