Stream流的用法

已于 2024-02-26 16:05:12 修改
阅读量384 收藏 9
点赞数 9
分类专栏： # 便捷开发区 # 学习区 文章标签： java 开发语言 idea spring boot 后端
于 2024-01-09 23:06:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59690068/article/details/135490102
版权

目录

1.遍历输出list

2.遍历输出对象

3.遍历对象--将某个字段设成我们指定的值

4.遍历对象--遍历到了我们要的值就改变里面的属性

5.过滤-我们只要18岁以上的人

6.去重--去除完全相同的数据

7.去重--根据username来去重

8.统计

9.截取--我们只需要多少条记录，我们自己定

10.排序操作

11.指定排序操作

12.判断

判断是否有超过24岁的人，只要有一个就返回true

判断是否全部的人都超过24岁的人，只要有一个不是就返回false

判断是否全部的人都不超过24岁的人，只要有一个超过就返回false

13.将对象的中的某个字段变成集合

14.获取年龄最大的人和年龄最小的人

15.获取所有年龄最大的人和所有年龄最小的人

16.自定义排序-根据名字自定义排序

17.根据visit字段来排序降序排序（大到小），然后取前面5个数据

18.分组-当从数据库判断如果type=**，就加入到对应的list里面

1.遍历输出list

package com.lpc.Test;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author lpc
 * @Date 2024 01 09 20 34
 **/
public class Stream {

    //System.out.println()  快捷键：sout
    @Test
    public void  list() {
        List<String> list = new ArrayList<>();
        list.add("炭治郎");
        list.add("伊之助");
        list.add("善逸");
        list.stream().forEach(s -> System.out.println("value:"+s));
    }


}

2.遍历输出对象

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

package com.lpc.Test;

import com.lpc.entity.Users;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author lpc
 * @Date 2024 01 09 20 34
 **/
public class Stream {

    //System.out.println()  快捷键：sout
   
    @Test
    public void Users(){
        List<Users> userList=new ArrayList<>();
        userList.add(new Users(1, "user1", "password1"));
        userList.add(new Users(2, "user2", "password2"));
        userList.add(new Users(3, "user3", "password3"));

        userList.stream().forEach(users -> System.out.println(users));
    }



}

结果

3.遍历对象--将某个字段设成我们指定的值

@Test
    public void Users(){
        List<Users> userList=new ArrayList<>();
        userList.add(new Users(1, "user1", "password1"));
        userList.add(new Users(2, "user2", "password2"));
        userList.add(new Users(3, "user3", "password3"));

        //将密码统一改成520
        userList.stream().forEach(users -> users.setPassword("520"));
        //遍历输出
        userList.stream().forEach(users -> System.out.println(users));


    }

结果：

4.遍历对象--遍历到了我们要的值就改变里面的属性

 Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

package com.lpc.Test;

import com.lpc.entity.Users;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author lpc
 * @Date 2024 01 09 20 34
 **/
public class Stream {

    //System.out.println()  快捷键：sout
   
    @Test
    public void Users2(){
        List<Users> userList=new ArrayList<>();
        userList.add(new Users(1, "user1", "password1"));
        userList.add(new Users(2, "user2", "password2"));
        userList.add(new Users(3, "user3", "password3"));

       //遍历到了id=2,就把它的username改成：炭治郎
        userList.stream().forEach(users -> {
            if (users.getId().equals(2)){
                users.setUsername("炭治郎");
            }
        });

        userList.stream().forEach(users -> System.out.println(users));
    }



}

结果

5.过滤-我们只要18岁以上的人

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

@Test
    public void Users2(){
        List<Users> userList=new ArrayList<>();
        userList.add(new Users(1, "user1", "password1",25));
        userList.add(new Users(2, "user2", "password2",17));
        userList.add(new Users(3, "user3", "password3",19));

       //过滤掉18岁以下的
       List<Users> newUserList=userList.stream().filter(users -> users.getAge()>=18).collect(Collectors.toList());
        System.out.println(newUserList);

    }

