java8的Stream常用方法测试

列举一些实际开发中,Stream的常用方法,

首先,创建实体类:

package testStream;

/**
 * Created by XuYinShan on 2020/7/20
 */
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

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

接下来是测试Stream的方法类TestStream:

package testStream;

import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.stream.Collectors.*;


/**
 * 测试java8  Stream
 *
 * Created by XuYinShan on 2020/7/20
 */
public class TestStream {

    // 测试mapToInt()及sum()方法
    @Test
    public void testStream1() {
        String[] strarr = {"abc", "defg", "hijk"};
        // 1.mapToInt()的参数是流中的每个元素,可以对每个元素进行操作,生成新的流
        // 2.流调用sum方法累加流中的元素
        int length = Arrays.stream(strarr).mapToInt(s -> s.length()).sum();
        System.out.println("长度和: " + length);
        // 测试结果: 长度和: 11
    }


    // 测试filter方法
    @Test
    public void testStream2() {
        // 获取年龄为20的person对象的list
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        // 1.filter方法中的person也是代指流中的每个元素,通过表达式实现过滤
        // 2.使用collect(toList())将流转成集合
        List listNew = list.stream().filter(p -> p.getAge() == 20).collect(toList());
        System.out.println(listNew);
        // 测试结果: [Person{name='xx', age=20}]
    }


    // 测试sorted()方法
    @Test
    public void testStream3() {
        // person根据年龄排序
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        // sorted()实现排序
        // 1.a的方式是方便理解的,降序是(p1, p2) -> p2.getAge() - p1.getAge()
        // 2.b方式如果需要降序排列,在Comparator.comparingInt(Person::getAge)后面加上reversed()

        // a.
        // List listNew = list.stream().sorted((p1, p2) -> p1.getAge() - p2.getAge()).collect(toList());

        // b.
        List listNew = list.stream().sorted(Comparator.comparingInt(Person::getAge)).collect(toList());
        System.out.println(listNew);
        // 测试结果: [Person{name='xqe', age=19}, Person{name='xx', age=20}, Person{name='xys', age=25}]
    }


    // 测试limit()方法
    @Test
    public void testStream4() {
        // 获取指定person对象个数
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        List listNew = list.stream().limit(2).collect(toList());
        System.out.println(listNew);
        // 测试结果: [Person{name='xx', age=20}, Person{name='xys', age=25}]
    }


    // 测试skip()方法
    @Test
    public void testStream5() {
        // 去除前n个元素
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        List listNew = list.stream().skip(2).collect(toList());
        System.out.println(listNew);
        // 测试结果: [Person{name='xqe', age=19}]
    }


    // 测试map()方法
    @Test
    public void testStream6() {
        // 将对象的姓名存为list
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        List listNew = list.stream().map(Person::getName).collect(toList());
        // List listNew = list.stream().map(p->p.getName()).collect(toList());
        System.out.println(listNew);
        // 测试结果: [xx, xys, xqe]
    }


    // 测试flatMap()方法
    @Test
    public void testStream7() {
        // flatMap将流合并
        List<String> list = new ArrayList<>();
        list.add("aaa bbb ccc");
        list.add("ddd eee fff");
        list.add("ggg hhh iii");
        // 先将集合中的每一项转成数组,然后将这些数组合并成流,最后转成集合
        list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(toList());
        System.out.println(list);
        // 测试结果: [aaa, bbb, ccc, ddd, eee, fff, ggg, hhh, iii]
    }


