这里写目录标题
- 一、Stream流概述
- 1.1、传统写法
- 1.2、Stream写法
- 1.3、Stream流操作分类
- 二、Stream流获取方式
- 2.1、根据Collection获取
- 2.2、通过Stream的of方法
- 三、Stream常用方法介绍
- 3.1、forEach
- 3.2、count
- 3.3、filter
- 3.4、limit
- 3.5、skip
- 3.6、map
- 3.7、sorted
- 3.8、distinct
- 3.9、match
- 3.10、find
- 3.11、max和min
- 3.12、reduce方法
- 3.12.1、 map和reduce的组合
- 3.13、mapToInt
- 3.14、concat
- 3.15、综合案例
- 4.1、结果收集到集合中
- 四、Stream结果手集
- 4.1、结果收集到集合中
- 4.2、结构收集到数组中
- 4.3、对流中数据做聚合操作
- 4.4、对流中数据做分组操作
- 4.5、对流中数据做分区操作
- 4.6、对流中数据做拼接
- 五、并行Stream流
- 5.1、串行的Stream流
- 5.2、并行流
- 5.2.1、获取并行流
- 5.2.3、并行流操作
- 5.3、并行流和串行流对比
- 5.4、线程安全
一、Stream流概述
Java 中，Stream 是一个来自java.util.stream包的接口，用于对集合（如List、Set等）或数组等数据源进行操作的一种抽象层。
Stream流（和IO流没有任何关系）主要是对数据进行加工处理的。Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。
1.1、传统写法
现在有需求：对list中姓张，名字长度为3的信息打印：
public static void main(String[] args) {
//定义一个List集合
List<String> list = Arrays.asList("张三","张三丰","张无忌","李四","王五");
//获取姓张，名字长度为3的信息，添加到列表中
List<String> list1=new ArrayList<>();
for (String s : list) {
if(s.startsWith("张")&&s.length()==3){
list1.add(s);
}
}
for (String s : list1) {
System.out.println(s);
}
}
1.2、Stream写法
public static void main(String[] args) {
//定义一个List集合
List<String> list = Arrays.asList("张三","张三丰","张无忌","李四","王五");
list.stream().filter(s -> s.startsWith("张"))
.filter(s -> s.length()== 3)
.forEach(System.out::println);
}
上面的SteamAPI代码的含义：获取流，过滤张，过滤长度，逐一打印。代码相比于上面的案例更加的简洁直观。
1.3、Stream流操作分类
- 生成操作
通过数据源（集合、数组等）生成流。 - 中间操作
对流进行某种程度的过滤/映射，并返回一个新的流。 - 终结操作
执行某个终结操作，一个流只能有一个终结操作。
二、Stream流获取方式
2.1、根据Collection获取
java.util.Collection 接口中加入了default方法 stream，也就是说Collection接口下的所有的实现都可以通过steam方法来获取Stream流。(java集合框架主要包括两种类型的容器，一种是集合，存储一个元素集合（Collection），另一种是图(Map)，存储键/值对映射)。
public static void main(String[] args) {
List<String> list=new ArrayList<>();
Stream<String> stream=list.stream();
Set<String> set=new HashSet<>();
Stream<String> stream1=set.stream();
Vector vector=new Vector();
vector.stream();
}
Map接口别没有实现Collection接口，这时我们可以根据Map获取对应的key value的集合。
public static void main(String[] args) {
Map<String,Object> map=new HashMap<>();
Stream<String> stream=map.keySet().stream();//key
Stream<Object> stream1=map.values().stream();//value
Stream<Map.Entry<String,Object>> stream2=map.entrySet().stream();//entry
}
2.2、通过Stream的of方法
由于数组对象不可能添加默认方法，所有Stream接口中提供了静态方法of操作到数组中的数据
public static void main(String[] args) {
Stream<String> a1= Stream.of("a1","a2","a3");
String[] arr1 = {"aa","bb","cc"};
Stream<String> arr11 = Stream.of(arr1);
Integer[] arr2 = {1,2,3,4};
Stream<Integer> arr21 = Stream.of(arr2);
arr21.forEach(System.out::println);
// 注意：基本数据类型的数组是不行的
int[] arr3 = {1,2,3,4};
Stream.of(arr3).forEach(System.out::println);
}
三、Stream常用方法介绍
Stream常用方法
| 方法名 | 方法作用 | 返回值类型 | 防范种类 |
|---|---|---|---|
| count | 统计个数 | long | 终结 |
| forEach | 逐一处理 | void | 终结 |
| filter | 过滤 | Stream | 函数拼接 |
| limit | 取用前几个 | Stream | 函数拼接 |
| skip | 跳过前几个 | Stream | 函数拼接 |
| map | 映射 | Stream | 函数拼接 |
| concat | 组合 | Stream | 函数拼接 |
| 注意： |
- 这里把常用的API分为“终结方法”和“非终结方法”
- “终结方法”：返回值类型不再是 Stream 类型的方法，不再支持链式调用。
- “非终结方法”：返回值类型仍然是 Stream 类型的方法，支持链式调用。
- Stream方法返回的是新的流。
- Stream不调用终结方法，中间的操作不会执行。
3.1、forEach
forEach用来遍历流中的数据的。
void forEach(Consumer<? super T> action);
该方法接受一个Consumer接口，会将每一个流元素交给函数处理。
public static void main(String[] args) {
Stream<String> a1=Stream.of("aa","bb","cc");
a1.forEach(System.out::println);
}
3.2、count
Stream流中的count方法用来统计其中的元素个数的。
long count();
该方法返回一个long值，代表元素的个数。
public static void main(String[] args) {
long count = Stream.of("a1", "a2", "a3").count();
System.out.println(count);
}
3.3、filter
filter方法的作用是用来过滤数据的。返回符合条件的数据。
可以通过filter方法将一个流转换成另一个子集流。
public static void main(String[] args) {
Stream<String> stream =
Stream.of("aa", "ab", "bc","a1","b2","c3").
filter(s -> s.contains("a"));
stream.forEach(System.out::println);
}
该接口接收一个Predicate函数式接口参数作为筛选条件。
3.4、limit
limit方法可以对流进行截取处理，支取前n个数据，
Stream<T> limit(long maxSize);
参数式一个long类型的数值，如果集合当前长度大于参数就进行截取，否则不操作：
public static void main(String[] args) {
Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
.limit(3)
.forEach(System.out::println);
}
3.5、skip
如果希望跳过前面几个元素，可以使用skip方法获取一个截取之后的新流：
Stream<T> skip(long n);
示例：
public static void main(String[] args) {
Stream.of("a1","b2","c3","aa","bb","cc")
.skip(3).forEach(System.out::println);
}
3.6、map
如果需要将流中的元素映射到另一个流中，可以使用map方法：
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的数据
public static void main(String[] args) {
Stream.of("1","2","3","4","5")
//.map(s -> Integer.parseInt(s))
.map(Integer::parseInt)
.forEach(System.out::println);
}
3.7、sorted
如果需要将数据排序，可以使用sorted方法：
Stream<T> sorted();
在使用的时候可以根据自然规则排序，也可以通过比较强来指定对应的排序规则
public static void main(String[] args) {
Stream.of("1","2","7","9","3","4","6")
.map(Integer::parseInt)
.sorted((o1, o2) -> (o1 - o2))
.forEach(System.out::println);
}
3.8、distinct
如果要去掉重复数据，可以使用distinct方法
Stream<T> distinct();
Stream流中的distinct方法对于基本数据类型式可以直接去重的，但是对于自定义类型，我们需要重写hashCode和equals方法来移除重复数据。
public static void main(String[] args) {
Stream.of("1","2","4","5","2","3","4")
.sorted()
.distinct().forEach(System.out::println);
System.out.println("----------------");
Stream.of(
new Person("张三",18),
new Person("李四",18),
new Person("王五",20),
new Person("张三",18)
).distinct().forEach(System.out::println);
}
3.9、match
如果需要判断数据是否匹配指定的条件，可以使用match相关的方法：
boolean anyMatch(Predicate<? super T> predicate); // 元素是否有任意一个满足条件
boolean allMatch(Predicate<? super T> predicate); // 元素是否都满足条件
boolean noneMatch(Predicate<? super T> predicate); // 元素是否都不满足条件
使用：
public static void main(String[] args) {
boolean b = Stream.of("1","2","3","4","5","7")
.map(Integer::parseInt)
//.anyMatch(s-> s > 4);
//.allMatch(s-> s > 4);
.noneMatch(s-> s > 4);
System.out.println(b);
}
注：match是一个终结方法。
3.10、find
如果我们需要找到某些数据，可以使用find方法来实现
Optional<T> findFirst();
Optional<T> findAny();
使用：
public static void main(String[] args) {
Optional<String> first = Stream.of("a", "b", "c")
.findFirst();
System.out.println(first.get());
Optional<String> any = Stream.of("a", "b", "c","d")
.findAny();
System.out.println(any.get());
}
注：
3.11、max和min
如果我们想要获取最大值和最小值，那么可以使用max和min方法
public static void main(String[] args) {
Optional<Integer> max= Stream.of(1,2,3,4).max(Integer::compareTo);
System.out.println(max.get());
Optional<Integer> min= Stream.of(1,2,3,4).min(Integer::compareTo);
System.out.println(min.get());
}
3.12、reduce方法
如果需要将所有数据归纳得到一个数据，可以使用reduce方法：
public static void main(String[] args) {
Integer sum = Stream.of(4,5,3,7)
//identity默认值
//第一次的时候会将默认值赋给x
//之后每次将上一次的操作结果赋值给x y,就是每次从数据中获取的元素
.reduce(0, (x, y) -> {
System.out.println("x="+x+",y="+y);
return x + y;
});
System.out.println("sum = " + sum);
// 获取最大值
Integer max = Stream.of(4,5,3,9)
.reduce(0,(x,y) ->{
return x>y?x:y;
});
System.out.println("max = " + max);
}
3.12.1、 map和reduce的组合
在实际开发中我们经常会将map和reduce一块来使用：
public static void main(String[] args) {
//1、求出所有年龄总和
Integer sumAge= Stream.of(
new Person("张三", 20),
new Person("李四", 21),
new Person("王五", 22),
new Person("赵六", 23)
).map(Person::getAge)
.reduce(0,Integer::sum);
System.out.println(sumAge);
//2、求出所有年龄最大值
Integer maxAge= Stream.of(
new Person("张三", 20),
new Person("李四", 21),
new Person("王五", 22),
new Person("赵六", 23)
).map(Person::getAge)
.reduce(Integer::max).get();
System.out.println(maxAge);
//3、统计字符 a 出现的次数
Integer countA= Stream.of("a","b","c","d","e","a","a","a")
.map(ch -> ch.equals("a")?1:0)
.reduce(0,Integer::sum);
System.out.println(countA);
}
3.13、mapToInt
如果需要将Sream中的Integer类型转换成int类型，可以使用mapToInt方法来实现
public static void main(String[] args) {
//Integer 占用的内存比int多很多，在Stream流操作中会自动装修和拆箱操作
Integer arr[] ={1,2,3,4,6,7,8};
Stream.of(arr).filter(x -> x > 0).forEach(System.out::println);
//为了提高程序代码效率，可以先将流中Integer数据转为为int数据
IntStream intStream = Stream.of(arr).mapToInt(Integer::intValue);
intStream.forEach(System.out::println);
}
3.14、concat
如果有两个流，希望合并成为一个流，那么可以使用Stream接口防范concat
public static void main(String[] args) {
Stream<String> steam1=Stream.of("a","b","c");
Stream<String> steam2=Stream.of("x","y","z");
//通过concat方法将两个流合并成一个新的流
Stream.concat(steam1,steam2).forEach(System.out::println);
}
3.15、综合案例
4.1、结果收集到集合中
public static void main(String[] args) {
List<String> list1 = Arrays.asList("迪丽热巴", "宋远桥", "苏星河", "老子",
"庄子", "孙子", "洪七公");
List<String> list2 = Arrays.asList("古力娜扎", "张无忌", "张三丰", "赵丽颖",
"张二狗", "张天爱", "张三");
Stream<String> stream1 = list1.stream().filter(s -> s.length() == 3).limit(3);
Stream<String> stream2 =list2.stream().filter(s -> s.startsWith("张")).skip(2);
Stream.concat(stream1,stream2)
//.map(s -> new Person(s))
.map(Person::new)
.forEach(System.out::println);
}
四、Stream结果手集
4.1、结果收集到集合中
@Test
public void test01(){
//收集到list集合中
List<String> list= Stream.of("a","b","c").collect(Collectors.toList());
System.out.println(list);
//收集到set集合中
Set<String> set = Stream.of("aa","bb","cc","dd")
.collect(Collectors.toSet());
System.out.println(set);
//如果需要获取的类型为具体实现
ArrayList<String> arrayList = Stream.of("aaa","bbb","ccc")
//.collect(Collectors.toCollection(() -> new ArrayList<>()));
.collect(Collectors.toCollection(ArrayList::new));
System.out.println(arrayList);
}
4.2、结构收集到数组中
Stream中提供了toArray方法来将结果放到一个数组中，返回值类型是Object[]。
如果我们要指定返回的类型，那么可以使用另一个重载的toArray(IntFunction f)方法。
@Test
public void test02(){
//收集结果到数组中，数据类型是Object
Object[] objects = Stream.of("aaa","bbb","ccc")
.toArray();
System.out.println(Arrays.toString(objects));
//收集结构到数组中，数据类型是String
String[] strings = Stream.of("aaa","bbb","ccc")
.toArray(String[]::new);
System.out.println(Arrays.toString(strings));
}
4.3、对流中数据做聚合操作
当我们使用Stream流处理数据后，可以根据某个属性将数据分组
@Test
public void test03(){
//获取年龄最大值
List<Person> personList= Arrays.asList(new Person("张三",20),
new Person("李四",25),
new Person("王五",30),
new Person("赵六",35));
Optional<Person> maxAgePerson = personList.stream()
//.collect(Collectors.maxBy(Comparator.comparingInt(Person::getAge)));
.collect(Collectors.maxBy((p1,p2)->p1.getAge()-p2.getAge()));
System.out.println("最大年龄： "+maxAgePerson.get());
//获取年龄最小值
Optional<Person> minAgePerson = personList.stream()
.collect(Collectors.minBy((p1,p2)->p1.getAge()-p2.getAge()));
System.out.println("最小年龄： "+minAgePerson.get());
//求所有人的年龄之和
Integer sumAge = personList.stream()
.collect(Collectors.summingInt(Person::getAge));
System.out.println("年龄总和：" + sumAge);
//求所有人的年龄平均值
Double avgAge = personList.stream()
.collect(Collectors.averagingInt(Person::getAge));
System.out.println("年龄的平均值：" + avgAge);
//统计数量
Long count = personList.stream().filter(p-> p.getAge() > 20)
.collect(Collectors.counting());
System.out.println("满足条件的记录数：" + count);
}
4.4、对流中数据做分组操作
当我们使用Stream流处理数据后，可以根据某个属性将数据分组
public void test04(){
List<Person> personList= Arrays.asList(
new Person("张三", 18, 175)
, new Person("李四", 22, 177)
, new Person("张三", 14, 165)
, new Person("李四", 15, 166)
, new Person("张三", 19, 182));
//根据姓名对数据分组
Map<String,List<Person>> map1= personList.stream()
.collect(Collectors.groupingBy(Person::getName));
map1.forEach((k,v)-> System.out.println("k=" + k +"\t"+ "v=" + v));
System.out.println("-----------");
Map<String, List<Person>> map2 = personList.stream()
.collect(Collectors.groupingBy(p -> p.getAge() >= 18 ? "成年" : "未成年"));
map2.forEach((k,v)-> System.out.println("k=" + k +"\t"+ "v=" + v));
}
多级分组
@Test
public void test05(){
List<Person> personList= Arrays.asList(
new Person("张三", 16, 175)
, new Person("李四", 22, 177)
, new Person("张三", 14, 165)
, new Person("李四", 15, 166)
, new Person("张三", 19, 182));
//先根据name分组，然后根据age(成年和未成年)分组
Map<String,Map<Object,List<Person>>> map= personList.stream()
.collect(Collectors.groupingBy(Person::getName,
Collectors.groupingBy(p-> p.getAge() >= 18 ? "成年" : "未成年")));
map.forEach((k,v)->{
System.out.println("k=" + k);
v.forEach((kk,vv) -> System.out.println("\t"+"kk="+kk+"\tvv="+vv));
});
4.5、对流中数据做分区操作
Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表，一个true列表，一个
false列表
@Test
public void test06(){
List<Person> personList= Arrays.asList(
new Person("张三", 16, 175)
, new Person("李四", 22, 177)
, new Person("张三", 14, 165)
, new Person("李四", 15, 166)
, new Person("张三", 19, 182));
Map<Boolean, List<Person>> map = personList.stream()
.collect(Collectors.partitioningBy(p -> p.getAge() > 18));
map.forEach((k,v)-> System.out.println(k+"\t" + v));
}
4.6、对流中数据做拼接
Collectors.joining会根据指定的连接符，将所有的元素连接成一个字符串
@Test
public void test07(){
List<Person> personList= Arrays.asList(
new Person("张三", 18, 175)
, new Person("李四", 22, 177)
, new Person("张三", 14, 165)
, new Person("李四", 15, 166)
, new Person("张三", 19, 182));
String s1 = personList.stream().map(Person::getName)
.collect(Collectors.joining());
// 张三李四张三李四张三
System.out.println(s1);
String s2 = personList.stream().map(Person::getName)
.collect(Collectors.joining("_"));
// 张三_李四_张三_李四_张三
System.out.println(s2);
String s3 = personList.stream().map(Person::getName)
.collect(Collectors.joining("_", "###", "$$$"));
// ###张三_李四_张三_李四_张三$$$
System.out.println(s3);
}
五、并行Stream流
5.1、串行的Stream流
我们前面使用的Stream流都是串行，也就是在一个线程上面执行。
@Test
public void test01(){
long count = Stream.of(5,6,7,4,2,1,9)
.filter(s ->{
System.out.println(Thread.currentThread().getName() + ":" + s);
return s > 3;
}).count();
System.out.println(count);
}
5.2、并行流
parallelStream其实就是一个并行执行的流，它通过默认的ForkJoinPool，可以提高多线程任务的速
度。
5.2.1、获取并行流
@Test
public void test02(){
List<Integer> list=new ArrayList<>();
//通过list接口直接获取并行流
Stream<Integer> stram=list.parallelStream();
//将已有的串行流转换为并行流
Stream<Integer> parallel=Stream.of(1,2,3).parallel();
}
5.2.3、并行流操作
@Test
public void test03(){
long count = Stream.of(5,6,7,4,2,1,9)
.parallel()
.filter(s ->{
System.out.println(Thread.currentThread().getName() + ":" + s);
return s > 3;
}).count();
System.out.println(count);
}
5.3、并行流和串行流对比
我们通过for循环，串行Stream流，并行Stream流来对500000000亿个数字求和。来看消耗时间
public class StresmTest24 {
private static long times=500000000;
private long start;
@Before
public void before(){
start=System.currentTimeMillis();
}
@After
public void end(){
long end=System.currentTimeMillis();
System.out.println("消耗时间："+(end - start));
}
@Test
public void test01(){
System.out.println("普通for循坏：");
long res= 0;
for (int i = 0;i<times;i++){
res+=1;
}
}
@Test
public void test02(){
System.out.println("串行流：serialStream");
LongStream.rangeClosed(0,times).reduce(0,Long::sum);
}
@Test
public void test03(){
LongStream.rangeClosed(0,times)
.parallel().reduce(0,Long::sum);
}
}
5.4、线程安全
在多线程的处理下，肯定会出现数据安全问题。如下：
@Test
public void test01(){
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
list.add(i);
}
System.out.println(list.size());
List<Integer> listNew =new ArrayList<>();
list.parallelStream()
.forEach(listNew::add);
System.out.println(listNew.size());
}
这个会抛出异常
java.lang.ArrayIndexOutOfBoundsException
针对这个问题，我们的解决方案有哪些呢？
- 加同步锁
- 使用线程安全的容器
- 通过Stream中的toArray/collect操作
实现：
@Test
public void test02(){
List<Integer> listNew = new ArrayList<>();
Object obj = new Object();
IntStream.rangeClosed(1,1000)
.parallel()
.forEach(i->{
synchronized (obj){
listNew.add(i);
}
});
System.out.println(listNew.size());
}
@Test
public void test03(){
Vector v = new Vector();
Object obj = new Object();
IntStream.rangeClosed(1,1000)
.parallel()
.forEach(i->{
synchronized (obj){
v.add(i);
}
});
System.out.println(v.size());
}
@Test
public void test04(){
List<Integer> listNew = new ArrayList<>();
// 将线程不安全的容器包装为线程安全的容器
List<Integer> synchronizedList = Collections.synchronizedList(listNew);
Object obj = new Object();
IntStream.rangeClosed(1,1000)
.parallel()
.forEach(i->{
synchronizedList.add(i);
});
System.out.println(synchronizedList.size());
}
@Test
public void test05(){
List<Integer> listNew = new ArrayList<>();
Object obj = new Object();
List<Integer> list = IntStream.rangeClosed(1, 1000)
.parallel()
.boxed()
.collect(Collectors.toList());
System.out.println(list.size());
}
