Java8中的stream的测试使用

Java8中的stream的测试使用

• 一、准备
• • [1、属性枚举类 PropertyEnum](#1、属性枚举类 PropertyEnum)
  • [2、人物实体 Character](#2、人物实体 Character)
  • 3、测试单元依赖
• [二、stream 对象](#二、stream 对象)
• • 1、中间操作
  • • （1）、filter
    • （2）、map
    • （3）、sorted
    • （4）、distinct
    • （5）、limit
    • （6）、skip
    • （7）、peek
  • 2、终止操作
  • • （1）、forEach
    • （2）、collect
    • （3）、reduce
    • （4）、allMatch
    • （5）、noneMatch
    • （6）、anyMatch
    • （7）、findFirst
    • （8）、findAny

一、准备

1、属性枚举类 PropertyEnum

/**
 * 属性枚举类
 *
 * @author：gan
 * @date: 2026-05-09 10:40
 */
public enum PropertyEnum {
    GOLD,
    WOOD,
    WATER,
    FIRE,
    EARTH;
}

2、人物实体 Character

import com.zsp.demo.exer.enums.PropertyEnum;

import java.util.List;

/**
 * 人物实体
 *
 * @author：gan
 * @date: 2026-05-09 10:38
 */
public class Character {
    //姓名
    private String name;

    //年龄
    private Integer age;

    //身高
    private Integer height;

    //属性
    private List<PropertyEnum> propertyList;

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Integer getHeight() {
        return height;
    }

    public void setHeight(Integer height) {
        this.height = height;
    }

    public List<PropertyEnum> getPropertyList() {
        return propertyList;
    }

    public void setPropertyList(List<PropertyEnum> propertyList) {
        this.propertyList = propertyList;
    }

    @Override
    public String toString() {
        return "Character{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                ", propertyList=" + propertyList +
                '}';
    }
}

3、测试单元依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>

二、stream 对象

1、中间操作

（1）、filter

filter：接收Lambda，从流中排除某些元素。

创建一个整形数组，在数组里面筛选出大于20的结果集：

@Test
public void testFilter() {
    List<Integer> ageList = Arrays.asList(18, 25, 25, 512);

    //筛选年龄大于20的List
    List<Integer> resultOneList = ageList.stream().filter(age -> age > 20).collect(Collectors.toList());
    System.out.println("resultOneList：" + resultOneList);
}

那要筛选集合中的元素怎么办，创建一个人物集合，筛选出年龄大于20岁的结果集：

@Test
public void testFilter() {
    List<Character> characterList = new ArrayList<>(3);

    Character lydia = new Character("lydia", 18, 170);
    Character judith = new Character("judith", 25, 168);
    Character serena = new Character("serena", 512, 166);

    characterList.add(lydia);
    characterList.add(judith);
    characterList.add(serena);

    //筛选年龄大于20的人物List
    List<Character> resultThreeList = characterList.stream().filter(character -> character.getAge() > 20).collect(Collectors.toList());
    for (Character character : resultThreeList) {
        System.out.println(character);
    }
}

（2）、map

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

创建一个整形数组，为每个整形后加上"岁"字：

@Test
public void testMap() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(18, 25, 25, 512);

    List<String> resultOneList = ageList.stream().map(age -> {
        return age + " 岁";
    }).collect(Collectors.toList());
    System.out.println("resultOneList：" + resultOneList);
}

为集合中的每个元素加上"1"

@Test
public void testMap() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(18, 25, 25, 512);

    List<Integer> resultTwoList = ageList.stream().map(age -> {
        return age + 1;
    }).collect(Collectors.toList());
    System.out.println("resultTwoList：" + resultTwoList);
}

在一个集合中筛选集合元素的某个属性组成新的集合，比如筛选人物集合中的名称组成字符串集合

@Test
public void testMap() {
    List<Character> characterList = new ArrayList<>(3);

    Character lydia = new Character("lydia", 18, 170);
    Character judith = new Character("judith", 25, 168);
    Character serena = new Character("serena", 512, 166);

    characterList.add(lydia);
    characterList.add(judith);
    characterList.add(serena);

    //第一种方式
    List<String> resultFiveList = characterList.stream().map(character -> character.getName()).collect(Collectors.toList());
    System.out.println("resultFiveList：" + resultFiveList);
}

这是以这种方式筛选

@Test
public void testMap() {
    List<Character> characterList = new ArrayList<>(3);

    Character lydia = new Character("lydia", 18, 170);
    Character judith = new Character("judith", 25, 168);
    Character serena = new Character("serena", 512, 166);

    characterList.add(lydia);
    characterList.add(judith);
    characterList.add(serena);

    //第二种方式
    List<String> resultSixList = characterList.stream().map(Character::getName).collect(Collectors.toList());
    System.out.println("resultSixList：" + resultSixList);
}

（3）、sorted

sorted：有两个重载方法，一个是不带参的，产生一个新流，其中按自然顺序排序；另一个带参的，产生一个新流，其中按比较器顺序排序。一般都是用带参的。

创建一个整形集合，将集合元素从小到大排列

@Test
public void testSorted() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //顺序排序
    List<Integer> resultOneList = ageList.stream().sorted().collect(Collectors.toList());
    System.out.println("resultOneList：" + resultOneList);

}

