Student

import java.io.Serializable;
import java.util.Objects;

public class Student implements Serializable {

    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;
    }

    @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);
    }
    
    //省略setter/getter。。。
}

使用场景

过滤

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);

//筛选年龄大于15岁的学生
List <Student> stuList = students.stream()
                                 .filter(s -> s.getAge()>15)
                                 .collect(Collectors.toList());
//筛选住在浙江省的学生
List<Student> stuList2 = students.stream()
                                 .filter(s -> "浙江".equals(s.getAddress()))
                                 .collect(Collectors.toList());

转换

.map

map: 对于Stream中包含的元素使用给定的转换函数进行转换操作，新生成的Stream只包含转换生成的元素。这个方法有三个对于原始类型的变种方法，分别是：mapToInt，mapToLong和mapToDouble。这三个方法也比较好理解，比如mapToInt就是把原始Stream转换成一个新的Stream，这个新生成的Stream中的元素都是int类型。之所以会有这样三个变种方法，可以免除自动装箱/拆箱的额外消耗；

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);

//获取地址集合
List<String> addresses1 = students.stream()
                                 .map(Student::getAddress)
                                 .collect(Collectors.toList());

//在地址前面加上部分信息，只获取地址输出
List<String> addresses = students.stream()
                                 .map(s -> "住址:" + s.getAddress())
                                 .collect(Collectors.toList());

//获取的地址以逗号隔开拼成字符串
String addresses2 = students.stream()
                            .map(Student::getAddress)
                            .collect(Collectors.joining(","));

//集合以逗号隔开拼成字符串
String addresses3 = StringUtils.join(addresses1.toArray(), ",");

.mapToLong

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);

//年龄求和
int sum = students.stream().mapToLong(Student::getAge).sum();

.collect

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(4L, "李淳风", 17, "浙江");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.add(s5);

//键相同，新的值不会覆盖旧的值
Map<Long, String> map1 = students.stream()
	.collect(Collectors.toMap(Student::getId, Student::getName, 
                              (oldVal, newVal) -> oldVal));

//键相同，新的值会覆盖旧的值
Map<Long, String> map2 = students.stream()
    .collect(Collectors.toMap(Student::getId, Student::getName, 
                              (oldVal, newVal) -> newVal));

Map<String, String> map = new HashMap<>();
map.put("a", "路飞1");
map.put("b", "索隆23");
map.put("c", "三治456");
map.put("d", "布鲁克7890");
//获取新的map，值为原来值的长度
Map<String, Integer> map2 = map.entrySet().stream()
    .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().length()));

//获取新的map，值为原来值的长度
Map<String, Integer> map3 = map.entrySet().stream()
    		.collect(HashMap::new, (m, v) 
             -> m.put(v.getKey(), v.getValue().length()), 
             HashMap::putAll);

去重

基本类型

//简单字符串的去重
List<String> list = Arrays.asList("111", "222", "333", "111", "222");
list.stream().distinct().forEach(System.out::println);

集合

//引用对象的去重，引用对象要实现hashCode和equal方法，否则去重无效
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> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.add(s5);

List <Student> students2 = students.stream().distinct().collect(Collectors.toList());

排序

默认排序

List<String> list = Arrays.asList("333", "222", "111");
list.stream().sorted().forEach(System.out::println);

指定排序规则

Student s1 = new Student(1L, "肖战", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 14, "浙江");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);

// 按id和年龄倒序排列
students.stream()
        .sorted((stu1, stu2) -> Long.compare(stu2.getId(), stu1.getId()))
        .sorted((stu1, stu2) -> Integer.compare(stu2.getAge(), stu1.getAge()))
        .collect(Collectors.toList());

students.stream()
    // 按年龄升序排序，相同年龄按id降序排序
    .sorted((stu1, stu2) -> Long.compare(stu2.getId(), stu1.getId()))
    .sorted(Comparator.comparingInt(Student::getAge))
    .forEach(System.out::println);

students.stream()
    // 按年龄升序排序，相同年龄按id降序排序
    .sorted(Comparator.comparingLong(Student::getId).reversed())
    .sorted(Comparator.comparingInt(Student::getAge))
    .forEach(System.out::println);

students.stream()
    // 按年龄升序排序，相同年龄按id升序排序
    .sorted(Comparator.comparingInt(Student::getAge).thenComparingLong(Student::getId))
    .forEach(System.out::println);

students.stream()
    // 按年龄升序排序，相同年龄按id升序排序，反向取值，即按年龄排序，年龄相同按id升序
    .sorted(Comparator.comparingInt(Student::getAge)
            .reversed()
            .thenComparingLong(Student::getId)
            .reversed())
    .forEach(System.out::println);

截取

截取前N个

//集合limit，返回前几个元素
List<String> list = Arrays.asList("333", "222", "111");
list.stream().limit(2).forEach(System.out::println);

跳过前N个

//集合skip，删除前n个元素
List<String> list = Arrays.asList("333", "222", "111");
list.stream().skip(2).forEach(System.out::println);

聚合

//集合reduce,将集合中每个元素聚合成一条数据
List<String> list = Arrays.asList("欢", "迎", "你");
String appendStr = list.stream().reduce("北京", (a, b) -> a + b);

极值

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(Comparator.comparingInt(Student::getAge))
                       .orElse(new Student(0L, null, 0, null));

匹配

anyMatch：Stream 中任意一个元素符合传入的 predicate，返回 true
allMatch：Stream 中全部元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

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("没有叫杨洋的同学");
}

分组

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(5L, "肖战", 17, "浙江");
Student s6 = new Student(6L, "肖战", 15, "浙江");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.add(s5);
students.add(s6);

// 按照姓名和年龄分组
Map<String, Map<Integer, List<Student>>> groupMap = students.stream()
    .collect(Collectors.groupingBy(Student::getName, Collectors.groupingBy(Student::getAge)));

结果如下：

{
    "肖战": {
        "15": [
            {
                "address": "浙江",
                "age": 15,
                "id": 1,
                "name": "肖战"
            },
            {
                "address": "浙江",
                "age": 15,
                "id": 6,
                "name": "肖战"
            }
        ],
        "17": [
            {
                "address": "浙江",
                "age": 17,
                "id": 5,
                "name": "肖战"
            }
        ]
    }
    ...
}