Java8新特性Stream 和lambda 表达式

深碍√TFBOYSˉ_ 2023-06-30 02:19 30阅读 0赞

## **Java8新特性Stream 和lambda 表达式** ##

**一：Java8新特性**  
接口默认方法，lambda 表达式 ，函数式接口，Date API 等特性  
**Stream**  
作为java8 的新特性，基于lambda表达式，是对集合对象功能的增强，它专注于对集合对象进行各种高效，遍历的聚合操作或者大批量的数据操作  
**Stream原理：**  
将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包括过滤，筛选，去重，排序，聚合，元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果  
**集合有两种方式生成流：**  
stream() — 为集合创建串行流  
parallelStream()—为集合创建并行流

主要针对集合的 去重、筛选、转换、排序、limit 限制返回个数、  
skip（删除元素）,删除前n 个元素、reduce 聚合 将集合中的每个元素聚合成一条数据、求最小值 min、anyMatch/allMatch/noneMatch(匹配)  
**二：案例**\`

/**
    * Created by 10393 on 2020/1/13.
    */
    public class Student {
        
    
    private Long id;
    private String name;
    private int age;
    private String address;
    
    public Student() {
        
    }
    
    public Student(Long id, String name, int age, String address) {
        
    this.id = id;
    this.name = name;
    this.age = age;
    this.address = address;
    }
    
    public Long getId() {
        
    return id;
    }
    
    public void setId(Long id) {
        
    this.id = id;
    }
    
    public String getName() {
        
    return name;
    }
    
    public void setName(String name) {
        
    this.name = name;
    }
    
    public int getAge() {
        
    return age;
    }
    
    public void setAge(int age) {
        
    this.age = age;
    }
    
    public String getAddress() {
        
    return address;
    }
    
    public void setAddress(String address) {
        
    this.address = address;
    }
    
    @Override
    public String toString() {
        
    return "Student{" +
    "id=" + id +
    ", name='" + name + '\'' +
    ", age=" + age +
    ", address='" + address + '\'' +
    '}';
    }
    
    @Override
    public boolean equals(Object o) {
        
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age &&
    Objects.equals(id, student.id) &&
    Objects.equals(name, student.name) &&
    Objects.equals(address, student.address);
    
    }
    
    @Override
    public int hashCode() {
        
    return Objects.hash(id, name, age, address);
    }
    }
    
    ```java
    /**
    * Created by 10393 on 2020/1/13.
    */
    public class Test {
        
    
    
    public static void main(String[] args) {
        
    Student s1 = new Student(1L, "肖战", 15, "浙江");
    Student s2 = new Student(2L, "王一博", 15, "湖北");
    Student s3 = new Student(3L, "杨紫", 17, "北京");
    Student s4 = new Student(4L, "李现", 17, "浙江");
    Student s5 = new Student(1L, "肖战", 15, "浙江");
    List<Student> stuList = new ArrayList<Student>();
    
    stuList.add(s1);
    stuList.add(s2);
    stuList.add(s3);
    stuList.add(s4);
    stuList.add(s5);
    //去重
    // stuList.stream().distinct().forEach(System.out::println);
    
    
    List<Student> streamStudents = testFilter(stuList);
    streamStudents.forEach(System.out::println);//遍历打印输出
    testMap(stuList);
    testDistinct1();
    testSort1();
    testSort2();
    testLimit();
    testReduce();
    testMin();
    testMatch();
    }
    
    /*
    * 集合的筛选
    * */
    private static List<Student> testFilter(List<Student> students){
        
    //筛选年龄大于15岁的学生
    return students.stream().filter(s ->s.getAge()>15).collect(Collectors.toList());
    //筛选在浙江省的同学
    // return students.stream().filter(s->"浙江".equals(s.getAddress())).collect(Collectors.toList());
    }
    /*
    * 集合转换
    * */
    private static void testMap(List<Student> students){
        
    List<String> addressess=students.stream().map(s->"住址："+s.getAddress()).collect(Collectors.toList());
    addressess.forEach(a->System.out.println(a));
    }
    /*
    * 集合去重（基本类型）
    * */
    private static void testDistinct1(){
        
    //简单字符串的去重
    List<String> list= Arrays.asList("111","222","333","444","111");
    list.stream().distinct().forEach(System.out::println);
    }
    /*
    * 集合排序（默认排序）
    * */
    private static void testSort1(){
        
    List<String> list=Arrays.asList("333","222","111");
    list.stream().sorted().forEach(System.out::println);
    
    }
    
    /*
    *
    * 上面指定排序规则，先按照学生的id进行降序排序，再按照年龄进行降序排序
    * */
    private static void testSort2(){
        
    Student s1 = new Student(1L, "肖战", 15, "浙江");
    Student s2 = new Student(2L, "王一博", 15, "湖北");
    Student s3 = new Student(3L, "杨紫", 17, "北京");
    Student s4 = new Student(4L, "李现", 17, "浙江");
    List<Student> students = new ArrayList<>();
    students.add(s1);
    students.add(s2);
    students.add(s3);
    students.add(s4);
    
    students.stream()
    .sorted((stu1,stu2) ->Long.compare(stu2.getId(),stu1.getId()))
    .sorted((stu1,stu2) ->Integer.compare(stu2.getAge(),stu1.getAge()))
    .forEach(System.out::println);
    }
    
    
    /*
    * limit 限制返回个数
    * */
    private static void testLimit(){
        
    List<String> list=Arrays.asList("333","222","111");
    list.stream().limit(2).forEach(System.out::println);
    }
    
    /*
    *
    * skip（删除元素）,删除前n 个元素
    * */
    private static void testSkip(){
        
    List<String> list=Arrays.asList("333","222","111");
    list.stream().skip(2).forEach(System.out::println);
    }
    
    /*
    * reduce 聚合 将集合中的每个元素聚合成一条数据
    * */
    
    private static void testReduce(){
        
    List<String> list=Arrays.asList("欢","迎","你");
    String appendStr=list.stream().reduce("北京",(a,b)->a+b);
    System.out.println("=="+appendStr);
    }
    
    /*
    * 求最小值 min
    * */
    private static void testMin(){
        
    Student s1 = new Student(1L, "肖战", 14, "浙江");
    Student s2 = new Student(2L, "王一博", 15, "湖北");
    Student s3 = new Student(3L, "杨紫", 17, "北京");
    Student s4 = new Student(4L, "李现", 17, "浙江");
    List<Student> students = new ArrayList<>();
    students.add(s1);
    students.add(s2);
    students.add(s3);
    students.add(s4);
    Student mins= students.stream().min((stu1,stu2)->Integer.compare(stu1.getAge(),stu2.getAge())).get();
    System.out.println(mins.toString());
    }
    
    /*
    * anyMatch/allMatch/noneMatch(匹配)
    *
    * */
    private static void testMatch(){
        
    Student s1 = new Student(1L, "肖战", 15, "浙江");
    Student s2 = new Student(2L, "王一博", 15, "湖北");
    Student s3 = new Student(3L, "杨紫", 17, "北京");
    Student s4 = new Student(4L, "李现", 17, "浙江");
    List<Student> students = new ArrayList<>();
    students.add(s1);
    students.add(s2);
    students.add(s3);
    students.add(s4);
    Boolean anyMatch=students.stream().anyMatch(s->"湖北".equals(s.getAddress()));
    if(anyMatch){
        
    System.out.println("有湖北人");
    }
    Boolean allMatch=students.stream().allMatch(s->s.getAge()>=15);
    if (allMatch){
        
    System.out.println("所有学生都满15岁");
    }
    Boolean noneMatch=students.stream().noneMatch(s->"杨洋".equals(s.getName()));
    if(noneMatch){
        
    System.out.println("没有叫杨洋的同学");
    }
    }
    }