也可以用带参的 sorted 方法来替换，方式如下：

@Test
public void testSorted() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //顺序排序
    //方式二
    List<Integer> resultTwoList = ageList.stream().sorted((a, b) -> a - b).collect(Collectors.toList());
    System.out.println("resultTwoList：" + resultTwoList);
}

然后是倒序排序

@Test
public void testSorted() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //倒序排序
    //方式一
    List<Integer> resultThreeList = ageList.stream().sorted((a, b) -> b - a).collect(Collectors.toList());
    System.out.println("resultThreeList：" + resultThreeList);
}

这是第二种方式

@Test
public void testSorted() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //倒序排序
    //方式二
    List<Integer> resultFourList = ageList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
    System.out.println("resultFourList：" + resultFourList);
}

创建一个对象集合，安装年龄顺序排序

@Test
public void testSorted() {
    //对象集合
    List<Character> characterList = new ArrayList<>(3);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //按年龄顺序排序
    characterList = characterList.stream().sorted(Comparator.comparing(Character::getAge)).collect(Collectors.toList());

    for (Character character : characterList) {
        System.out.println(character);
    }
}

按照身高倒序排序

@Test
public void testSorted() {
    //对象集合
    List<Character> characterList = new ArrayList<>(3);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //按身高倒序排序
    characterList = characterList.stream().sorted(Comparator.comparing(Character::getHeight).reversed()).collect(Collectors.toList());

    for (Character character : characterList) {
        System.out.println(character);
    }
}

按照年龄和身高排序，以年龄为主

@Test
public void testSorted() {
    //对象集合
    List<Character> characterList = new ArrayList<>(3);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 177);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //按年龄和升高顺序排序，年龄为主
    characterList = characterList.stream().sorted(Comparator.comparing(Character::getAge).thenComparing(Character::getHeight)).collect(Collectors.toList());

    for (Character character : characterList) {
        System.out.println(character);
    }
}

年龄相同的时候才能看到效果。

（4）、distinct

distinct：筛选，通过流所生成元素的hashCode()和equals()去除重复元素。

创建一个基本数据类型的集合，对集合进行去重

@Test
public void testDistinct() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //对数据内容去重
    List<Integer> resultOneList = ageList.stream().distinct().collect(Collectors.toList());
    System.out.println("resultOneList：" + resultOneList);

}

对象集合中一般不会用 distinct 这个方法去重，这里演示一下对象集合的某个属性的去重方式