6.去重--去除完全相同的数据

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

 @Test
    public void Users3(){
        List<Users> userList=new ArrayList<>();
        userList.add(new Users(1, "user1", "password1",25));
        userList.add(new Users(2, "user2", "password2",17));
        userList.add(new Users(3, "user3", "password3",19));
        userList.add(new Users(3, "user3", "password3",19));
        userList.add(new Users(3, "user3", "password3",19));
        userList.add(new Users(3, "user3", "password3",19));
        
        //去除完全相同的数据
       userList=userList.stream().distinct().collect(Collectors.toList());
        System.out.println(userList);


    }

7.去重--根据username来去重

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

 @Test
    public void Users4(){
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user3", "password3", 19)); // 重复记录
        userList.add(new Users(5, "user3", "password3", 19)); // 重复记录
        userList.add(new Users(6, "user3", "password3", 19)); // 重复记录

        //根据username去重
        List<Users> userList2=userList.stream().collect(
                Collectors.collectingAndThen(Collectors.toCollection(
                        () -> new TreeSet<>(Comparator.comparing(users -> users.getUsername()))), ArrayList::new)
        );

        System.out.println(userList2);
    }

8.统计

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

 @Test
    public void Users6(){
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 19)); // 重复记录
        userList.add(new Users(5, "user5", "password5", 19)); // 重复记录
        userList.add(new Users(6, "user6", "password6", 19)); // 重复记录

        //统计
        Long count=userList.stream().count();
        System.out.println( count);
    }

9.截取--我们只需要多少条记录，我们自己定

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

 @Test
    public void Users7(){
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 19)); // 重复记录
        userList.add(new Users(5, "user5", "password5", 19)); // 重复记录
        userList.add(new Users(6, "user6", "password6", 19)); // 重复记录

        //只需要前三条数据
        userList=userList.stream().limit(3).collect(Collectors.toList());
        System.out.println(userList);
    }

10.排序操作

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

@Test
    public void Users8() {
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 18));
        userList.add(new Users(5, "user5", "password5", 19)); 
        userList.add(new Users(6, "user6", "password6", 20)); 
        //根据年龄从小到大排序
        userList = userList.stream().sorted(Comparator.comparing(Users::getAge)).collect(Collectors.toList());
        System.out.println(userList);

        System.out.println("--------------------------------------------------------------");
        //根据年龄从大到小排序
        List<Users> users = userList.stream().sorted(Comparator.comparing(Users::getAge).reversed()).collect(Collectors.toList());

        System.out.println(users);
    }

11.指定排序操作

12.判断

判断是否有超过24岁的人，只要有一个就返回true

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

 @Test
    public void Users9() {
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 18)); // 重复记录
        userList.add(new Users(5, "user5", "password5", 19)); // 重复记录
        userList.add(new Users(6, "user6", "password6", 20)); // 重复记录

        //判断userList里面是否有超过24的人，只要有一个就返回true
        boolean flag=userList.stream().anyMatch(users -> users.getAge()>=24);
        System.out.println(flag);
    }

判断是否全部的人都超过24岁的人，只要有一个不是就返回false

@Test
    public void Users10() {
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 18)); // 重复记录
        userList.add(new Users(5, "user5", "password5", 19)); // 重复记录
        userList.add(new Users(6, "user6", "password6", 20)); // 重复记录

        //判断userList里面是否有超过24的人，只要有一个就返回true
        boolean flag=userList.stream().allMatch(users -> users.getAge()>=24);
        System.out.println(flag);
    }

判断是否全部的人都不超过24岁的人，只要有一个超过就返回false

@Test
    public void Users10() {
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 18)); // 重复记录
        userList.add(new Users(5, "user5", "password5", 19)); // 重复记录
        userList.add(new Users(6, "user6", "password6", 20)); // 重复记录

        //判断userList里面是否有超过24的人，只要有一个就返回true
        boolean flag=userList.stream().noneMatch(users -> users.getAge()>=24);
        System.out.println(flag);
    }

13.将对象的中的某个字段变成集合

Users

