Stream API 主要操作：
筛选与切片
filter(Predicate) 筛选元素，从流中排除不满足Predicate的某些元素
limit(n) 截断流，使其元素不超过给定数量
skip(n) 跳过前面n个元素，若元素不足n个，则返回空流
distinct() 去重，通过流所生成元素的hashCode()与equals()去除重复元素
实体类
public class User {
private String name; // 姓名
private String age; // 年龄
private double salary; // 薪水
private Status status; // 工作状态：FREE 空闲， BUSY 繁忙 INVOCATION 休假
public enum Status {
BUSY, FREE, INVOCATION;
}
public User(){
}
public User(String name, String age, double salary, Status status) {
this.name = name;
this.age = age;
this.salary = salary;
this.status = status;
}
// Getter Setter equals hashCode toString
}
List<User> list = Arrays.asList(
new User("张三", 21, 6000, User.Status.BUSY),
new User("李四", 23, 7000, User.Status.FREE),
new User("王五", 25, 6000, User.Status.INVOCATION),
new User("赵六", 21, 10000, User.Status.BUSY),
new User("赵六", 21, 10000, User.Status.BUSY)
);
// filter 筛选出BUSY状态的员工
list.stream()
.filter(u -> User.Status.BUSY.equals(u.getStatus()))
.forEach(System.out::println);
/* 结果：
User{name='张三', age='21', salary=6000.0, status=BUSY}
User{name='赵六', age='21', salary=10000.0, status=BUSY}
User{name='赵六', age='21', salary=10000.0, status=BUSY}
*/
// 筛选出工资等于6000的一个员工
list.stream()
.filter(u -> u.getSalary() == 6000)
.limit(1)
.forEach(System.out::println);
/* 结果：
User{name='张三', age='21', salary=6000.0, status=BUSY}
*/
// 筛选工资等于6000，不是第一个员工的员工
list.stream()
.filter(u -> u.getSalary() == 6000)
.skip(1)
.forEach(System.out::println);
/* 结果：
User{name='王五', age='25', salary=6000.0, status=INVOCATION}
*/
// 员工列表去重
list.stream()
.distinct()
.forEach(System.out::println);
/* 结果：
User{name='张三', age='21', salary=6000.0, status=BUSY}
User{name='李四', age='23', salary=7000.0, status=FREE}
User{name='王五', age='25', salary=6000.0, status=INVOCATION}
User{name='赵六', age='21', salary=10000.0, status=BUSY}
*/
映射
map(Function<T, R>) 提取元素，使用Function应用到每个元素
flatMap(Function<T, Stream<R>>) 提取元素，应用每个元素得到每一个新的Stream，然后将这些Stream合并成新的Stream
public static void test() {
List<String> list = Arrays.asList("abc", "def", "ghi");
// 将每个元素(这里指的每个元素是指"abc", "def"这种)，转换成大写
list.stream()
.map(String::toUpperCase)
.forEach(System.out::print);
/* 结果：
ABCDEFGHI
*/
// 提取所有字符
// 步骤：应用每个元素,比如"abc"将其转换成Stream<Charactor>，然后得到三个Stream<Charactor>，最终合并到一个新的Stream<Character>，类似于list.addAll
list.stream()
.flatMap(Test::strToCharator) // ==> .flatMap(s -> strToCharator(s))
.forEach(System.out::print);
/* 结果：
abcdefghi
*/
}
public static Stream<Character> strToCharator(String s){
List<Character> list = new ArrayList<>();
for (char c : s.toCharArray()) {
list.add(c);
}
return list.stream();
}
重点说下区别：
Stream<Stream<Character>> characterStream = list.stream()
.map(Test::strToCharator);
characterStream.forEach(s -> s.forEach(System.out::println));
// s = Stream<Character> ，所有需要再迭代遍历一次，共两次
// 变化为 "abc","bcd", "ghi" --> {a, b, c}, {b, c, d}, {g, h , i} --> { {a, b, c}, {b, c, d}, {g, h , i} }
Stream<Character> characterStream2 = list.stream()
.flatMap(Test::strToCharator);
characterStream2.forEach(System.out::println);
// 变化为 "abc","bcd", "ghi" --> {a, b, c }, {b, c, d}, {g, h , i} --> {a,b,c,d,e,f,g,h,i}
类比于List list1， List list2
list1.add(list2) // 将list2作为list1的元素
list1.addAll(list2) // 将list2中所有元素放入到list1中
排序
sorted() 自然排序
sorted(Comparator) 自定义排序
List<String> list = Arrays.asList("bcd", "abe", "afa");
// 自然排序
list.stream()
.sorted()
.forEach(System.out::println);
// 按照string排序
list.stream()
.sorted(String::compareTo)
.forEach(System.out::println);
// 按照第二个元素排序
list.stream()
.sorted((s1, s2) -> Character.valueOf(s1.charAt(1)).compareTo( Character.valueOf(s2.charAt(1))))
.forEach(System.out::println);
// 等于上面，使用工具类 Comparator 更加方便
list.stream()
.sorted(Comparator.comparing(s -> s.charAt(1)))
.forEach(System.out::println);
查找与匹配
allMatch 流中所有元素都匹配成功，返回true
anyMatch 流中匹配一个元素即返回true
noneMatch 流中所有元素都不匹配，返回true，与allMatch相反
findFirst 返回流中匹配的第一个元素
findAny 返回流中匹配到的第一个元素，由于可能是parallelStream并行方式，所以不等于findFirst
count 返回流中元素个数
max 返回流中最大值
min 返回流中最小值
List<User> list = Arrays.asList(
new User("张三", 21, 6000, User.Status.BUSY),
new User("李四", 23, 7000, User.Status.FREE),
new User("王五", 25, 6000, User.Status.INVOCATION),
new User("赵六", 21, 10000, User.Status.BUSY)
);
// 1. 所有员工是否都处于BUSY状态
boolean b = list.stream().allMatch(u -> User.Status.BUSY.equals(u.getStatus())); // ==> false
// 更好的方式： list.stream().map(User::getStatus).allMatch(User.Status.BUSY::equals)
// 2. 至少有一个员工处理BUSY状态
boolean b2 = list.stream().map(User::getStatus).anyMatch(User.Status.BUSY::equals); // ==> true
// 3. 所有员工都不处于BUSY状态
boolean b3 = list.stream().map(User::getStatus).noneMatch(User.Status.BUSY::equals); // ==> false
// 4. 找出处于BUSY状态的第一个员工
Optional<User> firstUser = list.stream().filter(u -> User.Status.BUSY.equals(u.getStatus())).findFirst(); // firstUser.get() 张三
// 5. 找出任意一个处于BUSY状态的员工
Optional<User> anyUser = list.parallelStream().filter(u -> User.Status.BUSY.equals(u.getStatus())).findAny(); // anyUser.get() 赵六
// 6. 处于BUSY状态的员工数量
long count = list.stream().map(User::getStatus).filter(User.Status.BUSY::equals).count(); // ==> 2
// 7. 找到工资最高的员工
Optional<User> maxSalaryUser = list.stream().max(Comparator.comparingDouble(User::getSalary)); // maxSalaryUser.get() 赵六
// 8. 找到年龄最小的员工
Optional<User> minAgeUser = list.stream().min(Comparator.comparingInt(User::getAge)); // minAgeUser.get() 张三
归约与收集
reduce(T identity, BinaryOperator) / reduce(BinaryOperator) 可以将流中的元素反复结合起来，得到一个值
collect 将流转换成其他形式，接收
BinaryOperator extends BiFunction 所以是 T, T, R， 两个参数，一个返回值
reduce
List<User> list = Arrays.asList(
new User("张三", 21, 6000, User.Status.BUSY),
new User("李四", 23, 7000, User.Status.FREE),
new User("王五", 25, 6000, User.Status.INVOCATION),
new User("赵六", 21, 10000, User.Status.BUSY)
);
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 1. 数组所有元素求和
int sum = Arrays.stream(arr).reduce(0, (x, y) -> x + y); // 55
// 说明：这里identity=0，指代第一次运算的x=0,y=数组第一个元素，也就是1，如果identity=2，那么第一次就是x=2, y=1, 那么最终结果=56
// 由于有第一次运算默认值，所以这里一定有返回值，所以设计为返回int，假设没有初始值，也就是下面这种，不确定元素是否足够，返回Optional
OptionalInt optionalInt = Arrays.stream(arr).reduce((x, y) -> x + y); // optionalInt.getAsInt() == 55
// OptionalInt 为 Optional 专门为int的包装类，比Optional<Integer>性能更好，减少装箱拆箱操作
// 2. 计算所有员工工资总和
Optional<Double> sumSalary = list.stream().map(User::getSalary).reduce(Double::sum); // sumSalary.get()
map-reduce 这种思想应用很广，比如hadoop，提取然后计算
collect
List<User> list = Arrays.asList(
new User("张三", 21, 6000, User.Status.BUSY),
new User("李四", 23, 7000, User.Status.FREE),
new User("王五", 25, 6000, User.Status.INVOCATION),
new User("赵六", 21, 10000, User.Status.BUSY)
);
// ---------------------- 转换为集合 -------------------
// collect(Collector)，可以工具类Collectors生成Collector
// 1. 获取员工姓名列表
// 返回一个list
List<String> userNameList = list.stream().map(User::getName).collect(Collectors.toList());
// 返回set
Set<String> userNameSet = list.stream().map(User::getName).collect(Collectors.toSet());
// 返回hashSet
HashSet<String> userNameHashSet = list.stream().map(User::getName).collect(Collectors.toCollection(HashSet::new));
// ---------------------- 计算 ------------------------
// 2. 得到员工数量
// 总数
Long count = list.stream().collect(Collectors.counting()); // == list.stream().count()
// 工资大于5000员工数量
Long salaryConditionCount = list.stream().map(User::getSalary).filter(s -> s > 5000).collect(Collectors.counting()); // == filter().count()
// 3. 所有员工平均工资
Double averagSalary = list.stream().collect(Collectors.averagingDouble(User::getSalary));
// 4. 最高/最低工资
Optional<Double> maxSalary = list.stream().map(User::getSalary).collect(Collectors.maxBy(Double::compare)); // == map().max()
// -------------------- 分组 --------------------------
// 类似于SQL中的group by
// 5. 根据工作状态分组 （单级分组） { BUSY: List<User>, FREE: List<User> }
Map<User.Status, List<User>> userMapByStatus = list.stream().collect(Collectors.groupingBy(User::getStatus));
// 6. 先根据工作状态分组，再根据年龄分组 （多级分组）{ BUSY: {21 : List<User>, 23 : List<User>}, FREE : { 25 : List<User>, 26 : List<User> } }
Map<User.Status, Map<Integer, List<User>>> userMapByStatusAndAge = list.stream()
.collect(Collectors.groupingBy(User::getStatus, Collectors.groupingBy(User::getAge)));
// 7. 更多级分组
Map<User.Status, Map<Integer, Map<Double, List<User>>>> userMapByStatusAndAgeAndSalary = list.stream()
.collect(Collectors.groupingBy(User::getStatus, Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getSalary))));
// 8. 自定义分组，先按工作状态分组，再自定义下一次分组key，比如小于30岁，key为青年，大于30岁，key为中年
// ==> { BUSY : { "青年" : List<User>, "老年" : List<User> } }
list.stream().collect(Collectors.groupingBy(User::getStatus, Collectors.groupingBy(u -> {
User user = (User)u;
if (user.getAge() < 30) {
return "青年";
} else {
return "中年";
}
})));
// ------------------ 分区 ------------------------
// 特殊情况下的分组形式，分组条件结果为true/false，即 { true : List<xx>, false : List<xx> }
// 9. 将工资大于6000的分一个区，小于等的分一个区 ==> {true : List<工资大于6000的User>, false : List<工资小于等于6000的User> }
Map<Boolean, List<User>> partitionSalaryMap = list.stream().collect(Collectors.partitioningBy(u -> u.getSalary() > 6000));
// ------------------ 统计 -----------------------
// 返回一个统计结果相关的操作类，可用来得到最大值，最小值等等，当要获取一个集合的各项情况时，这种方式比较好，必须要生成多次流操作获取
DoubleSummaryStatistics summaryStatistics = list.stream().collect(Collectors.summarizingDouble(User::getSalary));
double summaryStatisticsSum = summaryStatistics.getSum(); // 总和，工资总数
long summaryStatisticsCount = summaryStatistics.getCount(); // 总的个数，员工数
double summaryStatisticsMax = summaryStatistics.getMax(); // 最高工资
double summaryStatisticsMin = summaryStatistics.getMin(); // 最低工资
double summaryStatisticsAverage = summaryStatistics.getAverage(); // 平均工资
扫一扫
907
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