@Test
public void testDistinct() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //对集合中包含两个相同元素的数据进行去重，这里是年龄
    //方式一
    List<Character> characterTwoList = characterList.stream().collect(Collectors.toMap(Character::getAge, Function.identity(), ((exist, replace) -> exist)))
            .values()
            .stream()
            .collect(Collectors.toList());

    for (Character character : characterTwoList) {
        System.out.println(character);
    }
}

这是方式二

@Test
public void testDistinct() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //对集合中包含两个相同元素的数据进行去重，这里是年龄
    //方式二
    List<Character> characterThreeList = characterList.stream().collect(Collectors.collectingAndThen(
            Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Character::getAge))), ArrayList::new
    ));

    for (Character character : characterThreeList) {
        System.out.println(character);
    }
}

（5）、limit

limit：截断流,使其元素不超过给定数量。

创建一个基本数据类型的集合，限制输出3个元素

@Test
public void testLimit() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    List<Integer> resultOneList = ageList.stream().limit(3).collect(Collectors.toList());
    System.out.println("resultOneList：" + resultOneList);
}

对象集合中也是类似

@Test
public void testLimit() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    List<Character> resultTwoList = characterList.stream().limit(3).collect(Collectors.toList());

    for (Character character : resultTwoList) {
        System.out.println(character);
    }
}

（6）、skip

skip：跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与 limit(n)互补。

创建一个基本数据类型的集合，跳过第一个元素

@Test
public void testSkip() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //跳过前面第一个元素
    List<Integer> resultOneList = ageList.stream().skip(1).collect(Collectors.toList());
    System.out.println("resultOneList：" + resultOneList);
}

对象集合也是类似，创建对象集合，跳过前面两个元素

@Test
public void testSkip() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //跳过前面的两个对象
    List<Character> resultTwoList = characterList.stream().skip(2).collect(Collectors.toList());
    for (Character character : resultTwoList) {
        System.out.println("character：" + character);
    }
}

（7）、peek

peek：用于在Stream流中获取元素同时执行一些操作，如打印、调试、观察等。通常会与其他的方法联合使用。

创建一个基本数据类型集合，打印所有的元素

@Test
public void testPeek() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    ageList.stream().peek(System.out::println).collect(Collectors.toList());
}

创建一个对象集合，打印所有对象

@Test
public void testPeek() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //打印集合
    characterList.stream().peek(System.out::println).collect(Collectors.toList());
}

只打印每个对象的名称

@Test
public void testPeek() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //筛选集合元素中的name并打印
    characterList.stream().map(Character::getName).peek(System.out::println).collect(Collectors.toList());
}

为集合中的每个对象年龄加1，名称前加上"name："

@Test
public void testPeek() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //将集合中的name前面加上"name："，并且age+1再打印
    characterList.stream().peek(character -> {
        character.setAge(character.getAge() + 1);
        character.setName("name：" + character.getName());
    }).peek(System.out::println).collect(Collectors.toList());
}

2、终止操作

（1）、forEach

forEach：内部迭代(使用Collection接口需要用户去做迭代,称为外部迭代。相反，Stream API使用内部迭代------它帮你把迭代做了)

创建一个基本数据类型集合，打印所有的元素

@Test
public void testForEach() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //打印集合中的元素
    //方式一
    ageList.stream().forEach(System.out::println);
}

这是方式二

@Test
public void testForEach() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //打印集合中的元素
    //方式二
    ageList.stream().forEach(age -> System.out.println(age));
}

然后是对象集合，创建一个对象集合，循环打印每个元素，这是方式一

    @Test
    public void testForEach() {
        //对象集合
        List<Character> characterList = new ArrayList<>(5);

        Character judith = new Character("judith", 25, 168);
        judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

        Character lydia = new Character("lydia", 18, 170);
        lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

        Character serena = new Character("serena", 512, 166);
        serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

        Character raya = new Character("raya", 26, 172);
        raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

        Character sorin = new Character("sorin", 26, 172);
        sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

        characterList.add(judith);
        characterList.add(lydia);
        characterList.add(serena);
        characterList.add(raya);
        characterList.add(sorin);

        //打印集合中的元素，类似for循环，同样两种方式
        //方式一
        characterList.stream().forEach(System.out::println);
    }