package com.lpc.entity;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * @Author lpc
 * @Date 2024 01 08 10 24
 **/

@Data //简化实体类，get,set,构造都有了
@AllArgsConstructor
public class Users {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

}

AllArgsConstructor 是 lombok 提供的一个注解，它可以为类生成一个包含所有字段的构造函数。使用 @AllArgsConstructor 注解，你就不需要手动编写构造函数，lombok 会自动生成一个构造函数，并将所有字段作为参数。

依赖

 <!--Lombok 是一个开发工具，可以通过注解自动化生成 Java 代码中的一些样板代码，
        如 getter、setter、构造函数等，减少了编写冗余代码的工作量。-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
<properties>
        <!--依赖版本控制-->
        <lombok.version>1.18.16</lombok.version>
    </properties>

Test

 @Test
    public void Users11() {
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 18)); // 重复记录
        userList.add(new Users(5, "user5", "password5", 19)); // 重复记录
        userList.add(new Users(6, "user6", "password6", 20)); // 重复记录

        //将对象的中的某个字段变成集合
        List<String> nameList=userList.stream().map(users -> users.getUsername()).collect(Collectors.toList());
        // System.out.println();  快捷键：sout
        System.out.println(nameList);

    }

14.获取年龄最大的人和年龄最小的人

问题：我这样写只能查出一个人，有相同的最大年龄，相同的最小年龄不能都查出来

 @Test
    public void Users16() {
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 19));
        userList.add(new Users(4, "user4", "password4", 18));
        userList.add(new Users(5, "user5", "password5", 17));
        userList.add(new Users(6, "user6", "password6", 20));
        //获取年龄最大的
        Users user=userList.stream().max(Comparator.comparing(Users::getAge)).get();
        System.out.println(user);

        //获取年龄最小的
        Users user2=userList.stream().min(Comparator.comparing(Users::getAge)).get();
        System.out.println(user2);

       

    }

15.获取所有年龄最大的人和所有年龄最小的人

 @Test
    public void Users16() {
        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 25));
        userList.add(new Users(4, "user4", "password4", 18));
        userList.add(new Users(5, "user5", "password5", 17));
        userList.add(new Users(6, "user6", "password6", 20));
        // 获取年龄最大的所有人
        int maxAge = userList.stream().max(Comparator.comparing(Users::getAge)).get().getAge();
        List<Users> oldestUsers = userList.stream().filter(u -> u.getAge() == maxAge).collect(Collectors.toList());
        System.out.println("年龄最大的人：");
        oldestUsers.forEach(System.out::println);

        // 获取年龄最小的所有人
        int minAge = userList.stream().min(Comparator.comparing(Users::getAge)).get().getAge();
        List<Users> youngestUsers = userList.stream().filter(u -> u.getAge() == minAge).collect(Collectors.toList());
        System.out.println("年龄最小的人：");
        youngestUsers.forEach(System.out::println);

    }

`System.out::println` 是 Java 8 中引入的方法引用（Method Reference）的语法。它表示对 `System.out.println` 方法的引用。具体而言，`System.out.println` 是一个静态方法，用于将参数打印到控制台，并换行。通过 `System.out::println`，你可以在流的 `forEach` 方法中将每个元素传递给 `System.out.println` 方法。

在上述代码中，`System.out.println` 是通过方法引用的方式传递给 `forEach` 方法。这意味着对于流中的每个元素，将调用 `System.out.println` 方法，并将元素作为参数传递给该方法。这样可以方便地打印出流中的元素。

方法引用是一种简化 Lambda 表达式的方法，可以提高代码的可读性和简洁性。 `System.out::println` 是其中一种常见的用法，表示引用 `System.out` 对象的 `println` 方法。

16.自定义排序-根据名字自定义排序