    // 测试anyMatch()方法
    @Test
    public void testStream8() {
        // 是否存在符合条件的对象
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 17));
        // 测试流中的是否有符合条件的元素,参数是断言类型函数
        boolean b = list.stream().anyMatch(person -> person.getAge() == 30);
        System.out.println(b);
        // 测试结果: false
    }


    // 测试reduce()方法
    @Test
    public void testStream9() {
        // 运算 map 将流中的每一个元素 T 映射为 R（类似类型转换）
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 23));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 18));
        // 1 求和
        // Integer reduce = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
        Integer reduce = list.stream().map(Person::getAge).reduce(0, (a, b) -> a + b);
        // 2 求和
        // int reduce = list.stream().map(Person::getAge).reduce(0, Integer::sum);
        // Optional<Integer> reduce = list.stream().map(Person::getAge).reduce(Integer::sum);
        // 3 乘积
        // int reduce = list.stream().map(Person::getAge).reduce(1, (a, b) -> a * b);
        // 返回流中个数
        // long count = list.stream().count();
        // list.stream().forEach(System.out::println);
        System.out.println(reduce);
    }


    // 测试max(),min(),average()方法
    @Test
    public void testStream10() {
        // 数值流相关
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        // 最大
        OptionalInt max = list.stream().mapToInt(Person::getAge).max();
        // 最小
        OptionalInt min = list.stream().mapToInt(Person::getAge).min();
        // 求和(推荐)
        int sum = list.stream().mapToInt(Person::getAge).sum();
        // 平均值
        OptionalDouble average = list.stream().mapToInt(Person::getAge).average();

        // Stream 求和
        IntStream intStream = IntStream.rangeClosed(1, 10); // 闭区间
        IntStream intStream2 = IntStream.range(1, 10); // 左闭右开
        System.out.println(intStream2.sum());
    }


    // 测试数组转流
    @Test
    public void testStream11() {
        // 将数组转成数值流,同时取下标从1开始到3(不含3)结束的流
        int[] a = {1, 2, 3, 4};
        Arrays.stream(a, 1, 3).forEach(System.out::println);
        // 测试结果: 2 3
    }


    // 文件生成流
    @Test
    public void testStream12() throws IOException {
        // 按行读取d盘下的aa.txt
        Stream<String> lines = Files.lines(Paths.get("D:\\aa.txt"));
        // 输出
       // lines.flatMap(line -> Arrays.stream(line.split(" "))).distinct().forEach(System.out::println);

        // list存放读取到的文件流
        List<String> collect = lines.flatMap(line -> Arrays.stream(line.split(" "))).distinct().collect(toList());
        System.out.println(collect);
    }


    // 测试iterate()方法
    @Test
    public void testStream13() {
        // 函数生成流,生成10个奇数
        Stream.iterate(0, n -> n + 1).filter(x -> x % 2 != 0) .limit(10).forEach(System.out::println);
        // 测试结果: 1 3 5 7 9 11 13 15 17 19
    }


    // 测试toMap()方法
    @Test
    public void testStream14() {
        // collect() 把流中所有元素收集到一个 List, Set 或 Collection 中
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        Map<String, Person> map = list.stream().collect(toMap(Person::getName, p -> p));
        System.out.println(map);
        // 测试结果: {xx=Person{name='xx', age=20}, xys=Person{name='xys', age=25}, xqe=Person{name='xqe', age=19}}
    }


    // 取最值
    @Test
    public void testStream15() {
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        // 1
        Optional<Person> collect = list.stream().collect(maxBy(Comparator.comparing(Person::getAge)));
        // 2
        Optional<Person> max = list.stream().max(Comparator.comparing(Person::getAge));
        System.out.println(max);
    }


    // 连接字符串
    @Test
    public void testStream16() {
        List<Person> list = new ArrayList<>();
        list.add(new Person("xx", 20));
        list.add(new Person("xys", 25));
        list.add(new Person("xqe", 19));
        String collect = list.stream().map(Person::getName).collect(joining());
        String collect2 = list.stream().map(Person::getName).collect(joining(","));
        // 三个参数依次为:连接符,前缀,后缀
        String collect3 = list.stream().map(Person::getName).collect(joining(" and ", "Today ", " play games."));
        System.out.println(collect3);
    }


    // 分组
    @Test
    public void testStream17() {
        List<Person> list = new ArrayList<>();
        list.add(new Person("xuxiang", 20));
        list.add(new Person("xuyinshan", 25));
        list.add(new Person("xuyinzhe", 25));
        Map<Integer, List<Person>> collect = list.stream().collect(groupingBy(Person::getAge));
        System.out.println(collect);
        // 测试结果: {20=[Person{name='xuxiang', age=20}], 25=[Person{name='xuyinshan', age=25}, Person{name='xuyinzhe', age=25}]}
    }


    // 分区 partitioningBy()
    @Test
    public void testStream18() {
        List<Person> list = new ArrayList<>();
        list.add(new Person("xuxiang", 20));
        list.add(new Person("xuyinshan", 25));
        list.add(new Person("xuyinzhe", 20));
        Map<Boolean, List<Person>> map = list.stream()
                .collect(partitioningBy(p -> p.getAge() <= 20));
        System.out.println(map);
        // 测试结果: {false=[Person{name='xuyinshan', age=25}], true=[Person{name='xuxiang', age=20}, Person{name='xuyinzhe', age=20}]}
    }


    // 并行 parallel() 实现累加
    @Test
    public void testStream19() {
        int i = Stream.iterate(1, a -> a + 1).limit(100).parallel().reduce(0, Integer::sum);
        System.out.println(i);
        // 测试结果: 5050
    }

}

详细api可参考:https://www.matools.com/api/java8中的 java.util.stream;