一文了解：JDK8的Stream流操做以及lambda表达式

Lambda Jdk8

Lambda 是一个匿名函数，只关注参数列表和方法体,咱们能够把 Lambda表达式理解为是一段能够传递的代码（将代码像数据同样进行传递)

类型推断:省略参数类型

与内部类比较

内部类this关键字指向内部类自己,Lambda中this指向lambda所处在的类

Java编译器将lambda表达式编译成类的私有方法。使用了Java 7的 invokedynamic 字节码指令来动态绑定这个方法。

表达式

引入了->新操做符:参数表加操做体

(Parameters)->{expressions}复制代码

方法引用

类名 :: 方法名

功能接口(使用要求)

使用@FunctionalInterface注解

接口中的抽象方法只能是一个(函数式接口)

Predicate

java.util.function.Predicate函数式接口,向API方法添加逻辑,很是适合作过滤器

List<String> names=Arrays.asList("dx","wdt","zfb","wuguangyao","nihaoshiw"));
        Predicate<String> filter1 = str->str.length()>5;
        Predicate<String> filter2 = str->str.endsWith("yao");
       // filter(names,(n)->((String)n).startsWith("d"));
        filter(names,filter2);
        names.stream().filter(filter1.and(filter2))
                .forEach(System.out::println);
    }

    public static void filter(List<String> list, Predicate condition){
        for(String str:list){
            if(condition.test(str)){
                System.out.println(str);
            }
        }
    }复制代码

Runnable

Runnable t = ()-> System.out.println("hello");
        t.run();复制代码

s

Collections

根接口

sort

implements Comparable

实体类实现Comparable接口

public class Student implements Comparable<Student> {
~~~~
@Override
    public int compareTo(Student o) {
        return stuId.compareTo(o.getStuId());
    }复制代码

Collections.sort(List ,new Comparator())

建立一个比较器实现Comparator接口

Collections.sort(list, new Comparator<StudentNoSort>() {
            @Override
            public int compare(StudentNoSort o1, StudentNoSort o2) {
                return o1.getStuId().compareTo(o2.getStuId());
            }
        });复制代码

Stream

使用Jdk8 Stream更加简单

List<StudentNoSort> streamList = list.stream()
                .filter(w -> w.getClass()==StudentNoSort.class)
                .sorted(((o1, o2) -> o1.getStuId().compareTo(o2.getStuId())))
                .collect(Collectors.toList());复制代码

Stream

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操做；高级版本的 Stream，用户只要给出须要对其包含的元素执行什么操做，好比 “过滤掉长度大于 10 的字符串”、“获取每一个字符串的首字母”等，Stream 会隐式地在内部进行遍历，作出相应的数据转换。

Stream构成

获取一个数据源（source）→ 数据转换→执行操做(返回新的Stream对象)，这就容许对其操做能够像链条同样排列，变成一个管道

Stream Source

集合，数组，I/O channel， 产生器generator 等

Stream Operation

Intermediate

一个流能够后面跟随零个或多个 intermediate 操做。其目的主要是打开流，作出某种程度的数据映射/过滤，而后返回一个新的流，交给下一个操做使用。

collect

建立一个List

filter

过滤器:集合进行过滤操做

distinct

集合元素去重

map

对函数进行操做

reduce

组合元素

forEach

遍历元素

limit

限定流中数据的数量

sorted

排序 使用Comparator接口

march,allMatch,noneMatch,anyMatch

符合元素传入predicate,返回boolean

还有如下

mapToInt (转换为int), summaryStatistics(int型变量统计) ,sum(int型求和)

Terminal

一个流只能有一个 terminal 操做，当这个操做执行后，流就被使用“光”了，没法再被操做。

构造Stream

Collections

Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();复制代码

example:

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 12, 1, 1, 2, 3, 2, 432, 4, 32, 54, 3, 3));
        int sum = list.stream().map(x -> x * x)
                .reduce((x, y) -> x + y)
                .get();复制代码

遍历文件(nio+lambda)

Path start = FileSystems.getDefault().getPath("/home/dzou/报告/模电");
        Files.walk(start)
                .filter(path -> path.toFile().isFile())
                .filter(path -> path.toString().endsWith(".jpg"))
                .forEach(System.out::println);复制代码

时间复杂度

Stream 里有个操做函数的集合，每次转换操做就是把转换函数放入这个集合中，在 Terminal 操做的时候循环 Stream 对应的集合，而后对每一个元素执行全部的函数

并行parallelStream

咱们看这个代码,输出不是顺序的

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        numbers.parallelStream()
                .forEach(out::println);复制代码

底层使用ForkJoinPool,相比于ThreadPoolExecutor,可让线程建立新的任务,并挂起当前任务,此时线程能够在队列中选择子任务执行