Stream流常用方法测试

1、创建Stream的方法

1.1、通过 java.util.Collection.stream() 方法用集合创建流（推荐使用）

List<String> list = Arrays.asList("1","2","3");
Stream<String> stream = list.stream();

1.2、使用java.util.Arrays.stream(T[] array)方法用数组创建流

String [] arr={
    
    "1","2","3","4"};
Stream<String> stream1 = Arrays.stream(arr);

1.3、使用Stream的静态方法：of()、iterate()、generate()

Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
System.out.println(integerStream.getClass());   // 打印类型
int [] integerArr={
    
    2,4,5,2,3412,31};
IntStream stream2 = Arrays.stream(integerArr);
System.out.println(stream2.max().getAsInt());   // 取最大值     不加getAsInt() >>  OptionalInt[3412]

Stream<Integer> limit = Stream.iterate(0, x -> x + 1).limit(3);  // 从0开始，每次+1，执行3次   结果：0，1，2
limit.forEach(System.out::println);
AtomicInteger integer=new AtomicInteger(10);  // 原子类
Stream<Integer> limit1 = Stream.generate(() -> integer.incrementAndGet()).limit(2); // 结果 11  12
limit1.forEach(System.out::println);

2、遍历、匹配

List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
List<Integer> list2 = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

2.1、顺序遍历

list.stream().forEach(System.out::println);

2.2、并行遍历（开辟多线程并发执行）

list.parallelStream().forEach(System.out::println);

2.3、筛选遍历

list.stream().filter(t->t>6).forEach(System.out::println); // 先找到大于6的元素 再组装成新的集合之后再遍历
list.stream().filter(t -> t > 6).findFirst(); // >> Optional[7]
list.stream().filter(t -> t > 6).findFirst().get();  //>> 7

Optional<Integer> any1 = list.parallelStream().filter(t -> t > 1).findAny();   // 使用并行流，随机返回一个比1大的
System.out.println(any1.get());

2.4、筛选

List<Person> personList = new ArrayList<Person>();

personList.add(new Person("韩梅梅", 8900,22, "女", "武汉"));
personList.add(new Person("李磊", 7000,33, "男", "上海"));
personList.add(new Person("Lucy", 7800,44, "女", "北京"));
personList.add(new Person("狗哥", 8200,55, "男", "深圳"));
personList.add(new Person("Lily", 9500,66, "女", "深圳"));
personList.add(new Person("Jim", 7900,77, "男", "深圳"));
//筛选员工中工资高于8000的人，注意以下是没有返回新集合，直接遍历结果
    //Person{name='韩梅梅', salary=8900, age=22, sex='女', area='武汉'}
    //Person{name='狗哥', salary=8200, age=55, sex='男', area='深圳'}
    //Person{name='Lily', salary=9500, age=66, sex='女', area='深圳'}
personList.stream().filter(t->t.getSalary()>8000).forEach(System.out::println);
//返回新集合，返回新集合
/*[Person{name='韩梅梅', salary=8900, age=22, sex='女', area='武汉'}, Person{name='狗哥', salary=8200, age=55, sex='男', area='深圳'}, Person{name='Lily', salary=9500, age=66, sex='女', area='深圳'}]
List<Person> collect = personList.stream().filter(t -> t.getSalary() > 8000).collect(Collectors.toList());*/
System.out.println(collect);
//找出性别为女的，并返回名字到一个新的集合
    // 韩梅梅
    // Lucy
    // Lily
List<String> girl = personList
    .stream()
    .filter(t ->t.getSex().equals("女"))
    .map(Person::getName)    // 取出符合字段
    .collect(Collectors.toList());
girl.forEach(System.out::println);

3、聚合

3.1、获取String集合中最长的元素

List<String> list = Arrays.asList("李磊", "韩梅梅", "Lucy", "Jim");
Optional<String> max = list.stream().max((o1, o2) -> o1.length() - o2.length());
System.out.println(max.get());

3.2、取最大值/最小值

//2. 获取Integer集合中的最大值
List<Integer> list2 = Arrays.asList(7, 6, 9, 4, 11, 6);
Integer maxNum = list2.stream().max(Integer::compareTo).get();
System.out.println(maxNum);

Integer minInteger = list2.stream().min(Integer::compareTo).get();
System.out.println(minInteger);

4、映射

4.1、英文字符串数组的元素全部改为大写

String[] strArr = {
    
     "abcd", "bcdd", "defde", "fTr" };
List<String> listStr= Arrays.asList(strArr);
System.out.println(listStr);
List<String> newListStr = listStr.stream()
    .map(t -> t.toUpperCase())   // 映射修改字段
    .collect(Collectors.toList());
System.out.println(newListStr);
// [abcd, bcdd, defde, fTr]
// [ABCD, BCDD, DEFDE, FTR]

