jdk8 lambda表达式

lambda表达式旨在简化语法。

1 简单应用

1.1 应用举例

传统写法:

 Integer[] array = new Integer[]{1,2,3,4};
 //匿名内部类方式
 Arrays.sort(array, new Comparator<Integer>()
 {
     @Override
     public int compare(Integer o1, Integer o2)
     {
         return o1.compareTo(o2);
     }
 });

lambda表达式写法：

//lambda方式
        Arrays.sort(array, (o1,o2) -> {
            return o1.compareTo(o2);
        });

lambda表达式的意义：
1.简化语法，不必声明匿名内部类
2.类型自动推断：Comparator接口，传入Integer，Integer，返回int

1.2 函数式接口

只有一个抽象方法的接口，接口类用FunctionalInterface注解注释。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

1.3 方法引用

1.3.1 静态方法引用

Arrays.sort(array, SortBy::sort);

static class SortBy{
        static int sort(Integer o1,Integer o2){
             return o1.compareTo(o2);
        }
    }

SortBy::sort此方法签名（签名只看参数类型和返回值）和Comparator接口恰好一致

1.3.2 实例方法引用

Arrays.sort(array,Integer::compareTo);

Integer::compareTo条用compare(this.value, anotherInteger.value)【默认第一个参数是this】与Comparator接口的方法public int compare(Integer o1, Integer o2) 签名一致

1.3.3 构造函数引用

List<String> names = Arrays.asList("yalong", "xiaoli");
        //将names赋值到person(传统的做法是for循环赋值)
List<Person> persons = names.stream().map(Person::new).collect(Collectors.toList());

2 Stream流接口

2.1 创建Stream

2.1.1 通过指定元素、现有数组、现有Collection创建

Stream<Integer> s2 = Stream.of(1, 2, 3, 4, 5);
Integer[] array1 = new Integer[]{1,2,3,4};
Stream<Integer> s3 = Arrays.stream(array1);
List<String> names1 = Arrays.asList("yalong", "xiaoli");
Stream<String> s4 = names1.stream();

2.1.2 通过Supplier创建无限序列

//Stream<T> generate = Stream.generate(Supplier < T > s);
Stream<BigInteger> s5 = Stream.generate(new NaturalSupplier());

static class NaturalSupplier implements Supplier<BigInteger>{
        BigInteger next = BigInteger.ZERO;
        @Override
        public BigInteger get()
        {
            next = next.add(BigInteger.ONE);
            return next;
        }
    }

2.1.3 api接口创建

//将文件的一行当场一个stream元素
 Stream<String> s6 = Files.lines(Paths.get("/path/error.log"));
 //通过正则表达式创建
 String test = "a,b,c,d";
 Pattern pattern = Pattern.compile("\\s*\\,\\s*");
 Stream<String> s7 = pattern.splitAsStream(test);

2.1.4 基本类型创建(基本类型不支持泛型，所以不能使用上面的方法来创建Stream)

//IntStream.generate(Supplier < T > s);
//LongStream.generate(Supplier < T > s);
//DoubleStream.generate(Supplier < T > s);

2.1 Stream方法api

//Stream.map方法 可转换成另一个 Stream
//Stream.reduce 聚合成一个结果
int result = Stream.of(1, 2, 3, 4, 5).reduce((acc, x) -> acc * x).get();
//Stream.sorted 排序Stream
//Stream.distinct 去除重复元素的新Stream
//Stream.limit(long) 截取Stream的最大前N个元素
//Stream.skip(long) 跳过Stream的当前N个元素
//Stream.concat 将两个Stream合并成一个
//Stream.flatMap 如果Stream的元素是集合，flatMap可将集合的元素合并成一个新Stream
Stream<List<Integer>> listStream = Stream.of(
        Arrays.asList(1, 2, 3),
        Arrays.asList(1, 2, 3)
);
Stream<Integer> integerStream = listStream.flatMap(list -> list.stream());
//Stream.parallel 可并行处理stream
//Stream的聚合方法
...