JDK 8

1、lambda

使用格式：

 (参数列表)->{
        方法体
 }

方法体：用于执行业务逻辑，可以是单一语句，亦可以是语句块，当时一个单一的语句时，可以省略花括号。当需要返回值的时候，如果方法体中只有一个语句，可以省略return，会自动根据结果进行返回。

• 没有参数的

()-> new Student();

• 只有一个参数的

    x->{
        System.out.println(x);
        return x;
    }

• 多个参数

(int x,int y)->{
        System.out.println(x);
        System.out.println(y);
        return x+y;
    }

参数类型可以省略哦

遍历集合:

list.forEach(v->{
            System.out.println(v);
        });
        
list.forEach(v-> System.out.println(v));
        
list.forEach(System.out::println);

改造匿名内部类：

Runnable runnable = new Runnable(){
            @Override
            public void run() {
                
            }
        };
        
 Runnable runnable1= ()->{
     System.out.println("111");
 };

集合排序:

Arrays.sort(ints, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return (o1.compareTo(o2));
            }
        });
​
        Arrays.sort(ints,(o1, o2) -> o1.compareTo(o2));

2、函数式接口

        其实是仅有一个抽象方法的普通接口，如果声明多个抽象方法则会报错，但是默认的方法和静态方法在此接口中可以定义多个。

3、Stream流

        流操作是java8提供一个重要新特性，它允许开发人员以声明性方式处理集合，其核心类库主要改进了对集合类的API和新增Stream操作。Stream类中每一个方法都对应集合上的一种操作。将真正的函数式编程引1入到ava中，能让代码更加简洁，极大地简化了集合的处理操作，提高了开发的效率和生产力。

        同时，Stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或i/o channel等。在Stream中的操作每一次都会产生新的流，内部不会像普通集合操作一样立刻获取值，而是情性取值，只有等到用户真正需要结果的时候才会执行。

• 中间操作：会返回一个流，通过这种方式可以将多个中间操作连接起来，形成一个调用链，从而转化为另外一个流。除非调用链最后存在一个终端操作，否者中间操作对流不会进行任何结果处理。

• 终端操作：会返回一个具体的结果，比如Boolean、List、Integer等。

public class demo1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"张三","F",18));
        list.add(new Student(2,"李四","M",19));
        list.add(new Student( 3,"王五","F",20));
        list.add(new Student( 4,"赵六","M",21));
​
​
        List<String> collect = list.stream()
                .filter(student -> student.getAge() > 19)// 过滤出年龄大于19岁的学生
                .sorted(Comparator.comparing(Student::getAge))// 按照年龄排序
                .map(Student::getName)// 只获取学生的名字
                .collect(Collectors.toList());// 将结果收集到list中
​
       // System.out.println(collect);
​
​
        List<String> collect1 = Stream.of("one", "two", "three", "four")
                .filter(e -> e.length() > 3)
                .peek(e -> System.out.println("Filtered value: " + e))
                .map(String::toUpperCase)
                .peek(e -> System.out.println("Mapped value: " + e))
                .collect(Collectors.toList());
        System.out.println(collect1);
​
    }
}

3.1、筛选

        对于集合的操作，经常性的会涉及到对于集中符合的数据筛选，Stream中对于数据筛选两个常见的API：filter（过滤），distinct（去重）。

List<Student> collect = list.stream().distinct().collect(Collectors.toList());

        输出集合发现没有去重，为什么原来是要实现hashcode和equals方法！！！

3.2、切片

limit

public class limitdemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
​
        List<Integer> collect = list.stream().limit(4).collect(Collectors.toList());
        System.out.println(collect);
    }
}

        limit是对数据进行从前往后的方式进行截取，但是对于我想获取其中的一部分数据怎么办，skip

public class limitdemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
​
        List<Integer> collect = list.stream()
                .limit(4)
                .skip(2)
                .collect(Collectors.toList());
        System.out.println(collect);
    }
}

两个执行的前后顺序不一样的话，获取到的结果也是不一样的。

3.3、映射

        在对集合进行操作的时候，我们经常会从对象选择性的提取某些数据的值，就像编写sql一样，指定获取表中的特定数据列。

select name from Student

public class demo1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"张三","F",18));
        list.add(new Student(2,"李四","M",19));
        list.add(new Student( 3,"王五","F",20));
        list.add(new Student( 4,"赵六","M",21));
        list.add(new Student( 4,"赵六","M",21));
​
        List<String> collect = list.stream().map(Student::getName).collect(Collectors.toList());
​
        List<String> stringList = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9");
​
        List<Integer> integerList =                 stringList.stream().map(Integer::parseInt).collect(Collectors.toList());
        int sum = stringList.stream().mapToInt(Integer::parseInt).sum();
​
        System.out.println(collect);
    }
}

