Java8 新特性

速度更快更换了数据结构，内存结构（JVM）
*代码更少了（Lambda表达式） *
*强大的Stream API *
便于并行 fork join (串行切换并行)
最大化减少空指针异常 Optional

Lambda表达式

在说 Lambda 之前，首先要说的是函数式接口。这个可以说是为了 Lambda 表达式而存在的一个东西。那么什么是函数式接口？

函数式接口

定义：接口中只有一个抽象接口。像 java.util.function 下的所有接口都是函数式接口。Java1.8提供@FunctionalInterface检测一个接口是否是一个函数式接口。

"->" 是 lambda 表达式的符号左侧表示函数式接口中抽象方法的参数列表，右侧表示你对这个方法的实现

四大函数式接口

我们一般对函数式接口的使用的时候，都会对其进行封装。

消费性接口

Consumer 只有一个抽象方法名为 accept，参数列表只有一个泛型t，无返回值。参数的数据类型有类决定

/**
 * @ClassName ConsumerTest
 * @Description 消费型接口， 消费字符串字段 打印输出
 **/
public class ConsumerTest {

    public static void main(String[] args) {
        test("hello",x-> System.out.println(x));
    }

    public static <T> void test(T t, Consumer<T> consumer) {
        consumer.accept(t);
    }
}

输出：hello 如果需要多个参数列表的话，也可以在 java.util.function 包下找到相应的函数式接口比如 ObjLongConsumer。其他的可以自行查看

供给型接口

Supplier 只有一个抽象方法名为 get，参数列表为空，有返回值，返回值得数据类型为T。

/**
 * @ClassName SupplerTest
 * @Description 供给型接口 字符串拼接
 **/
public class SupplerTest {

    public static void main(String[] args) {
        String hello = test("hello ", () -> "word!");
        System.out.println(hello);
    }

    public static String test(String str,Supplier<String> supplier){
        return str + supplier.get();
    }
}

输出为：hello word! 如果需要返回得数据为基本数据类型，可以在 java.util.function 包下找到相应的函数式接口比如：getAsLong 其他的可以自行查看

函数型接口

Function<T, R> 只有一个抽象方法名为 apply，参数列表只有一个参数为T，有返回值，返回值的数据类型为R。（借鉴scala学习）

/**
 * @ClassName FunctionTest
 * @Description 函数式接口 将字符串转换成大写的
 **/
public class FunctionTest {


    public static void main(String[] args) {
        String test = test("hello", x -> x.toUpperCase());
        System.out.println(test);
    }


    public static String test(String str , Function<String,String> function){
        return function.apply(str);
    }
}

输出为：HELLO 如果需要多个入参，然后又返回值的话，可以在 java.util.function 包下找到相应的函数式接口比如 BiFunction。其他的可以自行查看

断言型接口

断言型又名判断型。 Predicate 只有一个抽象方法名为 test，参数列表只有一个参数为 T，有返回值，返回值类型为 boolean。

/**
 * @ClassName PredicateTest
 * @Description 断言型接口，判断字符串大小是否大于6
 * @Author ouyangkang
 * @Date 2019-02-18 16:16
 **/
public class PredicateTest {
    public static void main(String[] args) {
        boolean hello = test("hello", x -> x.length() > 6);
        System.out.println(hello);
    }
    public static boolean test(String str, Predicate<String> predicate){
        return predicate.test(str);
    }
}
复制代码

输出为： false

Stream API

Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Stream中间操作，多个中间操作可以连接起来形成一个流水线，除非流水线上触发了终止操作，否则中间不会执行任何处理！而终止操作时会一次性全部处理，称为惰性处理。要进行流操作首先要获取流。有4中方法可以获取流。

集合获取流 通过集合系列提供的stream方法和 parallelStream()（并行流）方法获取流

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        // 常用获取流的方式
        Stream<Integer> stream = list.stream();
    }

2.通过Arrays.stream() 将数组转换成流

    public static void main(String[] args) {
        int[] a = new int[]{1,2,3,4};
        IntStream stream = Arrays.stream(a);

    }

3.通过Stream.of的方法创建流

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
    }

4.创建无限流

    public static void main(String[] args) {
        Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
    }

所有的对流的操作可以分为4种，分别为筛选与分片，映射，排序，终结（归约，收集）

中间操作主要有以下方法（此类型方法返回的都是Stream）：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

终止操作主要有以下方法：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

筛选与分片

操作有 filter ,distant,limit,skip。

filter ：过滤操作,方法参数为*断言型接口 *

 public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.filter(x->x != 2).forEach(x-> System.out.println(x));
    }

输出：

1
3

distinct ：去重操作，方法无参数

limit ：获取前几条数据，*方法参数为long *

skip ：跳过前多少条数据，然后获取后面所有的。方法参数为long

映射

常用操作有 map ，flatMap。

map: 对原数据进行处理，并返回处理后的数据。方法参数为函数型接口

  public static void main(String[] args) {
       Stream<Integer> stream = Stream.of(1, 2, 3);
       stream.map(x->x*2).forEach(System.out::println);
    }

输出：

2
4
6

flatMap ：使原来流种的原有数据一个一个整合在另一个流中。方法参数为函数型接口，但是返回值为流

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        List<String> list2 = Arrays.asList("f","d");
        list.stream().flatMap(x->list2.stream().map(y-> x + y)).forEach(System.out::println);
    }

排序