@Test
    public void Users17() {

        List<Users> userList = new ArrayList<>();
        userList.add(new Users(1, "user1", "password1", 25));
        userList.add(new Users(2, "user2", "password2", 17));
        userList.add(new Users(3, "user3", "password3", 25));
        userList.add(new Users(4, "user4", "password4", 18));
        userList.add(new Users(5, "user5", "password5", 17));
        userList.add(new Users(6, "user6", "password6", 20));

        List<String> nameList = Arrays.asList("user1","user3","user2","user4","user5","user6");
        userList =userList.stream().sorted(Comparator.comparing(Users::getUsername,(x, y)->
                {
                    for (String name : nameList) {
                        if (name.equals(x) || name.equals(y)) {
                            if (x.equals(y)) {
                                return 0;
                            } else if (name.equals(x)) {
                                return -1;
                            } else {
                                return 1;
                            }
                        }
                    }
                    return 0;
                })).

                collect(Collectors.toList());

        System.out.println("value:"+userList);

    }

17.根据visit字段来排序降序排序（大到小），然后取前面5个数据

 List<YcFile> sortedAndLimitedList = ycFileList.stream()
                .sorted(Comparator.nullsLast(Comparator.comparingLong(YcFile::getVisit).reversed()))
                //给出前5条阅读量最多的文件
                .limit(5)
                .collect(Collectors.toList());
  1. ycFileList.stream()将ycFileList转换为一个流。
  2. sorted(Comparator.nullsLast(Comparator.comparingLong(YcFile::getVisit).reversed()))对流中的元素进行排序，首先使用Comparator.nullsLast对空值进行处理，然后使用Comparator.comparingLong(YcFile::getVisit)按照YcFile对象的visit属性进行升序排序，最后使用reversed()将排序结果反转，即按照降序排序。
  3. limit(5)限制只取前5条元素。
  4. collect(Collectors.toList())将流中的元素收集到一个新的List中，并将结果赋值给sortedAndLimitedList变量。
  5. 最终，sortedAndLimitedList中存储的是ycFileList中阅读量最多的前5个文件。

18.分组-当从数据库判断如果type=**，就加入到对应的list里面

@Test
    public void add(){
        // 创建一个包含多个元素的type数组
        Integer[] typeArray = {1, 2, 3, 1, 2, 3};

        List<Integer> typeList = new ArrayList<>(Arrays.asList(typeArray));

        List<Integer> oneList = new ArrayList<>();
        List<Integer> twoList = new ArrayList<>();
        List<Integer> threeList = new ArrayList<>();

        // 使用switch对类型进行判断并添加到相应的列表中
        typeList.forEach(type -> {
            switch (type) {
                case 1:
                    oneList.add(type);
                    break;
                case 2:
                    twoList.add(type);
                    break;
                case 3:
                    threeList.add(type);
                    break;
                default:
                    // 处理其他类型的情况
                    break;
            }
        });

        // 打印结果
        System.out.println("oneList: " + oneList);
        System.out.println("twoList: " + twoList);
        System.out.println("threeList: " + threeList);
    }