3.4、匹配

        在日常的开发中，有时还需要判断集合中的某些元素是否匹配对应的条件，如果有可以进行后续操作，在Stream中提供了相关方法供我们使用，比如anyMatch、allMatch等。

        anyMatch：判断条件至少匹配一个元素，主要用于判断六中的元素是否至少存在一个符合条件的元素， 他返回的是一个Boolean值，并且对于它的操作一般叫做短路求值。

        短路求值：对于集合的一些操作，我们无需处理整个集合就可以获得结果，比方说通过&&或者||连接一个判断调条件，这个就是短路。对于流来说，某些操作不用操作整个流就可以得到结果。

        AllMatch()判断条件是否匹配所有元素，AllMatch的工作原理与anyMatch类似，但是执行anyMatch时，只要流中有一个元素符合条件就会返回true，而allMatch会判断流中所有的条件都符合条件，全部符合才会返回true。

public class demo1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"张三","F",18));
        list.add(new Student(2,"李四","M",19));
        list.add(new Student( 3,"王五","F",20));
        list.add(new Student( 4,"赵六","M",21));
        list.add(new Student( 5,"孙琪","M",22));
​
        boolean b = list.stream().anyMatch(student -> student.getAge() > 21);
        System.out.println(b);
​
        boolean b1 = list.stream().allMatch(student -> student.getAge() > 20);
        System.out.println(b1);
​
    }
}

3.5、查找

        对于集合操作，有时需要从集合中查找中符合条件的元素，Stream中也提供了相关的API，findAny(和findFirst0，他俩可以与其他流操作组合使用。findAny用于获取流中随机的某一个元素，findFirst用于获取流中的第一个元素。至于一些特别的定制化需求，则需要自行实现。

public class demo1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"张三","F",18));
        list.add(new Student(2,"李四","M",19));
        list.add(new Student( 3,"王五","F",20));
        list.add(new Student( 4,"赵六","M",21));
        list.add(new Student( 5,"孙琪","M",22));
​
​
        Optional<Student> any = list.stream().filter(student -> student.getAge() > 18).findAny();
​
        if (any.isPresent()){
            Student student = any.get();
            System.out.println(student);
        }
​
​
    }
}

3.6、规约

        到现在截止，对于流的终端操作，我们返回的有boolean、Optional和List。 但是在集合操作中，我们经常会涉及对元素进行统计计算之类的操作，如求和、求最大值、最小值等，从而返回不同的数据结果。

public class dis {
    public static void main(String[] args) {
​
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 4, 3, 2, 1);
​
​
        Integer reduce = list.stream().reduce(0, (x, y) -> x + y);
        System.out.println(reduce);
        Integer reduce1 = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce1);
​
        Integer integer = list.stream().reduce(Integer::sum).get();
        System.out.println(integer);
    }
}

3.7、数值处理

​
      

  Integer max = list.stream().reduce(Integer::max).get();
        System.out.println(max);
        list.stream().reduce(Integer::min).ifPresent(System.out::println);
        list.stream().reduce(Integer::sum).ifPresent(System.out::println);

3.8、构建流

基于值：

   Stream<String> stream = Stream.of("one", "two", "three", "four");
        stream.forEach(System.out::println);
        
        Integer[] integers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Stream<Integer> stream1 = Stream.of(integers);
        stream1.forEach(System.out::println);

基于文件：

public class filedemo {
​
    public static void main(String[] args) throws IOException {
​
        Files.list(Paths.get("")).forEach(path -> {
            System.out.println(path);
​
            try {
                Files.lines(path).forEach(c->{
                    System.out.println(c);
                });
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

3.9、收集器

        通过使用收集器，可以让代码更加方便的进行简化与重用。其内部主要核心是通过Collectois完成更加复杂的计算转换，从而获取到最终结果。并且Collectors内部提供了非常多的常用静态方法，直接拿来就可以了。比方说：toList。

public class demo1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"张三","F",18));
        list.add(new Student(2,"李四","M",19));
        list.add(new Student( 3,"王五","F",20));
        list.add(new Student( 4,"赵六","M",21));
        list.add(new Student( 5,"孙琪","M",22));
​
​
        Map<String, List<Student>> collect = list.stream().collect(Collectors.groupingBy(Student::getSex));
        System.out.println(collect);
    }
}

收集集合总数、最大值、最小值

public class demo1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"张三","F",18));
        list.add(new Student(2,"李四","M",19));
        list.add(new Student( 3,"王五","F",20));
        list.add(new Student( 4,"赵六","M",21));
        list.add(new Student( 5,"孙琪","M",22));
​
​
        Long collect = list.stream().collect(Collectors.counting());
​
        Optional<Student> collect1 = list.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getAge)));
        Student student = collect1.get();
        System.out.println(student);
        Optional<Student> collect2 = list.stream().collect(Collectors.minBy(Comparator.comparing(Student::getAge)));
        System.out.println(collect2.get());
    }
}

平均值，求和

public class demo1 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"张三","F",18));
        list.add(new Student(2,"李四","M",19));
        list.add(new Student( 3,"王五","F",20));
        list.add(new Student( 4,"赵六","M",21));
        list.add(new Student( 5,"孙琪","M",22));
        
        Integer collect = list.stream().collect(Collectors.summingInt(Student::getAge));
        int sum = list.stream().mapToInt(Student::getAge).sum();
​
        Double collect1 = list.stream().collect(Collectors.averagingDouble(Student::getAge));
        list.stream().mapToDouble(Student::getAge).average();
    }
}