以下代码使用JDK11编写。
(1)案例需求
按照下面的要求完成集合的创建和遍历
(2)原始方式示例代码
public class StreamDemo01 {
public static void main(String[] args) {
//集合的批量添加
ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
//list.add()
//遍历list1把以张开头的元素添加到list2中。
ArrayList<String> list2 = new ArrayList<>();
for (String s : list1) {
if(s.startsWith("张")){
list2.add(s);
}
}
//遍历list2集合,把其中长度为3的元素,再添加到list3中。
ArrayList<String> list3 = new ArrayList<>();
for (String s : list2) {
if(s.length() == 3){
list3.add(s);
}
}
for (String s : list3) {
System.out.println(s);
}
}
}
(3)使用Stream流示例代码
public class StreamDemo01 {
public static void main(String[] args) {
//集合的批量添加
ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
//Stream流
list1.stream().filter(s->s.startsWith("张"))
.filter(s->s.length() == 3)
.forEach(s-> System.out.println(s));
}
}
(4)Stream流的好处
(1)Stream流的思想
(2)Stream流的三类方法
(3)生成Stream流的方式
Collection体系集合:使用默认方法stream()生成流, default Stream stream()
Map体系集合:把Map转成Set集合,间接的生成流
数组:通过Arrays中的静态方法stream生成流
同种数据类型的多个数据:通过Stream接口的静态方法of(T… values)生成流
(4)代码演示
public class StreamDemo {
public static void main(String[] args) {
//Collection体系的集合可以使用默认方法stream()生成流
List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();
//Map体系的集合间接的生成流
Map<String,Integer> map = new HashMap<String, Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
//数组可以通过Arrays中的静态方法stream生成流
String[] strArray = {"hello","world","java"};
Stream<String> strArrayStream = Arrays.stream(strArray);
//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> intStream = Stream.of(10, 20, 30);
}
}
(5)详细操作
单列集合(Collection体系集合)
public class StreamDemo02 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
System.out.println("---------------一条语句:生成流并进行相关操作------------");
list.stream()
.forEach(s -> System.out.println(s));
System.out.println("---------------把上面的一条语句进行拆分------------------");
// 获取到一条流水线,并把集合中的数据放到流水线上
Stream<String> stream1 = list.stream();
// 使用终结方法打印一下流水线上的所有数据
stream1.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
// s:依次表示流水线上的每一个数据
System.out.println(s);
}
});
}
}
双列集合(Map体系的集合间接的生成流)
public class StreamDemo03 {
public static void main(String[] args) {
// 1.创建双列集合
HashMap<String,Integer> hm = new HashMap<>();
// 2.添加数据
hm.put("aaa",111);
hm.put("bbb",222);
hm.put("ccc",333);
hm.put("ddd",444);
// 3.第一种获取stream流,只获取到了key
hm.keySet().stream().forEach(s -> System.out.println(s));
// 4.第二种获取stream流,可以获取到key和value
hm.entrySet().stream().forEach(s-> System.out.println(s));
}
}
数组(数组可以通过Arrays中的静态方法stream生成流)
public class StreamDemo04 {
public static void main(String[] args) {
// 1.创建数组
int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
String[] arr2 = {"a","b","c"};
// 2.获取stream流
Arrays.stream(arr1).forEach(s-> System.out.println(s));
System.out.println("--------------------------------");
Arrays.stream(arr2).forEach(s-> System.out.println(s));
System.out.println("--------------------------------");
/**
* 注意:
* Stream接口中静态方法of的细节:
* 方法的形参是一个可变参数,可以传递一堆零散的数据,也可以传递数组
* 但是数组必须是引用数据类型的,如果传递基本数据类型,是会把整个数组当做一个元素,放到Stream当中。
*/
Stream.of(arr1).forEach(s-> System.out.println(s)); // 输出[I@17f6480
}
}
一堆零散数据(同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)
生成流)
public class StreamDemo05 {
public static void main(String[] args) {
// 基本类型
Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
// 引用类型
Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));
}
}
注意1:如果是直接操作Stream流(如Stream.concat(stream1, stream2),而不是使用集合的stream格式,如list.stream()),中间方法返回的是新的Stream流,原来的Stream流只能使用一次。例如,用filter、limit、skip、concat、distinct、map等中间操作后,stream对象就无法再次被操作。建议使用链式编程或者把中间操作的结果存储到新的stream变量中再使用。
注意2:修改Stream流中的数据,不会影响原来集合或者数组中的数据
(1)概念:中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作
(2)常见方法
方法名 | 说明 |
---|---|
Stream filter(Predicate predicate) | 用于对流中的数据进行过滤 |
Stream limit(long maxSize) | 返回此流中的元素组成的流,截取前指定参数个数的数据 |
Stream skip(long n) | 跳过指定参数个数的数据,返回由该流的剩余元素组成的流 |
static Stream concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
Stream distinct() | 返回由该流的不同元素(根据Object.equals(Object) )组成的流 |
Stream map(Function<T,R> mapper) | 转换流中的数据类型 |
(3)filter代码演示
public class StreamDemo06 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// 1、把张开头且字符串长度为3的留下,其余数据过滤不要
System.out.println("--------filter过滤:匿名内部类格式---------");
list.stream()
.filter(new Predicate<String>() {
@Override
public boolean test(String s) {
//如果返回值为true,表示当前数据留下
//如果返回值为false,表示当前数据舍弃不要
return s.startsWith("张")&&s.length()==3;
}
})
.forEach(s -> System.out.println(s));
System.out.println("--------filter过滤:Lambda表达式格式---------");
list.stream()
.filter(s -> s.startsWith("张"))
.filter(s -> s.length() == 3)
.forEach(s -> System.out.println(s));
System.out.println("--------filter过滤:Lambda表达式格式---------");
}
}
(4)limit&skip代码演示
public class StreamDemo06 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
System.out.println("----limit获取前几个元素----");
list.stream().limit(3).forEach(s -> System.out.println(s));
System.out.println("----skip跳过前几个元素----");
list.stream().skip(4) .forEach(s -> System.out.println(s));
System.out.println("----练习:思路1----");
/**
* 课堂练习:获取 "张强", "张三丰", "张翠山"
*
* 第一种思路:先获取前面6个元素:"张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山",
* 然后跳过前面3个元素
*/
list.stream().limit(6).skip(3).forEach(s -> System.out.println(s));
/**
* 第二种思路:
* 先跳过3个元素:"张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤"
* 然后再获取前面3个元素:"张强", "张三丰", "张翠山"
*/
System.out.println("----练习:思路2----");
list.stream().skip(3).limit(3).forEach(s -> System.out.println(s));
}
}
(5)concat&distinct代码演示
public class StreamDemo07 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "张无忌","张无忌","张无忌", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2, "周芷若", "赵敏");
System.out.println("----------------distinct元素去重---------");
list1.stream().distinct().forEach(s -> System.out.println(s));
System.out.println("----------------concat合并a和b两个流为一个流---------");
Stream.concat(list1.stream(),list2.stream()).forEach(s -> System.out.println(s));
}
}
(6)map代码演示
public class StreamDemo08 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-15", "周芷若-14", "赵敏-13", "张强-20", "张三丰-100", "张翠山-40", "张良-35", "王二麻子-37", "谢广坤-41");
//需求:获取里面的年龄并进行打印
System.out.println("--------map转换流中的数据类型:匿名内部类格式---------");
/**
* 第一个类型:流中原本的数据类型
* 第二个类型:要转成之后的类型
* apply的形参s:依次表示流里面的每一个数据,其返回值表示转换之后的数据
* 当map方法执行完毕之后,流上的数据就变成了整数
* 所以在下面forEach当中,s依次表示流里面的每一个数据,这个数据现在就是整数了
*/
list.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
String[] arr = s.split("-");
String ageString = arr[1];
int age = Integer.parseInt(ageString);
return age;
}
}).forEach(s-> System.out.println(s));
System.out.println("--------map转换流中的数据类型:Lambda表达式格式---------");
list.stream()
.map(s ->Integer.parseInt(s.split("-")[1]))
.forEach(s-> System.out.println(s));
}
}
(1)概念:终结操作的意思是执行完此方法之后,Stream流将不能再执行其他操作
(2)常见方法
方法名 | 说明 |
---|---|
void forEach(Consumer action) | 对此流的每个元素执行操作 |
long count() | 返回此流中的元素数 |
toArray() | 收集流中的数据,放到数组中 |
R collect(Collector collector) | 收集流中的数据,放到集合中 |
(3)代码演示
forEach
public class StreamDemo09 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
/**
* void forEach(Consumer action) 遍历
* Consumer的泛型:表示流中数据的类型
* accept方法的形参s:依次表示流里面的每一个数据
* 方法体:对每一个数据的处理操作(打印)
*/
System.out.println("---------forEach:匿名内部类方式-----------");
list.stream().forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("---------forEach:Lambda表达式方式-----------");
list.stream().forEach(s -> System.out.println(s));
}
}
count
public class StreamDemo09 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// long count()统计
System.out.println("---------count()统计-----------");
long count = list.stream().count();
System.out.println(count);
}
}
(1)概念:对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中
(2)常用方法
方法名 | 说明 |
---|---|
toArray() | 收集流中的数据,放到数组中 |
R collect(Collector collector) | 把结果收集到集合中 |
(3)工具类Collectors提供了具体的收集方式
方法名 | 说明 |
---|---|
public static Collector toList() | 把元素收集到List集合中 |
public static Collector toSet() | 把元素收集到Set集合中 |
public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |
(4)收集到数组中
public class StreamDemo10 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰", "张翠山", "张良", "王二麻子", "谢广坤");
// 需求:收集流中的数据,放到数组中-toArray()
System.out.println("---------toArray():匿名内部类方式-----------");
/**
* IntFunction的泛型:具体类型的数组
* apply的形参:流中数据的个数,要跟数组的长度保持一致
* apply的返回值:具体类型的数组
* 方法体:就是创建数组
*
* toArray方法的参数的作用:负责创建一个指定类型的数组
* toArray方法的底层,会依次得到流里面的每一个数据,并把数据放到数组当中
* toArray方法的返回值:是一个装着流里面所有数据的数组
*/
String[] arr = list.stream().toArray(new IntFunction<String[]>() {
@Override
public String[] apply(int value) {
return new String[value];
}
});
System.out.println(Arrays.toString(arr));
System.out.println("---------toArray():Lambda表达式方式-----------");
String[] arr2 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr2));
}
}
(5)收集到集合中
注:如果要收集到Map集合当中,键不能重复,否则会报错
package com.ya.mystream;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* Stream流的收集操作:collect(Collector collector) 收集流中的数据,放到集合中 (List Set Map)
*/
public class StreamDemo11 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
"张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");
System.out.println("--------收集List集合当中-----------");
//把所有的男性收集起来,放到List集合当中
List<String> newList1 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toList());
System.out.println(newList1);
System.out.println("--------收集Set集合当中-----------");
//把所有的男性收集起来,放到Set集合当中
Set<String> newList2 = list.stream().filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toSet());
System.out.println(newList2);
System.out.println("--------收集Map集合当中:匿名内部类方式-----------");
/**
* 把所有的男性收集起来,放到Map集合当中
* 键:姓名。 值:年龄
*/
Map<String, Integer> map = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
/*
* toMap : 参数一表示键的生成规则
* 参数二表示值的生成规则
*
* 参数一:
* Function泛型一:表示流中每一个数据的类型
* 泛型二:表示Map集合中键的数据类型
*
* 方法apply形参:依次表示流里面的每一个数据
* 方法体:生成键的代码
* 返回值:已经生成的键
*
*
* 参数二:
* Function泛型一:表示流中每一个数据的类型
* 泛型二:表示Map集合中值的数据类型
*
* 方法apply形参:依次表示流里面的每一个数据
* 方法体:生成值的代码
* 返回值:已经生成的值
*
* */
.collect(Collectors.toMap(
// key
new Function<String, String>() {
@Override
public String apply(String s) {
//张无忌-男-15
return s.split("-")[0];
}
},
// value
new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s.split("-")[2]);
}
}));
System.out.println(map);
System.out.println("--------收集Map集合当中:Lambda表达式方式-----------");
Map<String, Integer> map2 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(
// key
s -> s.split("-")[0],
// value
s -> Integer.parseInt(s.split("-")[2])));
System.out.println(map2);
}
}
public class Test1 {
public static void main(String[] args) {
//1. 定义一个集合
ArrayList<Integer> list = new ArrayList<>();
//2.添加一些整数
Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
//3.过滤奇数,只留下偶数
//进行判断,如果是偶数,返回true 保留
List<Integer> newList = list.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
//4.打印集合
System.out.println(newList);
}
}
public class Test2 {
public static void main(String[] args) {
//1.创建一个ArrayList集合
ArrayList<String> list = new ArrayList<>();
//2.添加以下字符串
list.add("zhangsan,23");
list.add("lisi,24");
list.add("wangwu,25");
//3.保留年龄大于等于24岁的人
System.out.println("--------收集为Map集合:匿名内部类方式--------");
Map<String, Integer> map = list.stream()
.filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
.collect(Collectors.toMap(
// key
new Function<String, String>() {
@Override
public String apply(String s) {
return s.split(",")[0];
}
},
// value
new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s.split(",")[1]);
}
}));
System.out.println(map);
System.out.println("--------收集为Map集合:Lambda表达式方式--------");
Map<String, Integer> map1 = list.stream()
.filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
.collect(Collectors.toMap(
// key
s -> s.split(",")[0],
// value
s -> Integer.parseInt(s.split(",")[1])));
System.out.println(map1);
}
}
案例需求
现在有两个ArrayList集合,分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄。
姓名和年龄中间用逗号隔开。
比如:张三,23
要求完成如下的操作:
1,男演员只要名字为3个字的前两人
2,女演员只要姓杨的,并且不要第一个
3,把过滤后的男演员姓名和女演员姓名合并到一起
4,将上一步的演员信息封装成Actor对象。
5,将所有的演员对象都保存到List集合中。
备注:演员类Actor,属性有:name,age
男演员: "蔡坤坤,24" , "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27"
女演员: "赵小颖,35" , "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33"
代码实现
演员类
public class Actor {
private String name;
private int age;
public Actor() {
}
public Actor(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Actor{name = " + name + ", age = " + age + "}";
}
}
测试类
public class Test3 {
public static void main(String[] args) {
//1.创建两个ArrayList集合
ArrayList<String> manList = new ArrayList<>();
ArrayList<String> womenList = new ArrayList<>();
//2.添加数据
Collections.addAll(manList, "蔡坤坤,24", "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
Collections.addAll(womenList, "赵小颖,35", "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");
//3.男演员只要名字为3个字的前两人
Stream<String> stream1 = manList.stream()
.filter(s -> s.split(",")[0].length() == 3)
.limit(2);
//4.女演员只要姓杨的,并且不要第一个
Stream<String> stream2 = womenList.stream()
.filter(s -> s.split(",")[0].startsWith("杨"))
.skip(1);
//5.把过滤后的男演员姓名和女演员姓名合并到一起
//演员信息封装成Actor对象,String -> Actor对象 (类型转换,使用map中间操作方法)
// 注意:这里只能使用一个方式,两个方式同时打开运行会报错“IllegalStateException: stream has already been operated upon or closed”
// 因为stream1, stream2已经被操作过了,不是原来的stream1, stream2了
/*System.out.println("-------------匿名内部类方式--------------");
List<Actor> list = Stream.concat(stream1, stream2).map(new Function<String, Actor>() {
@Override
public Actor apply(String s) {
String name = s.split(",")[0];
int age = Integer.parseInt(s.split(",")[1]);
return new Actor(name, age);
}
}).collect(Collectors.toList());
System.out.println(list);*/
System.out.println("-------------Lambda表达式方式--------------");
List<Actor> list1 = Stream.concat(stream1, stream2)
.map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
.collect(Collectors.toList());
System.out.println(list1);
}
}