常用操作有sort自然排序，合sort参数为排序器的定制排序

自然排序

public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.sorted().forEach(System.out::println);
    }

输出：

1
2
3

定制排序（(x,y)->-Integer.compare(x,y)）

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.sorted((x,y)->-Integer.compare(x,y)).forEach(System.out::println);
    }
复制代码

输出：

3
2
1

终止操作

allMatch 检查是否匹配所有元素方法参数为断言型接口
anyMatch 检查是否匹配所有元素方法参数为断言型接口
noneMatch 检查是否没有匹配所有元素方法参数为断言型接口
findFirst 返回第一个元素无方法参数
findAny 返回当前流的任意元素无方法参数
count 返回流中的元素总个数无方法参数
max 返回流的最大值无方法参数
min 返回流中的最小值无方法参数

归约

reduce : 归约 -- 可以将流中的元素反复结合起来，得到一个值

 public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer reduce = list1.stream().reduce(11, (x, y) -> x + y);
        System.out.println(reduce);
    }

输出： 66

收集

这个是非常常用的一个操作。将流装换为其他形式。接收到一个Collector接口的实现，用于给Stream中的元素汇总的方法。用collect方法进行收集。方法参数为Collector。Collector可以由Collectors中的toList()，toSet(),toMap(Function(T,R) key,Function(T,R) value)等静态方法实现。

toList() 返回一个 Collector ，它将输入元素 List到一个新的 List 。
toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper) 返回一个 Collector ，它将元素累加到一个 Map ，其键和值是将所提供的映射函数应用于输入元素的结果。
toSet() 返回一个 Collector ，将输入元素 Set到一个新的 Set 。 eg:

User类

@Data
@ToString
public class User {
    private String name;
    private Integer age;
    private Integer salary;
}
   public static void main(String[] args) {
         List<User> users = Arrays.asList(new User("张三", 19, 1000),
                new User("张三", 58, 2000),
                new User("李四", 38, 3000),
                new User("赵五", 48, 4000)
        );
        List<String> collect = users.stream().map(x -> x.getName()).collect(Collectors.toList());
        Set<String> collect1 = users.stream().map(x -> x.getName()).collect(Collectors.toSet());
        Map<Integer, String> collect2 = users.stream().collect(Collectors.toMap(x -> x.getAge(), x -> x.getName()));
        System.out.println(collect);
        System.out.println(collect1);
        System.out.println(collect2);
    }

输出：

[张三, 张三, 李四, 赵五]
[李四, 张三, 赵五]
{48=赵五, 19=张三, 38=李四, 58=张三}

分组

Collectors.groupingBy()方法是返回 Collector “由基团”上的类型的输入元件操作实现 T ，根据分类功能分组元素。这个是非常常用的操作。比如你要对名字相同的进行分组。 groupingBy(Function<? super T,? extends K> classifier) eg:

    public static void main(String[] args) {
        List<User> users = Arrays.asList(new User("张三", 19, 1000),
                new User("张三", 58, 2000),
                new User("李四", 38, 3000),
                new User("赵五", 48, 4000)
        );
        Map<String, List<User>> collect3 = users.stream().collect(Collectors.groupingBy(x -> x.getName()));
        System.out.println(collect3);
    }

输出：{李四=[User{name='李四', age=38, salary=3000}], 张三=[User{name='张三', age=19, salary=1000}, User{name='张三', age=58, salary=2000}], 赵五=[User{name='赵五', age=48, salary=4000}]}

当然还有其他的一些比较复杂的分组操作，实际代码看业务来进行实现。

总结

java8中的lambda表达式可能一开始用的时候还不是很熟悉，但是只要熟悉了，你会发现非常的好用，而且lambda表达式结合stream API可以进行编写自己的工具类。在平常项目中可以非常的省时间，提高写代码的效率。我现在给出一个List转Map的工具类。

public class CollectionStream {
    public static void main(String[] args) {
        List<User> users = Arrays.asList(new User("张三", 19, 1000),
                new User("张三", 58, 2000),
                new User("李四", 38, 3000),
                new User("赵五", 48, 4000)
        );
        Map<Integer, Integer> map = listToMap(users, x -> x.getAge(), x -> x.getSalary());
        System.out.println(map);
    }

    /**
     * @Description list 转map key不能相同 ，如果相同会报错。 方法对 源数据，key，value过滤null。
     * @param source 源数据
     * @param key
     * @param value
     * @return java.util.Map<K,V>
    **/
    public static <DTO, K, V> Map<K, V> listToMap(List<DTO> source, Function<? super DTO, ? extends K> key, Function<? super DTO, ? extends V> value) {
        Objects.requireNonNull(source, "source not null");
        Objects.requireNonNull(key, "key not null");
        Objects.requireNonNull(value, "value not null");
        Map<K, V> map = source.stream()
                .filter(dto -> dto != null)
                .filter(dto -> key.apply(dto) != null)
                .filter(dto -> value.apply(dto) != null)
                .collect(Collectors.toMap(key, value));
        return map;
    }
}

遍历有四种：普通for、增强for、iterator迭代器、lamada
lamada中，循环体外部赋值的变量，无法在循环体内再次重新赋值。原因是：这个lamada表达式是类似于java匿名内部类的方式实现的，在匿名的内部类中访问局部变量，只能访问常量。增强for、迭代器、lamada不适合遍历时修改遍历对象的值。

Lambda表达式_Stream小总结