[Java知识库]Stream流的这些操作，35岁程序员的人生感悟

}

}

**运行截图**：

![](https://upload-images.jianshu.io/upload_images/22932333-ac0ba36703ad6039.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

distinct:筛选重复的元素，通过流生产元素的hashCode()和equals去除重复元素；

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;

public class StramTest02 {
public static void main(String[] args) {
Employee employee01=new Employee(“yang”,“hui”,9);
Employee employee02=new Employee(“yang”,“hui”,49);
Employee employee03=new Employee(“yang”,“hui”,9);
Employee employee04=new Employee(“yang”,“hui”,89);
Employee employee05=new Employee(“yang”,“hui”,89);
Employee employee06=new Employee(“yang”,“hui”,89);
List list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);
//创建Stream
Stream stream1 = list.stream();
//对stream1流进行过滤
Stream s = stream1.filter((e) -> {
System.out.println("---------------filter------------");
//过滤掉年龄小于19
return e.getAge() >= 19;
}).skip(2).distinct();
//s=s.skip(5);
s.forEach((e-> System.out.println(e)));
}
}

**运行截图：**

![](https://upload-images.jianshu.io/upload_images/22932333-e605ba2264502e7c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

**排序**：

sorted(Comparable)–自然排序

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest03 {
public static void main(String[] args) {
List list= Arrays.asList(“c”,“bbb”,“abc”,“bbbb”);
Stream stream = list.stream();
//即通过调用String方法中CompareTo，通过一个一个的比较字符的ASCLL值，首先比较首字符的ASCLL大小，相同的话再比较下一个
stream= stream.sorted();
stream.forEach(System.out::println);
}
}

**sorted(Comparator)–定制排序**

package com.ysh.review01_Stream;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Stream;

public class StramTest02 {
public static void main(String[] args) {
Employee employee01=new Employee(“yang”,“哈哈”,19);
Employee employee02=new Employee(“yang”,“hui”,49);
Employee employee03=new Employee(“yang”,“hui”,79);
Employee employee04=new Employee(“yang”,“呵呵呵”,79);
Employee employee05=new Employee(“yang”,“hui”,39);
Employee employee06=new Employee(“yang”,“hui”,29);
List list= Arrays.asList(employee01,employee02,employee03,employee04,employee05,employee06);
//创建Stream
Stream stream1 = list.stream();
//对stream1流进行过滤
Stream s = stream1.filter((e) -> {
System.out.println("---------------filter------------");
//过滤掉年龄小于19
return e.getAge() >= 19;
});
//s=s.skip(5);
/*此处可以使用Lambda表达式，即s.sorted((o1,o2)->{
//升序排序，如果年龄相同，则按照姓名的长度排序
if (o1.getAge()==o2.getAge()){
return o1.getName().length()-o2.getName().length();
}
//按照年龄升序排序
return o1.getAge()-o2.getAge();

                      })

     */
    s=s.sorted(new Comparator<Employee>() {
        @Override
        public int compare(Employee o1, Employee o2) {
            //升序排序，如果年龄相同，则按照姓名的长度排序
            if (o1.getAge()==o2.getAge()){
                return o1.getName().length()-o2.getName().length();
            }
            //按照年龄升序排序
            return o1.getAge()-o2.getAge();
        }
    });
    s.forEach((e-> System.out.println(e)));
}

}

## Stream中的map和flatMap方法：

*   流中的每一个数据，当做map方法的参数(接口)，接口中抽象方法的参数，进行制定操作，最终得到一个结果，最后所有的结果返回去成为一个流
*   流中的每一个数据当作参数，进行操作，得到的结果必须是一个流，最终会结合成一个流返回

package com.ysh.review01_Stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamTest04 {
public static void main(String[] args) {
Stream stream=Stream.of(“aaa”,“bbbb”,“ccccc”);
//map方法是每一个数据当作一个流，即以上{aaa}、{bbbb}、{ccccc}各是一个Stream流集合，即达到得到多个Stream流集合
//可以理解为Stream流中包含Stream流
//因为这里的testCharacter()的方法我返回的是一个Stream
//Stream<Stream> streamStream = stream.map((e) -> testCharacter(e));
Stream<Stream> streamStream = stream.map((e) -> {
List list = new ArrayList<>();
for (Character c : e.toCharArray()) {
list.add?;
}
return list.stream();
});
streamStream.forEach((e)->{
e.forEach((e2)->{
System.out.println(e2);
});
});
Stream stm=Stream.of(“aaa”,“bbbb”,“ccccc”);
//flatMap()方法即是把将得到的多个Stream流集合合并为一个一个Stream流集合
Stream stream1=stm.flatMap(StreamTest04::testCharacter);
//streamStream.forEach(System.out::println);
System.out.println("---------------");
stream1.forEach(System.out::println);
}
//返回一个Stream
public static Stream testCharacter(String str){
List list=new ArrayList<>();
for (Character c:str.toCharArray()){
list.add?;
}
Stream stream=list.stream();
return stream;
}
}

## 终止操作

#### 查找与匹配

*   allMatch:检查是否匹配所有元素；
*   anyMatch:检查是否至少匹配一个元素；
*   noneMatch:检查是否没有匹配所有元素；
*   findFirst:返回第一个元素；
*   findAny:返回当前流中的任意元素；
*   count:返回流中元素的总个数；
*   max:返回流中最大值；
*   min:返回流中最小值；

**代码实例**：

package com.ysh.review01_Stream;

import java.util.Optional;
import java.util.stream.Stream;

/**

• Stream中的终止操作
  */
  public class StreamTest06 {
  public static void main(String[] args) {
  //获取Stream
  Stream stm1=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  //allMatch()方法里面的参数是一个断言式接口，即实现必须重写test()方法
  boolean b1 = stm1.allMatch((t) -> {
  //检查是否匹配所有元素
  return t.length() > 2;
  });
  Stream stm2=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  boolean b2=stm2.anyMatch((t) -> {
  //检查是否至少匹配一个元素
  return t.length() > 2;
  });
  Stream stm3=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  boolean b3=stm3.noneMatch((t) -> {
  //检查是否没有匹配所有元素
  return t.length() > 2;
  });
  Stream stm4=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  //得到流中的第一个元素
  Optional first = stm4.findFirst();
  //输出
  System.out.println(first.get());
  Stream stm5=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  //返回当前流中的任意元素
  Optional any = stm5.findAny();
  System.out.println(any.get());
  Stream stm6=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  //放回流中元素的总个数
  long count = stm6.count();
  System.out.println(count);
  Stream stm7=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  //返回流中最大值，即长度最长，长度相同则比较ASCLL值大小
  Optional max = stm7.max((s1, s2) -> {
  if (s1.length()==s2.length()){
  return s1.compareTo(s2);
  }
  return s1.length() - s2.length();
  });
  System.out.println(max.get());
  Stream stm8=Stream.of(“aaaaaa”,“bbbbb”,“cccccc”,“dd”,“eee”);
  //返回流中最小值，即长度最短，长度相同则比较ASCLL值大小
  Optional min = stm8.min((s1, s2) -> {
  if (s1.length() == s2.length()) {
  return s2.compareTo(s1);
  }
  return s1.length() - s2.length();
  });
  System.out.println(min.get());
  System.out.println(b3);
  }
  }

## 收集：

收集-将流转换为其他形式，接收一个Collertor接口的实现，用于给Stream中元素做 汇总的方法

*   List：把流中所有元素收集到List中，使用.collect(Collectors.toList());
*   Set：把流中所有元素收集到Set中，删除重复项，使用.collect(Collectors.toSet());
*   Map：把流中所有元素收集到Map中，当出现相同的key时会抛异常，使用 .collect(Collectors.toMap());
*   使用collect方法求流中共有几条数据，使用.collect(Collectors.counting())
*   使用collect方法求平均数，使用.collect(Collectors.averagingInt();
*   使用collect方法求某个变量的总和，使用.collect(Collectors.summingDouble());
*   使用collect方法且某个变量中值的最大值，使用.collect(Collectors.maxBy());

**代码实例**：

package com.ysh.review01_Stream.one;

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

public class StreamTest07 {
public static void main(String[] args) {
Student stu1=new Student(“1”,“hhhh”,18);
Student stu2=new Student(“2”,“hhhhh”,19);
Student stu3=new Student(“3”,“oooooo”,19);
Student stu4=new Student(“4”,“aaaaa”,19);
List list = Arrays.asList(stu1,stu2,stu3,stu4);
//获取所有学生的姓名流，并且存储再List集合中
List collect = list.stream().map((e) -> {
return e.getName();
}).collect(Collectors.toList());
System.out.println(collect);
Set set = list.stream().map((e) -> {
return e.getName();
}).collect(Collectors.toSet());
System.out.println(collect);
//将学生的姓名和年龄放入到一个集合中，当出现相同的key是会抛出一个java.lang.IllegalStateException: Duplicate key异常
Map<String, Integer> map = list.stream().collect(Collectors.toMap((e) -> e.getName(), (e2) -> e2.getAge()));
System.out.println(map);
//运用collect输出所有学生的总数
Long count2 = list.stream().collect(Collectors.counting());
System.out.println(count2);
//运用collect方法计算所有学生的平均年龄
Double collect1 = list.stream().collect(Collectors.averagingDouble((n) -> n.getAge()));
System.out.println(collect1);
//运用collect方法求所有学生的年龄之和
int agesum=list.stream().collect(Collectors.summingInt((e)->e.getAge()));
System.out.println(agesum);
//运用collect方法求所有学生中年龄最大的
Optional max2 = list.stream().collect(Collectors.maxBy((a1, a2) -> a1.getAge() - a2.getAge()));
System.out.println(max2.get());

}

}
class Student {
private String id;
private String name;
private int age;
public Student(){

}

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

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public String getName() {
    return name;

最后

小编精心为大家准备了一手资料

**点击这里免费领取**以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术

【附】架构书籍赠送

1. BAT面试的20道高频数据库问题解析
2. Java面试宝典
3. Netty实战
4. 算法

BATJ面试要点及Java架构师进阶资料

片转存中…(img-nxAVeR5E-1628591946517)]

**点击这里免费领取**以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术

【附】架构书籍赠送

1. BAT面试的20道高频数据库问题解析
2. Java面试宝典
3. Netty实战
4. 算法

[外链图片转存中…(img-mcq0MF0T-1628591946520)]

BATJ面试要点及Java架构师进阶资料

[外链图片转存中…(img-5KYGxNCV-1628591946524)]