Java8新特性

java8中有两个最为重要的改变。第一个是Lambda表达式，另外一个则是Stream API

Lambda表达式的使用

1.举例：（o1,o2）->Integer.compare(o1,o2)
2.格式:->:lambda操作符或箭头操作符
->左边:lambda形参列表（其实就是接口中的抽象方法的形参列表）,形参列表的参数类型可以省略
如果Lambda形参列表只有一个参数，其一对（）也可以省略
->右边:lambda体（其实就是重写的抽象方法的方法体）Lambda体应该使用一对{}包裹；如果Lambda体只有一条执行语句
（可能是return语句），可以省略这一对{}和return关键字
3.Lambda表达式的使用：（分六种情况介绍）
语法格式一：无参，无返回值
Runnable r1=new Runnable() {
@Override
public void run() {
System.out.println(“我爱北京天安门”);
}
};
Runnable r2=()-> {System.out.println(“我爱北京天安门”);
}
语法格式二：Lambda 需要一个参数，但是没有返回值
Consumer con=new Consumer() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
Consumer con1=(String s)-> {System.out.println(s);
};
语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
Consumer con=new Consumer() {
@Override
public void accept(s) {
System.out.println(s);
}
};
Consumer con1=(String s)-> {System.out.println(s);
};
语法格式四：lambda若只需要一个参数时，参数的小括号可以省略
Consumer con1=(String s)-> {System.out.println(s);
};
Consumer con2=(String s)-> {System.out.println(s);
};
语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
Comparator com=new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
Comparator com1=(o1,o2)->{
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
语法格式六：当Lambda体只有一条语句时，return与大括号若有，都可以省咯
Comparator com1=(o1,o2)->{
return o1.compareTo(o2);
};
Comparator com2=(o1,o2)->o1.compareTo(o2);

4.Lambda表达式的本质：作为函数式接口的实例
5.如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
java内置的4大核心函数式接口
消费型接口Consumer void acceept(T t)
供给型接口Supplier T get()
函数型接口Function<T,R> R apply(T t)
断定型接口Perdicate boolean test(T t)

方法引用

1.使用情景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例
3.使用格式： 类（或对象）：：方法名
4.具体分为如下的三种情况
情况一：对象：：非静态方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
Consumer con1=str-> System.out.println(str);
con1.accept(“北京”);
PrintStream out = System.out;
Consumer con2=out::println;
con2.accept(“beijing”);
情况二：类：：静态方法
Comparator com1=(o1,o2)->Integer.compare(o1,o2);
int compare = com1.compare(12, 23);
System.out.println(compare);
Comparator com2=Integer::compare;
int compare1 = com2.compare(21, 12);
System.out.println(compare1);

---

Function<Double,Long> fun=new Function<Double, Long>() {
@Override
public Long apply(Double d) {
return Math.round(d);
}
};
Function<Double,Long> fun1=d->Math.round(d);
Function<Double,Long> fun2=Math::round;
情况三：类：：实例方法(非静态方法)(有难度)
Comparator com=(o1,o2)->o1.compareTo(o2);
System.out.println(com.compare(“12”, “321”));
Comparator com3=String::compareTo;
System.out.println(com3.compare(“32”, “32”));

5.方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值相同！

构造器引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型
即为构造器所属的类的类型

数组引用

可以把数组看做是一个特殊的类，则写法与构造器引用一致

Stream API

1.测试Stream的实例化

//测试Stream的实例化
public class StreamAPITest {
    @Test
    public void test(){
        //创建Stream方式一：通过集合
        List<String> list=new ArrayList<>();
        //default Stream<E> stream():返回一个顺序流
        Stream<String> stream = list.stream();
        //default Stream<E> parallelStream():返回一个并行流
        Stream<String> stringStream = list.parallelStream();
        //创建Stream方式二：通过数组
        int arr[]=new int[]{1,2,3,4,5,6};
        //调用Arrays类的static<T> Stream<T> stream(T[] array):返回一个流
        IntStream stream1 = Arrays.stream(arr);
        System.out.println(stream1);
        //创建Stream方式三：通过Stream的of（）
        Stream<Integer> integerStream = Stream.of(1, 2, 3);

    }
}

2.测试Stream的中间操作
2.1筛选与切片

 //1.筛选与切片
    @Test
    public void test(){
        List<String> list=new ArrayList();
        list.add("hello");
        list.add("大家好");
        list.add("大家好");
        //filter(Predicate p)-接受Lambda,从流中排除某些元素
        Stream<String> stream = list.stream();
        stream.filter(s->s.length()> 3).forEach(System.out::println);
        //limit(n)-截断流，使其元素不超过给定数量
        list.stream().limit(1).forEach(System.out::println);
        //skip(n)-跳过元素，返回一个扔掉了前n个元素的流，若流中的元素不足n个，则返回一个空流
        list.stream().skip(6).forEach(System.out::println);
        //distinct()-筛选，通过流所生成元素的hascode()和equals()去除重复元素
        list.stream().distinct().forEach(System.out::println);
    }

2.2映射

//2.映射
    @Test
    public void test2(){
       //map(Function f)-接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被
        //应用到每个元素上，并将其映射成一个新的元素
        List<String> list= Arrays.asList("aa","bb","cc","dd");
        list.stream().map(str->str.toUpperCase()).forEach(System.out::println);
        //练习：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        //遍历：类似于for循环的嵌套,因为map方法里返回的还是一个Stream
        streamStream.forEach(s->{
            s.forEach(System.out::println);
        });
        //flatMap(Function f)-接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }
    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list=new ArrayList<>();
        for(Character c:str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

2.3排序

 //排序
    @Test
    public void test3(){
        //sorted()自然排序
        List<Integer> list = Arrays.asList(12,21,23,34,45,56,65,23,43,54,22);
        list.stream().sorted().forEach(System.out::println);
        //sorted(Comparator com)自然排序
    }

3.测试Stream的终止操作
3.1匹配与查找
//allMatch(Predicate p)–检查是否匹配所有元素。
//anyMatch(Predicate p)–检查是否至少匹配一个元素。
//noneMatch(Predicate p)–检查是否没有匹配的元素
//findFirst–返回第一个元素
//count–返回流中元素的总个数
//max(Comparator c)–返回流中最大值
//min(Comparator c)–返回流中最小值
//forEach(Consumer c)–内部迭代
3.2归约

  @Test
    public void test3(){
        //reduce(T identity,BinaryOperator)-可以将流中元素反复结合起来
        //练习1：计算1-10的自然数的和
        List<Integer> list= Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);
        //reduce(BinaryOperator)-可以将流中元素反复结合起来，得到一个值。
    }

3.3收集
//collect(Collector c)-将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法