lamda接口语法

lamda表达式本质：作为接口的一个实例

内置函数式接口

方法引用

语法

• 对象::非静态方法
• 类::静态方法
• 类::非静态方法

使用要求

1. 当要传递给Lambda表达式体的操作，已经有实现的方法了，可以使用
2. (对象::非静态方法)(类::静态方法)这两种情况接口中的抽象方法要和已实现的方法的形参列表和返回值类型都相同

//对象::方法
    public static void main(String[] args) {

        // void accept(T t) 
        Consumer<String> consumer = str-> System.out.println(str);

        //System.out = PrintStream 对象
        // void println (String x)
        Consumer<String> consumer2 = System.out::println;
        
    }

//类::静态方法
    public static void main(String[] args) {
        //int compare(T o1, T o2);
        //就一行可以隐藏return 和大括号
        //Comparator<Integer> com = (x,y)-> {return Integer.compare(x,y);};
        Comparator<Integer> com = (x,y)-> Integer.compare(x,y);

        //int compare(int x, int y)
        Comparator<Integer> com1 = Integer::compare;
    }

 //类::实例方法
    public static void main(String[] args) {


        BiPredicate<String,String> predicate = (x,y)->x.equals(y);
        //两个参数。第一个参数作为被调用的对象，第二个对象为方法的传参
        BiPredicate<String,String> predicate1 = String::equals;


        //R accept(T t) 传入Dog 对象 返回String
        Function<Dog,String> f = x-> x.getName();

        //因为getName不需要参数
        Function<Dog,String> f2 = Dog::getName;
    }

    class Dog {
        private String name;
        public String getName() {
            return name;
        }

构造器引用以及数组引用

构造器引用

• 语法 类::new

public class test {
    //构造器引用（主要看接口的抽象方法和哪个构造方法相同）
    public static void main(String[] args) {

        //无参构造(根据Supplier接口，无参。自动匹配到无参构造函数）
        Supplier<Dog> supplier = ()-> new Dog();
        Dog dog = supplier.get();
        Supplier<Dog> supplier1 = Dog::new;
        Dog dog1 = supplier1.get();

        //一个参数构造器（Function需要一个参数，匹配到一个参数对应类型的构造方法）
        Function<String,Dog> f = name-> new Dog(name);
        Dog ck = f.apply("ck");
        Function<String,Dog> f1 = Dog::new;
        Dog ck1 = f1.apply("ck");

        //多个构造参数（匹配到多个参数）
        BiFunction<String,Integer,Dog > biFunction = (name,age)->new Dog(name,age);
        Dog ck2 = biFunction.apply("ck", 100);
        BiFunction<String,Integer,Dog > biFunction1 = Dog::new;
        Dog ck3= biFunction1.apply("ck", 100);
    }

    static class Dog {
        private String name;
        private Integer age;

        public Dog(){};

        public Dog(String name) {
            this.name = name;
        }

        public Dog(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    }
}

数组引用

• 语法 String[]::new

  Function<Integer,String[]> f = leng-> new String[leng];
  String[] apply = f.apply(10);
  Function<Integer,String[]> f1 = String[]::new;
  f1.apply(10);

Stream流

串行流和并行流

list.stream();//串行流，俺顺序遍历
list.parallelStream();//并行流，多线程随机获取值

串行流并行流使用

创建Stream流的四种方式

 public static void main(String[] args) {
        //1.集合
        List<Integer> list = new ArrayList<>();
        Stream<Integer> stream = list.stream();
        //2.数组
        int[] array = {1,2,3,4,5,6,7};
        long[] array1 = {1L,2L,3L,4L,5L,6L,7L};
        double[] array2 = {1.1,2.1,3.1,4.1,5.1,6.1,7.1};
        Integer[] array3 = {1,2,3,4,5,6,7};
        //对应的Int long double 返回 IntStream，LongStream，DoubleStream，只有这三个基本数据类型
        IntStream stream1 = Arrays.stream(array);
        LongStream stream2 = Arrays.stream(array1);
        DoubleStream stream3 = Arrays.stream(array2);
        Stream<Integer> stream4 = Arrays.stream(array3);//对象
        //3. Stream.of
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
        //4. 无限流，用来造数据
        // public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //UnaryOperator 参数T 返回值T
        Stream.iterate("s",x->x+"s").limit(10).forEach(System.out::println);
        Stream.iterate(1,x->x+2).limit(10).forEach(System.out::println);//1,3,5,7...19
        //public static<T> Stream<T> generate(Supplier<? extends T> s)
        //Supplier =》 T get();
        Stream.generate(Math::random).limit(10).forEach(System.out::println); //随机十个数
    }

流的形式

1. 带泛型的流 Stream<T,>
2. 基本类型流 IntStream，LongStream，DoubleStream

中间操作

惰性处理，中间操作只有在终端操作时一次性执行。

筛选和切片

映射

flatMap的使用

public static void main(String[] args) {
        //flatMap使用例子
        String[] strings = {"Hello","world"};
        //输出Helloworld
        //1. x->x.split("") 得到两个String[]数组 {"H","e","l","l","o"},{"w","o","r","l","d"}
        //2. flatMap(x->Arrays.stream(x)) 将每个数组又转换成两个流 {"H","e","l","l","o"}流，{"w","o","r","l","d"}流
        //3. 最后两个流合并 {"H","e","l","l","o","w","o","r","l","d"}
        Arrays.stream(strings).map(x->x.split("")).flatMap(x->Arrays.stream(x)).forEach(System.out::print);
    }

参考：

flatMap的使用

排序

sorted() 排序的类要实现Comparable接口，不然报错

终止操作

匹配与查找

Predicate =》boolean test(T t)

public static void main(String[] args) {
        
        Integer[] strings = {1,4,5,6,7,2,3};
        boolean a = Arrays.stream(strings).allMatch(x -> x < 0); //是否有所元素都小于0 false
        boolean b = Arrays.stream(strings).anyMatch(x -> x < 0); //是否任意一个元素小于0 false
        boolean c = Arrays.stream(strings).noneMatch(x -> x < 0);//是否所有元素都不小于0 true
        Optional<Integer> any = Arrays.stream(strings).findAny();//Optional 里面是1
        Optional<Integer> first = Arrays.stream(strings).findFirst();//Optional 里面是随机一个数
    }

规约

BinaryOperator =>T apply(T t1, T t2)

备注：经常和map合用

public static void main(String[] args) {
    
        Integer[] strings = {1,4,5,6,7,2,3};
        Integer reduce = Arrays.stream(strings).reduce(6, (x, y) -> x + y); //34
        Optional<Integer> reduce2 = Arrays.stream(strings).reduce((x, y) -> x + y); //28
        //对象使用 求dog的age总和
        ArrayList<Dog> dogs = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            dogs.add(new Dog(i+50));
        }
        Integer reduce3 = dogs.stream().map(x -> x.getAge()).reduce(0, (x, y) -> x + y);//260
        Dog reduce1 = dogs.stream().reduce(new Dog(50), (x, y) -> new Dog(x.getAge() + y.getAge()));//dog对象 其中age=310
        Optional<Dog> reduce4 = dogs.stream().reduce((x, y) -> new Dog(x.getAge() + y.getAge()));//Optional对象
    }
    static class Dog
    {
        private Integer age;

        public Dog(Integer age) {
            this.age = age;
        }

        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
    }

收集

将得到的流收集成对应的类型

Collectors 类提供了很多静态方法:


方法以及例子

按规则收集例子：

1. 第一个参数：Supplier<R.> supplier 代表用什么东西收集 返回值确定类型R
2. 第二个参数： BiConsumer<R, ? super T> 代表要如何处理一个个的元素。 R类型已由第一个参数确定，T为收集到的元素。
3. 第三个参数：BiConsumer<R, R> 代表要怎么整合前面处理好的一个个元素
4. 先创建一个容器，然后流中的每个元素如何存进这个容器，流中的每一个元素都会有一个容器，最后所有的容器如何整合起来

int[] a = {1,23,4,5,6,7,8};

//collect2 等价于 collect2_1
HashMap collect2 = Arrays.stream(a).collect(() -> new HashMap(), (x, y) -> x.put(y, y), (x, y) -> x.putAll(y));
HashMap collect2_1 = Arrays.stream(a).collect(HashMap::new, (x, y) -> x.put(y, y), HashMap::putAll);
//collect3 等价于 collect3_1
ArrayList collect3 = Arrays.stream(a).collect(() -> new ArrayList(), (x, y) -> x.add(y, y), (x, y) -> x.addAll(y));
ArrayList collect3_1 = Arrays.stream(a).collect(ArrayList::new, (x, y) -> x.add(y, y), ArrayList::addAll);

Optional类

创建Optional类对象的方法

判断Optional容器中是否够包含对象

获取Optional容器中的对象