这是方式二

@Test
public void testForEach() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //打印集合中的元素，类似for循环，同样两种方式
    //方式二
    characterList.stream().forEach(character -> System.out.println(character));
}

（2）、collect

collect：将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。这个方法一般与其他方法混着用。

创建一个基本类型数组，跳过第一个元素组成新的集合

@Test
public void testCollect() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //跳过第一个元素再将其余元素组成新的集合
    List<Integer> resultOneList = ageList.stream().skip(1).collect(Collectors.toList());
    System.out.println("resultOneList：" + resultOneList);

    System.out.println("ageList：" + ageList);
}

使用collect中实现去重

@Test
public void testCollect() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //将List集合转化为Set，就可以实现去重了
    Set<Integer> resultOneSet = ageList.stream().collect(Collectors.toSet());
    System.out.println("resultOneSet：" + resultOneSet);

    System.out.println("ageList：" + ageList);
}

创建一个对象集合，为每个元素的年龄加上1，体重加上2

@Test
public void testCollect() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    for (Character character : characterList) {
        System.out.println("原元素：" + character);
    }

    //将对象集合中的age+1、height+2后再转化为List集合
    List<Character> resultTwoList = characterList.stream().peek(character -> {
        character.setAge(character.getAge() + 1);
        character.setHeight(character.getHeight() + 2);
    }).collect(Collectors.toList());

    for (Character character : resultTwoList) {
        System.out.println(character);
    }
}

也可以利用collect方法对集合元素进行分组，比如将对象集合中同身高的元素进行分组

@Test
public void testCollect() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    Map<Integer, List<Character>> resultThreeMap = characterList.stream().collect(Collectors.groupingBy(Character::getHeight));
    for (Map.Entry<Integer, List<Character>> currentMap : resultThreeMap.entrySet()) {
        System.out.println("key：" + currentMap.getKey() + "，value：" + currentMap.getValue());
    }
}

（3）、reduce

reduce：有两个重载方法，第一个 T reduce(T identity, BinaryOperator accumulator); ，可以将流中元素反复结合起来，得到一个值，返回 T 。第二个 Optional reduce(BinaryOperator accumulator); ，可以将流中元素反复结合起来，得到一个值，返回 Optional 。

创建第一个基本数据类型集合，使用第一个方法将所有元素加起来

@Test
public void testReduce() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //将集合中所有的元素加起来
    //方式一
    Integer num1 = ageList.stream().reduce(0, Integer::sum);
    System.out.println(num1);
}

使用第二个重载方法将所有的集合元素加起来

@Test
public void testReduce() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //将集合中所有的元素加起来
    //方式二
    Optional<Integer> num2 = ageList.stream().reduce((first, second) -> first + second);
    System.out.println(num2.get());
}

也可以用第一个方法得到集合中的最大元素，第一个参数可以随便取一个集合中的元素，这里取第一个

@Test
public void testReduce() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //获得原集合与第一个参数组成的新集合中最大的元素，这里放集合的第一个元素
    //方式一
    Integer max = ageList.stream().reduce(ageList.get(0), Integer::max);
    System.out.println(max);
}

使用第二个方法得到最大值

@Test
public void testReduce() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //获得原集合与第一个参数组成的新集合中最大的元素，这里放集合的第一个元素
    //方式二
    Optional<Integer> max2 = ageList.stream().reduce((first, second) -> {
        return first >= second ? first : second;
    });
    System.out.println("max2：" + max2.get());
}

（4）、allMatch

allMatch：检查是否匹配所有元素。

创建一个基本数据类型集合，判断是否所有的元素都能整除5

