lambda&Stream流

目录

1.内部类

2. lambda

3.功能接口

4. Stream流

---

1.内部类

1.把类定义在一个类的内部，该类就是内部类。

什么时候用内部类：当某一个功能只在自己类中供自己使用，没有必要定义一个外部类，所以定义在自己类中使用即可。

定义为内部类，可以使用外部类的变量，即使私有

2.分类

成员内部类

局部内部类：在方法里面定义了一个类

静态内部类：static修饰的，只能使用外部类静态变量

匿名内部类：没有名字的一个类，内部类的简化写法

2. lambda

Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。

import java.util.Arrays;
import java.util.Comparator;
​
public class CarTest {
    public static void main(String[] args) {
        Car car1 = new Car(101, "car1");
        Car car2 = new Car(103, "car3");
        Car car3 = new Car(102, "car2");
        Car car4 = new Car(104, "car4");
​
        Car[] cars = {car2, car1, car4, car3};
​
        /*Arrays.sort(cars, new Comparator<Car>() {
            @Override
            public int compare(Car o1, Car o2) {
                return o1.getNum()- o2.getNum();
            }
        });*/
​
        Arrays.sort(cars, (c1, c2) -> {
            return c1.getNum() - c2.getNum();
        });
        System.out.println(Arrays.toString(cars));
    }
}

lambda表达式例子

无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略 () -> System.out.println("Hello World"); 无参数，有返回值 () -> { return 3.1415 }; 有参数，无返回值 (String s) -> { System.out.println(s); } 有一个参数，无返回值 s -> { System.out.println(s); } 有多个参数，有返回值 (int a, int b) -> { return a + b; } 有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断 (a, b) -> { return a - b; }

3.功能接口

Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口，功能接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽象方法接口。用@FunctionalInterface注释，当你注释的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。

@FunctionalInterface
public interface DoWork {
    void work(int a,int b);
}

public class Person {
    public void persontest(DoWork doWork) {
        doWork.work(10,3);
​
    }
​
    public static void main(String[] args) {
        Person person = new Person();
        person.persontest((q,w)->{ //自动推断类型
            System.out.println(q+w);
        });
    }
}

4. Stream流

Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。

数据处理操作 :流更偏向于数据处理和计算，比如 filter、map、find、sort 等。简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。

获取流的方法：

//1.使用 Collection 接口下的 stream()
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
​
//2.使用 Arrays 中的 stream() 方法，将数组转成流
Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);
​
//3.使用 Stream 中的静态方法：of()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
​
//4.使用 BufferedReader.lines() 方法，将每行内容转成流
BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));
Stream<String> lineStream = reader.lines();

流操作

中间操作 filter：过滤流中的某些元素, sorted(): 自然排序，流中元素需实现 Comparable 接口 distinct: 去除重复元素 limit(n): 获取 n 个元素 skip(n): 跳过 n 元素，配合 limit(n)可实现分页 map(): 将其映射成一个新的元素

终端操作 forEach: 遍历流中的元素 toArray:将流中的元素倒入一个数组 Min:返回流中元素最小值 Max:返回流中元素最大值 count:返回流中元素的总个数 Reduce:所有元素求和 anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返回 true，否则返回 false allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返回 true，否则返回 false findFirst：返回流中第一个元素 collect:将流中的元素倒入一个集合,Collection 或 Map

对数组的操作

 public static void main(String[] args) {
        Integer[] array = {1, 3, 5, 2, 4, 6, 7, 8};
​
        long count = Arrays.stream(array)
                .distinct()
                .sorted((a, b) -> {
                    return a - b;
                })
                .count();//返回处理后元素总个数
        System.out.println(count);//输出 8
​
        Integer sum = Arrays.stream(array)
                .distinct()
                .reduce((a, b) -> {
                    return a + b;
                })
                .get();
        System.out.println(sum);//输出36
​
        Object[] objs = Arrays.stream(array)
                .distinct()
                .sorted((a, b) -> {
                    return a - b;
                })
                .toArray();
        System.out.println(Arrays.toString(objs));//输出 [1, 2, 3, 4, 5, 6, 7, 8]
​
        boolean b = Arrays.stream(array)
                //.anyMatch((a)->{return a>5;})  //遍历所有元素是否有大于5
                .allMatch((a) -> {
                    return a > 5;
                });   //遍历所有元素是否全部大于5，返回布尔值
​
        System.out.println(b);// false
​
​
        List<Integer> list = Arrays.stream(array)
                .distinct()
                .collect(Collectors.toList());
​
        System.out.println(list);//输出 [1, 2, 3, 4, 5, 6, 7, 8]
    }

对集合进行操作

public static void main(String[] args) {
        Car car1 = new Car(101, "car1");
        Car car2 = new Car(103, "car3");
        Car car3 = new Car(102, "car2");
        Car car4 = new Car(104, "car4");
​
        Car[] cars = {car2, car1, car4, car3};
​
        List<Car> list = Arrays.stream(cars)
                .filter((a) -> {
                    return a.getName().equals("car1");
                })
                .collect(Collectors.toList());
        System.out.println(list);
​
        Object[] objs = Arrays.stream(cars)
                .sorted((a, b) -> {
                    return a.getNum() - b.getNum();
                })
                .toArray();
        System.out.println(Arrays.toString(objs));
​
        Set<Car> set = Arrays.stream(cars)
                .sorted((c1, c2) -> {
                    return c1.getNum() - c2.getNum();
                })
                .collect(Collectors.toSet());
        System.out.println(set);
​
        Map<Integer, String> map = Arrays.stream(cars)
                .collect(Collectors.toMap(Car::getNum, Car::getName));
​
        System.out.println(map);
        //输出{101=car1, 102=car2, 103=car3, 104=car4}
​
        List<Integer> lists = Arrays.stream(cars)
                .map(Car::getNum)//  map(): 将其映射成一个新的元素
                .collect(Collectors.toList());
        System.out.println(lists);
        //输出[103, 101, 104, 102]
    
        List<String> lists1 = Arrays.stream(cars)
                .map(Car::getName)
                .collect(Collectors.toList());
        System.out.println(lists1);
        //输出[car3, car1, car4, car2]
    }