4.2、每个数字都+3

扫描二维码关注公众号，回复： 13290962 查看本文章

//整数数组每个元素+3
System.out.println("整数数组每个元素+3");
List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
System.out.println(intList);
List<Integer> newIntList=intList.stream().
    map(t->t+3).   // 映射每个数字都+3
    collect(Collectors.toList());
System.out.println(newIntList);
// 整数数组每个元素+3
// [1, 3, 5, 7, 9, 11]
// [4, 6, 8, 10, 12, 14]

4.3、实体类属性修改

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("韩梅梅", 8900, 18,"女", "武汉"));
personList.add(new Person("李磊", 7000,19, "男", "上海"));
personList.add(new Person("Lucy", 7800,17, "女", "北京"));
personList.add(new Person("狗哥", 8200,18, "男", "深圳"));
personList.add(new Person("Lily", 9500,17, "女", "深圳"));
personList.add(new Person("Jim", 7900,17, "男", "深圳"));
// 改变原来值的情况
List<Person> personList2 = personList.stream().map(t -> {
    
    
    t.setSalary(t.getSalary() + 1000);
    return t;
}).collect(Collectors.toList());
System.out.println(personList2);
//不改变原有值的情况
List<Person> personList3 = personList.stream().map(t -> {
    
    
    //创建一个新的对象
    Person person = new Person(t.getName(), t.getSalary(), t.getAge(), t.getSex(), t.getArea()); // 创建一个新的实体
    //在新的对象基础上加1000
    person.setSalary(person.getSalary()+1000);
    return person;
}).collect(Collectors.toList());
System.out.println(personList3);

5、归约

reduce归约，也就是减少缩减，对流的的内容进行合并修改等操作最后只剩下一个值

List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);

5.1、求和

Integer sum = list.stream().reduce(Integer::sum).get();

5.2、求积

Integer mul = list.stream().reduce((x, y) -> x * y).get();

5.3、最大值

Integer max2 = list.stream().reduce(Integer::max).get();

5.4、最小值

Integer max2 = list.stream().reduce(Integer::min).get();

5.5、工资求和

map(找对应属性)+reduce(计算结果)

Integer allSalary1 = personList.stream().map(t -> t.getSalary()).reduce(Integer::sum).get();

// 重写
Integer allSalary4 = personList.stream().map(t -> t.getSalary()).reduce((x, y) -> x + y).get();

6、归集

因为流是不存储数据的，所有流的数据在完成处理后需要将数据重新归集到新的集合

有toList/toSet/toMap三种类型

List<Person> personList = new ArrayList<Person>();
personList.add(new Person("韩梅梅", 8900, 18,"女", "武汉"));
personList.add(new Person("李磊", 7000,19, "男", "上海"));
personList.add(new Person("Lucy", 7800,17, "女", "北京"));
personList.add(new Person("狗哥", 8200,18, "男", "深圳"));
personList.add(new Person("Lily", 9500,17, "女", "深圳"));
personList.add(new Person("Jim", 7900,17, "男", "深圳"));

6.1、找出所有姓名，并添加进新的集合中

 List<String> allNames=personList.stream().map(p->p.getName()).collect(Collectors.toList());
// [韩梅梅, 李磊, Lucy, 狗哥, Lily, Jim]

6.2、将list转换为map，k为实体类的名字，v为实体

Map<String, Person> personMap = personList.stream().collect(Collectors.toMap(Person::getName, p -> p));
/*
{狗哥=Person{name='狗哥', salary=8200, age=18, sex='男', area='深圳'}, 李磊=Person{name='李磊', salary=7000, age=19, sex='男', area='上海'}, Lucy=Person{name='Lucy', salary=7800, age=17, sex='女', area='北京'}, Lily=Person{name='Lily', salary=9500, age=17, sex='女', area='深圳'}, 韩梅梅=Person{name='韩梅梅', salary=8900, age=18, sex='女', area='武汉'}, Jim=Person{name='Jim', salary=7900, age=17, sex='男', area='深圳'}}
*/

6.3、找出所有性别，使用toSet() 去重

Set<String> collect = personList.stream().map(Person::getSex).collect(Collectors.toSet());
// [女, 男]

6.4、Collectors统计数据的静态方法

List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("韩梅梅", 8900, 18,"女", "武汉"));
        personList.add(new Person("李磊", 7000,19, "男", "上海"));
        personList.add(new Person("Lucy", 7800,17, "女", "北京"));
        personList.add(new Person("狗哥", 8200,18, "男", "深圳"));
        personList.add(new Person("Lily", 9500,17, "女", "深圳"));
        personList.add(new Person("Jim", 7900,17, "男", "深圳"));

6.4.1、统计实体人数