君子善假于物也
关注
专栏目录
Stream流使用方法
leader0520的博客
03-07 411
Stream流使用方法 Stream 是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。Stream是元素的集合，这点让Stream看起来用些类似Iterator。可以支持顺序和并行的对原Stream进行汇聚的操作。 1.创建stram() Collection.stream(),通过Stream接口的静态工厂方法创建stre...
Stream流常用方法
12-22
以下将详细介绍从标题和描述中提及的Stream流的常用方法： 1. **获取Stream流** - **从Collection获取**：所有实现了`Collection`接口的类（如`List`, `Set`, `Queue`等）都提供了`stream()`方法，用于将集合转换...
Stream语法
SeanTandol的博客
01-25 1150
文章目录Stream语法解析创建Stream转换Stream聚合StreamStream相对于迭代器和循环的效率 Stream语法解析 //Lists是Guava中的一个工具类 List&amp;amp;lt;Integer&amp;amp;gt; nums = Lists.newArrayList(1,null,3,4,null,6); nums.stream().filter(num -&amp;amp;gt; num != null).c...
stream语法
lannal_w
03-08 402
List&lt;Supplier&gt; uniqueSuppliers = supplierList.stream().collect( collectingAndThen( toCollection(() -&gt; new TreeSet&lt;&gt;(comparing(Supplier::getSupplierId))), ArrayLi...
Stream语法详解
yiye2017zhangmu的博客
09-06 207
学习转载：https://blog.csdn.net/youzhouliu/article/details/51820088 后面实践过程中再写心得.
Stream流常用语法及实际问题汇总
HSH541的博客
07-06 171
Stream：分组
【Java】Java8 之Stream用法总结（持续更新）
慕白Lee的博客
04-23 1万+
Java8 之Stream用法总结
Java Stream 流实现合并操作示例
08-19
在上面的示例中，我们使用 concat 方法将两个 Stream 流合并成一个流，然后将其收集到一个列表中。 多个流的合并 如果我们需要合并多个流，可以使用 concat 方法进行“套娃操作”，例如： ```java Stream...
简单总结Java IO中stream流的使用方法
09-02
Java IO中的Stream流是Java语言进行输入输出操作的核心机制。它以“流”的方式处理数据，使得数据的传输变得简单且高效。Stream流分为两种主要...理解并熟练掌握流的使用方法，是成为一名合格的Java开发者的必备技能。
Java Stream流知识总结
08-19
"Java Stream流知识总结...3. 并发编程：Stream流可以用于并发编程，例如使用parallelStream()方法来并发处理数据。 Java Stream流是一种非常有用的编程模型，能够简洁地体现代码的逻辑，提高代码的执行效率和可读性。
Java 打印流（PrintStream，PrintWriter）详细解析！
m0_51517626的博客
08-31 442
打印流（PrintStream，PrintWriter） 概述 PrintStream，Printwriter提供了一系列重载的print()方法和println()方法用于输出，可以在System.out时设置其对象，使得其不输出在控制台上，输出到文件中 使用 使用打印流对sout重定向 public static void main(String[] args) { PrintStream ps = null; FileOutputStream fos = null; try {
Java 8系列之Stream的基本语法详解
热门推荐
行云间
02-10 7万+
概述继Java 8系列之Lambda表达式之后，我们来了解Stream。Stream 是用函数式编程方式在集合类上进行复杂操作的工具，其集成了Java 8中的众多新特性之一的聚合操作，开发者可以更容易地使用Lambda表达式，并且更方便地实现对集合的查找、遍历、过滤以及常见计算等。聚合操作为了学习聚合的使用，在这里，先定义一个数据类：public class Student { int no
java8 Stream语法详解
weixin_33738555的博客
07-19 2622
些Stream的例子可能让你产生疑惑，本文将会详细讲解Stream的使用方法（不会涉及Stream的原理，因为这个系列的文章还是一个快速学习如何使用的）。 1. Stream初体验 我们先来看看Java里面是怎么定义Stream的： A sequence of elements supporting sequential and parallel aggregate operations...
stream流对象的理解及使用
了迹奇有没
02-17 1054
我的理解：用stream流式处理数据，将数据用一个一个方法去 . （点，即调用） 得到新的数据结果，可以一步达成。 有多种方式生成 Stream Source： 从 Collection 和数组 Collection.stream() Collection.parallelStream() Arrays.stream(T array) or Stream.of() 从 Buffered...
Java8特性详解 lambda表达式 Stream
weixin_30802273的博客
09-27 1693
1.lambda表达式 Java8最值得学习的特性就是Lambda表达式和Stream API，如果有python或者javascript的语言基础，对理解Lambda表达式有很大帮助，因为Java正在将自己变的更高（Sha）级（Gua），更人性化。--------可以这么说lambda表达式其实就是实现SAM接口的语法糖。 lambda写的好可以极大的减少代码冗余，同时可读性也好过冗长的内部...
java将word转pdf
紫月7575的博客
09-30 492
java将word转pdf
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 687
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 504
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 778
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
stream流使用方法
09-21
Stream流的使用方法如下： 1. 创建流：可以通过集合、数组、IO等数据源创建Stream流。 2. 中间操作：Stream流支持多种中间操作，例如filter、map、sorted等，这些操作可以对流中的元素进行筛选、映射、排序等处理。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值