文章目录
- 概述
-
- [一、Stream 流的常见生成方式](#一、Stream 流的常见生成方式)
- [二、Stream 流中间操作方法](#二、Stream 流中间操作方法)
- [三、Stream 流终结操作方法](#三、Stream 流终结操作方法)
- [四、Stream 综合小练习](#四、Stream 综合小练习)
- 小结
概述
Stream 流是 Java8 新特性之一,我们在实际开发中借助 Stream 流搭配 Lambda 表达式,可以很方便的完成一些对集合的操作,可以显著的提升开发的效率和性能。
一、Stream 流的常见生成方式
通常我们会选择对以下类型生成 Stream 流:单列集合、双列集合、数组、零散的数据。
c
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);
}
}
二、Stream 流中间操作方法
1、常用中间操作方法
这里的中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作(其他中间操作或终结操作)
方法名 | 说明 |
---|---|
Stream filter(Predicate predicate) | 用于对流中的数据进行过滤 |
Stream limit(long maxSize) | 获取前几个元素 |
Stream skip(long n) | 跳过前几个元素 |
Stream distinct() | 元素去重,依赖(hashCode和equals方法) |
Stream sorted(Comparator<? super T> comparator) | Stream 流元素排序 |
static Stream concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
Stream map(Function<T,R> mapper) | 转换流中的数据类型 |
注 :Stream.contact
合并两个 stream
流的时候,如果一个 stream 是 a 类型,另一个 stream 是 b 类型,那么最终合并为 a,b的父类型(类型提升)。
2、使用示例1
c
public class FilterDemo {
// 获取以张开头的元素
public static void main(String[] args) {
// 创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
}
}
3、使用示例2
c
public class LimitAndSkipDemo {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
//需求1:取前3个数据在控制台输出
list.stream().limit(3).forEach(s-> System.out.println(s));
System.out.println("--------");
//需求2:跳过3个元素,把剩下的元素在控制台输出
list.stream().skip(3).forEach(s-> System.out.println(s));
System.out.println("--------");
//需求3:跳过2个元素,把剩下的元素中前2个在控制台输出
list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
}
}
4、使用示例3
c
public class SortedDemo {
// 按照年龄进行排序
public static void main(String[] args) {
ArrayList<String> manList = new ArrayList<>();
Collections.addAll(manList,"蔡坤坤,24","叶厚贤,23,","刘不甜,22","吴倩,24","谷加,30","肖亮亮,27");
manList.stream()
.sorted((o1,o2)->Integer.parseInt(o1.split(",")[1]) - Integer.parseInt(o2.split(",")[1]))
.forEach(x -> System.out.println(x));
}
}
5、使用示例4
c
public class ConcatAndDistinctDemo {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
//需求1:取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
//需求2:跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
//需求3:合并需求1和需求2得到的流,并把结果在控制台输出,要求字符串元素不能重复
Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));
}
}
6、使用示例5
c
public class MapDemo {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张翠山-40");
// 需求:只获取里面1的年龄并进行打印
List<Integer> collect = list.stream()
.map(s -> Integer.parseInt(s.split("-")[1]))
.collect(Collectors.toList());
System.out.println(collect);
}
}
7、Stream 流使用注意事项
注意1 :修改 Stream
流中的数据,不会影响原来集合或者数组中的数据。
注意2 :中间方法,返回新的 Stream
流,原来的 Stream 流只能使用一次,建议使用链式编程()。因为每次调用中间方法都会返回新的 Stream 流,原来的 Stream 流会关闭。如:
c
public class Test1 {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));
Stream<String> stream2 = stream1.filter(s -> s.length() == 3);
stream2.forEach(s -> System.out.println(s));
stream1.filter(s -> s.length() == 2);
}
}
三、Stream 流终结操作方法
1、常用终结方法
终结操作的意思是,执行完终结方法之后,Stream
流将不能再执行其他操作了。
方法名 | 说明 |
---|---|
void forEach(Consumer action) | 遍历 |
long count() | 统计个数 |
toArray() | 收集流中的数据,放到数组中 |
R collect(Collector collector) | 收集流中的数据,放到集合中 |
工具类 Collectors
提供了具体的收集方式:
方法名 | 说明 |
---|---|
public static Collector toList() | 把元素收集到List集合中 |
public static Collector toSet() | 把元素收集到Set集合中 |
public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |
注意1 :toSet()
会进行自动去重。
注意2 :toMap()
如果我们要收集到 Map 集合当中,键重复会报错。
2、使用示例1
c
public class CountAndForEachDemo {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
// 统计返回此流中的元素数
long count = list.stream().count();
System.out.println(count);
// 遍历打印流中元素
list.stream().forEach(x -> System.out.println(x));
}
}
3、使用示例2
c
public class ToArrayDemo {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
// 收集流中的数据,放到数组中 (Object 数组)
Object[] objects = list.stream().toArray();
System.out.println(Arrays.toString(objects));
// 收集流中的数据,放到数组中 (指定类型 数组)
// toArray 方法参数就是创建一个指定类型的数组
// 底层会依次得到流里面的每一个数据,并把数据放到数组当中
// 返回值就是一个装着流里面所有数据的数组
String[] strings = list.stream().toArray(valuecount -> new String[valuecount]);
System.out.println(Arrays.toString(strings));
}
}
4、使用示例3
c
public class CollectDemo {
public static void main(String[] args) {
//创建一个集合,存储多个字符串元素
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌-男-15","周芷若-女-14","赵敏-女-13","张三丰-男-100","谢广坤-男-41");
// 需求1:把所有男性收集到list集合当中
List<String> newList1 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toList());
System.out.println(newList1);
// 需求2:把所有男性收集到set集合当中
Set<String> newList2 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toSet());
System.out.println(newList2);
// 需求3:把所有男性收集到map集合当中(键为姓名,值为年龄)
Map<String, Integer> map = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(
s -> s.split("-")[0],
s -> Integer.parseInt(s.split("-")[2])));
System.out.println(map);
}
}
5、Stream 基本分组功能
方法名 | 说明 |
---|---|
Collector<T, ?, Map<K, List>> groupingBy(Function<? super T, ? extends K> classifier) | 这是最基本的 groupingBy 方法,classifier:键映射:该方法的返回值是键值对的 键 |
Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) | 这个重载方法在基本的 groupingBy 方法的基础上添加了一个 downstream 参数,downstream:值映射:通过聚合方法将同键下的结果聚合为指定类型,该方法返回的是键值对的 值 |
Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier, Supplier mapFactory, Collector<? super T, A, D> downstream) | 这个重载方法除了包含分类函数和 downstream 收集器外,还接收一个 mapFactory 参数,mapFactory:无参构造函数提供返回类型:提供一个容器初始化方法,用于创建新的 Map容器 (使用该容器存放值对) |
c
public class GroupDemo {
// 基本分组操作
public static void main(String[] args) {
// 初始化数据
Actor actor1 = new Actor("张三",18);
Actor actor2 = new Actor("李四",20);
Actor actor3 = new Actor("王五",22);
List<Actor> actors = new ArrayList<>();
Collections.addAll(actors,actor1,actor2,actor3);
// 按照姓名分组
Map<String, List<Actor>> collect = actors.stream().collect(Collectors.groupingBy(actor -> actor.getName()));
// 打印结果
System.out.println(collect);
// 将不同课程的学生进行分类
Map<String, List<Actor>> groupByCourse = actors.stream().collect(Collectors.groupingBy(actor -> actor.getName()));
System.out.println(groupByCourse
);
Map<String, List<Actor>> groupByCourse1 = actors.stream().collect(Collectors.groupingBy(actor -> actor.getName(), Collectors.toList()));
System.out.println(groupByCourse1);
// 上面的方法中容器类型和值类型都是默认指定的,容器类型为:HashMap,值类型为:ArrayList
// 可以通过下面的方法自定义返回结果、值的类型
Map<String, List<Actor>> groupByCourse2 = actors.stream()
.collect(Collectors.groupingBy(actor -> actor.getName(),
() -> new HashMap<>(),
Collectors.toList()));
System.out.println(groupByCourse2);
}
}
其他分组操作参考 :Stream Collectors.groupingBy 的四种用法
四、Stream 综合小练习
c
public class Test {
public static void main(String[] args) {
// 现有两个 ArrayList 集合:
// 第一个集合:存储 6 名男演员的名字和年龄;第二个集合:存储 6 名女演员的名字和年龄
ArrayList<String> manList = new ArrayList<>();
ArrayList<String> womanList = new ArrayList<>();
Collections.addAll(manList,"蔡坤坤,24","叶厚贤,23,","刘不甜,22","吴倩,24","谷加,30","肖亮亮,27");
Collections.addAll(womanList,"赵晓英,35","杨颖,36","高媛媛,43","刘诗,35","杨小敏,33");
// 需求1:男演员只要名字为 3 个字的前两人
Stream<String> stream1 = manList.stream().filter(s -> s.split(",")[0].length() == 3)
.limit(2);
// 需求2:女演员只要姓杨的,并且不要第一个
Stream<String> stream2 = womanList.stream().filter(s -> s.split(",")[0].startsWith("杨"))
.skip(1);
// 需求3:把过滤后的男演员姓名和女演员合并到一起封装成 Actor 对象(Actor 对象属性有 name、age)
Stream<Actor> stream3 = Stream.concat(stream1, stream2)
.map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])));
// 需求5:将所有的演员对象都报存到 List 集合中
stream3.collect(Collectors.toList()).forEach(s -> System.out.println(s));
}
}
小结
Stream 流的使用步骤?
- 获取 Stream 流对象
- 使用中间方法处理数据
- 使用终结方法处理数据
如何获取 Stream 流对象?
- 单列集合:Collection 中的默认方法
- 双列集合:不能直接获取,可借助 keySets、values 转换成单列集合间接获取
- 数组:Arrays 工具类型中的静态方法
- 零散的数据:Stream 接口中的静态方法 of
Stream 常见方法?
- 中间方法:filter、limit、skip、distinct、concat、map
- 终结方法:forEach、count、collect
Lambda 怎么简化?
- 首先,数据类型可以省略
- 如果形参只有一个,小括号可以省略
- 如果形参有多个,小括号就不能省略了
- 如果方法体只有一行,那么大括号可以省略,return 可以省略分号可以省略
注:上述所有方法皆为函数式接口,因此均可以使用 Lambda 表达式进行替换,或使用方法引用替换(下期介绍)。