Lambda 表达式和Stream流

最新推荐文章于 2024-05-12 20:46:47 发布

山枧雾

最新推荐文章于 2024-05-12 20:46:47 发布

阅读量295

点赞数

分类专栏： JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/penghaixia666/article/details/125850657

版权

JavaSE 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

使用 Arrays 中的 stream() 方法，将数组转成流

使用 Stream 中的静态方法：of()

Lambda 表达式

前提

使用lambda表达式接口中只能有一个抽象方法,因为需要自动类型推断 @FunctionalInterface 代表该接口是功能函数接口

定义

lambda是一个匿名函数,简化匿名内部类语法,可以把匿名函数当做参数传递,由java进行推断

写法

()->{}

示例1:无参无返回值

/*
  使用lambda表达式接口中只能有一个抽象方法,因为需要自动类型推断
  @FunctionalInterface 代表该接口是功能函数接口
*/
@FunctionalInterface
public interface Demo {
    void show();
}



public class TestDemo {
    /*
      lambda是一个匿名函数,简化匿名内部类语法,可以把匿名函数当做参数传递,由java进行推断
    */
    public void show1(Demo demo){
        demo.show();
    }
    public static void main(String[] args) {
       TestDemo testDemo= new TestDemo();
       testDemo.show1(()->{
           System.out.println("无返回值");
       });
    }
}

示例2:有参有返回值

@FunctionalInterface
public interface Demo1 {
    int sun(int a,int b);
}



public class TestDemo1 {
    public void sum(Demo1 demo1) {
        System.out.println(demo1.sun(1, 2));
    }
    public static void main(String[] args) {
        TestDemo1 testDemo1 = new TestDemo1();
        testDemo1.sum((a, b) -> {
            return a + b;
        });
    }
}

Stream流

定义

与输入输出流不同，该流提供了对对象数据集合进行操作的各种方法，只需要声明告诉如何操作即可，是一个对集合及逆行遍历操作的高级迭代器

获取流的常用方法

使用 Arrays 中的 stream() 方法，将数组转成流

Arrays.stream(数组);

使用 Stream 中的静态方法：of()

Stream stream = Stream.of(1,2,3,4,5,6);

中间操作

filter()：过滤流中的某些元素, sorted(): 自然排序，流中元素需实现 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

示例1

import java.util.Arrays;

public class Demo1 {
    public static void main(String[] args) {
        /*
           Stream流 中提供了对对象数据集合进行操作的各种方法只需要声明式的告诉如何操作
                    一个对集合进行便利操作的高级迭代器
        */
        int [] a={1,3,4,4,2,3,8,5,7,8};
        Arrays.stream(a)//转换为流
               .distinct()//去重
               .sorted()//排序
                .filter((c)->{ return c>3; })//过滤
                .limit(3)//取出的个数
                .skip(1)//跳过的个数
               .forEach((e)-> System.out.println(e));//遍历
    }
}

示例2

import java.util.Arrays;

public class Demo2 {
    public static void main(String[] args) {
        Integer[] integers={1,3,4,2,6,7,0,9};
        System.out.println(Arrays.stream(integers).count());//返回处理后的数据个数
        System.out.println(Arrays.stream(integers)
                .max((a,b)->{return a-b;})//获取流中的最大值
                .get());//获得最终数据
        System.out.println( Arrays.stream(integers)
                .reduce((a,b)->{return a+b;})//求和
                .get());
        System.out.println(Arrays.stream(integers)
                .anyMatch((a)->{return a==1;}));//判断流数据中是否含有1
        System.out.println(Arrays.stream(integers)
                .allMatch((a)->{return a==1;}));//判断流数据中是否全是1
    }
}

示例3

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Demo3 {
    public static void main(String[] args) {
        Car car=new Car(1, "特斯拉"," 粉色");
        Car car1=new Car(2, "特斯拉1"," 绿色");
        Car car2=new Car(3, "特斯拉2"," 黑色");
        Car car3=new Car(4, "特斯拉3"," 金色");
        Car []cars={car2,car1,car3,car};
        List<Car> list=Arrays.stream(cars)
                .sorted((a,b)->{return a.getNum()-b.getNum();})//排序
                .collect(Collectors.toList());
        System.out.println(list);
        List<String> list1=Arrays.stream(cars)
                .map(Car::getColor)//映射成一个新的元素
                .collect(Collectors.toList());
        System.out.println(list1);
        Map<Integer,String> map=Arrays.stream(cars)
                .collect(Collectors.toMap(Car::getNum,Car::getName));//转换为map集合
        System.out.println(map);
    }
}



public class Car {
    private int num;
    private String name;
    private  String color;

    public Car(int num, String name, String color) {
        this.num = num;
        this.name = name;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Car{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}