long count = personList.stream().count();
Long collect = personList.stream().collect(Collectors.counting());  // Collectors.counting()  使用静态方法

6.4.2、求平均值

Double avg = personList.stream().collect(Collectors.averagingInt(Person::getSalary));

6.4.3、求和

Long sum1 = personList.stream().collect(Collectors.summingLong(Person::getSalary));

6.4.4、多种类型

IntSummaryStatistics collect1 = personList.stream().collect(Collectors.summarizingInt(Person::getSalary));
// IntSummaryStatistics{count=6, sum=49300, min=7000, average=8216.666667, max=9500}

6.5、分组

分组可以理解为数据库的groupby操作，返回值为Map<Boolean,List>

6.5.1、按工资是否大于等于8000分为2组

Map<Boolean, List<Person>> collect = personList.stream().collect(Collectors.groupingBy(p -> p.getSalary() >= 8000));
// k为true or false
// {false=[Person{name='李磊', salary=7000, age=19, sex='男', area='上海'}, Person{name='Lucy', salary=7800, age=17, sex='女', area='北京'}, Person{name='Jim', salary=7900, age=17, sex='男', area='深圳'}], true=[Person{name='韩梅梅', salary=8900, age=18, sex='女', area='武汉'}, Person{name='狗哥', salary=8200, age=18, sex='未知', area='深圳'}, Person{name='Lily', salary=9500, age=17, sex='女', area='深圳'}]}

6.5.2、按性别分为2组

Map<String, List<Person>> collect1 = personList.stream().collect(Collectors.groupingBy(p -> p.getSex()));
// {女=[Person{name='韩梅梅', salary=8900, age=18, sex='女', area='武汉'}, Person{name='Lucy', salary=7800, age=17, sex='女', area='北京'}, Person{name='Lily', salary=9500, age=17, sex='女', area='深圳'}], 未知=[Person{name='狗哥', salary=8200, age=18, sex='未知', area='深圳'}], 男=[Person{name='李磊', salary=7000, age=19, sex='男', area='上海'}, Person{name='Jim', salary=7900, age=17, sex='男', area='深圳'}]}

6.5.3、按地区分组

Map<String, List<Person>> collect2 = personList.stream().collect(Collectors.groupingBy(p -> p.getArea()));
// {上海=[Person{name='李磊', salary=7000, age=19, sex='男', area='上海'}], 武汉=[Person{name='韩梅梅', salary=8900, age=18, sex='女', area='武汉'}], 深圳=[Person{name='狗哥', salary=8200, age=18, sex='未知', area='深圳'}, Person{name='Lily', salary=9500, age=17, sex='女', area='深圳'}, Person{name='Jim', salary=7900, age=17, sex='男', area='深圳'}], 北京=[Person{name='Lucy', salary=7800, age=17, sex='女', area='北京'}]}

6.6、接合

6.6.1、找出所有的名字，并按，进行分割，最后返回一个使用，分割好的字符串

String names = personList.stream().map(t -> t.getName()).collect(Collectors.joining(","));
// 韩梅梅,李磊,Lucy,狗哥,Lily,Jim

6.6.2、A-B-C

List<String> list = Arrays.asList("A", "B", "C");
System.out.println(list.stream().collect(Collectors.joining("-")));

7、排序

7.1、按工资升序排序（自然排序） 并取出所有名字

List<String> names1 = personList.stream().sorted(Comparator.comparingInt(Person::getSalary)).map(p -> p.getName()).collect(Collectors.toList());
// [李磊, Lucy, Jim, 狗哥, 韩梅梅, Lily]

7.2、按工资倒序排序

List<String> names2 = personList.stream().sorted(Comparator.comparingInt(Person::getSalary).reversed()).map(p -> p.getName()).collect(Collectors.toList());
// [Lily, 韩梅梅, 狗哥, Jim, Lucy, 李磊]

8、合并

String[] arr1 = {
    
     "a", "b", "c", "d" };
String[] arr2 = {
    
     "d", "e", "f", "g" };

8.1、正常合并

List<String> collect1 = Stream.concat(Arrays.stream(arr1), Arrays.stream(arr2)).collect(Collectors.toList());

8.2、合并后去重

List<String> collect2 = Stream.concat(Arrays.stream(arr1),Arrays.stream(arr2)).distinct().collect(Collectors.toList());

8.3、合并并去重并只显示要前三个

List<String> collect3 = Stream.concat(Arrays.stream(arr1), Arrays.stream(arr2)).distinct().limit(3).collect(Collectors.toList());

8.4、合并并去重并只要三个 跳过1个元素取

List<String> collect4 = Stream.concat(Arrays.stream(arr1), Arrays.stream(arr2)).distinct().skip(1).limit(3).collect(Collectors.toList());