java8新特征

方法引用

PrintStream ps = System.out;
        Consumer<String> consumer = System.out::println;
        consumer.accept("java");

        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("a","c"));

类名::new

class MathOperations {
    public MathOperations(int o1, int o2) {
        System.out.println("o1 + o2  =" +(o1 + o2));
    }
}

BiConsumer<Integer, Integer> addtion2 = MathOperations::new;
        addtion2.accept(20, 30);

        BiConsumer<Integer,Integer> addtion1 = (a,b) -> new MathOperations(a,b);
        addtion1.accept(1,2);

        myFunc myFunc = () -> System.out.println("lzl");
        myFunc.run();

函数式接口

@FunctionalInterface 在接口上面注解声明,单例抽象方法接口,接口里面只能存在一个抽象方法

例如

 @FunctionalInterface
interface myFunc{
    public abstract void run();
}

myFunc myFunc = () -> System.out.println("r");
       myFunc.run();

java8中的Stream 流

stream流创建

IntStream stream = Arrays.stream(arr);
Stream<String> stream = list.stream();
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);

通过iterate创建stream流

Stream<Integer> iterate = Stream.iterate(0, t -> t + 1).limit(10);
        iterate.forEach(System.out::println);

这里不加limit会无限循环下去

generate与上面类似

Stream.generate(Math::random).limit(10);

Stream 的中间操作

1. filter()：对元素进行过滤

   //过滤出大于5的数
   iterate.filter(s -> s>5).forEach(System.out::println);

2. distinct 对元素进行去重

当然，前提是要重写equals和hashcode方法

iterate.distinct().forEach(System.out::println);

3. map 映射

这里通过map映射把int转换为string并进行输出

iterate.map(e -> e.toString()).forEach(System.out::println);

4. flatMap 一个或多个流合并成一个新流

   Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6)).flatMap(s -> s.stream()).forEach(s -> {
               System.out.print(s + ", ");
           });

5. limit限流

   Stream<Integer> iterate = Stream.iterate(0, t -> t + 1).limit(10);

6. skip 跳过元素

    Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6)).flatMap(s -> s.stream()).skip(3).forEach(s -> {
               System.out.print(s + ", ");
           });
   //跳过前三个元素

7. sorted 排序

   Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6)).flatMap(s -> s.stream()).sorted((e1,e2)->Integer.compare(e2,e1)).forEach(s -> {
               System.out.print(s + ", ");
           });

8. peek 数据状态

   Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5, 6)).flatMap(s -> s.stream()).peek(s -> System.out.println(s)).forEach(s -> {
               System.out.print(s + ", ");
           });

Stream 的终止操作

1. forEach 循环操作 Stream 数据
2. toArray——Stream 转数组
3. anyMatch、allMatch、noneMatch 返回bool类型

• anyMatch(Predicate p) 检查是否至少匹配一个元素。
• allMatch(Predicate p) 检查是否匹配的所有元素。
• noneMatch(Predicate p) 检查是否没有匹配的元素。

  System.out.println(iterate.allMatch(s -> s > -1));  //检查是否所有值大于-1

4. min、max、count
   min(Comparator p) 返回流中最小值。 max(Comparator c) 返回流中最大值。count 返回流中元素个数。

   System.out.println(iterate.max((e1,e2)-> Integer.compare(e1,e2)));

5. reduce 统计
   将流中元素反复集合起来，得到一个值

   System.out.println(iterate.reduce(Integer::sum));

6. collect——list、set、map

7. joining()、groupingBy

   String collect = list.stream().collect(Collectors.joining("->","",""));
           System.out.println(collect);

8. findFirst、findAny

   findFirst()：获取第一个元素
   findAny()：获取任一元素

串行流与并行流

串行流上的操作是在一个线程中依次完成，而并行流则是在多个线程上同时执行。

串行流

int count = (int) ((Stream) list.stream().sequential()).sorted().count();

并行流

int count = (int)((Stream) list.stream().parallel()).sorted().count();

Optional取代空指针

Optional.of(T t)：创建一个 Optional 实例
Optional.empty()：创建一个空的 Optional 实例
Optional.ofNullable(T t)：t 可以为 null

isPresent()判断容器中是否包含对象

T get() 获取容器中的对象，没有则抛出异常

T orElse(T other)：返回值（如果存在），否则返回其他

T orElseGet(Supplier<? extends T> other)：返回值（如果存在），否则调用其他并返回该调用的结果。

T orElseThrow(Supplier<? extends X> exceptionSupplier)：返回包含的值（如果存在），否则将引发由提供的供应商创建的异常。