@Test
public void testAllMatch() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //集合中所有的都能整除5就返回true，否则返回false
    boolean resultOneBoolean = ageList.stream().allMatch(age -> age % 5 == 0);
    System.out.println("resultOneBoolean：" + resultOneBoolean);
}

创建一个对象集合，判断是否所有元素的身高都不超过200

@Test
public void testAllMatch() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //集合中所有元素的height都小于200就返回true，否则返回false
    boolean resultTwoBoolean = characterList.stream().allMatch(character -> character.getHeight() < 200);
    System.out.println("resultTwoBoolean：" + resultTwoBoolean);
}

（5）、noneMatch

noneMatch：检查是否没有匹配所有元素。

创建一个基本类型集合，判断是否所有元素都能被7整除。

@Test
public void testNoneMatch() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    boolean resultOneBoolean = ageList.stream().noneMatch(age -> age / 7 == 0);
    System.out.println("resultOneBoolean：" + resultOneBoolean);
}

定义一个对象集合，判断集合中的元素的年龄是否存在大于1000的，没有就返回true

@Test
public void testNoneMatch() {
    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //集合中没有一个元素的age大于1000就返回true，否则返回false
    boolean resultTwoBoolean = characterList.stream().noneMatch(character -> character.getAge() > 1000);
    System.out.println("resultTwoBoolean：" + resultTwoBoolean);
}

（6）、anyMatch

anyMatch：检查是否至少匹配一个元素。

创建一个基本数据类型集合，判断集合中是否存在能被5整除的元素

@Test
public void testAnyMatch() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //集合中存在能被5整除的元素就返回true
    boolean resultOneBoolean = ageList.stream().anyMatch(age -> age % 5 == 0);
    System.out.println("resultOneBoolean：" + resultOneBoolean);
}

创建一个对象集合，判断集合中是否存在身高大于200的元素

@Test
public void testAnyMatch() {

    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    //集合中存在元素的身高大于200就返回true
    boolean resultTwoBoolean = characterList.stream().anyMatch(character -> character.getHeight() > 200);
    System.out.println("resultTwoBoolean：" + resultTwoBoolean);
}

（7）、findFirst

findFirst：返回第一个元素。

创建一个基本数据类型的集合，返回第一个元素。

@Test
public void testFindFirst() {
    //基本数据类型集合
    List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

    //就是拿集合中第一个元素
    Optional<Integer> resultOne = ageList.stream().findFirst();
    System.out.println("resultOne：" + resultOne.get());
}

对象集合也是一样

@Test
public void testFindFirst() {

    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    Optional<Character> resultTwo = characterList.stream().findFirst();
    System.out.println("resultTwo：" + resultTwo.get());
}

（8）、findAny

findAny：返回当前流中的任意元素。

虽然概念上说会返回流中任意元素，但是我试了很多次，它总是返回第一个元素。

这是基本数据类型集合

 @Test
 public void testFindAny() {
     //基本数据类型集合
     List<Integer> ageList = Arrays.asList(25, 34, 18, 25, 512);

     Optional<Integer> resultOne = ageList.stream().findAny();
     System.out.println("resultOne：" + resultOne.get());
 }

对象集合也是

@Test
public void testFindAny() {

    //对象集合
    List<Character> characterList = new ArrayList<>(5);

    Character judith = new Character("judith", 25, 168);
    judith.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character lydia = new Character("lydia", 18, 170);
    lydia.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character serena = new Character("serena", 512, 166);
    serena.setPropertyList(Arrays.asList(PropertyEnum.WATER));

    Character raya = new Character("raya", 26, 172);
    raya.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    Character sorin = new Character("sorin", 26, 172);
    sorin.setPropertyList(Arrays.asList(PropertyEnum.GOLD));

    characterList.add(judith);
    characterList.add(lydia);
    characterList.add(serena);
    characterList.add(raya);
    characterList.add(sorin);

    Optional<Character> resultTwo = characterList.stream().findAny();
    System.out.println("resultTwo：" + resultTwo.get());
}