一.概念理解
Stream可以由数组或集合创建,对流的操作分为两种:
- 中间操作,每次返回一个新的流,可以有多个。
- 终端操作,每个流只能进行一次终端操作,终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。
二、Stream的创建
public class StreamDemo {
public static void main(String[] args) {
// 集合
List<Integer> list = Arrays.asList(1, 2, 3);
// 集合创建一个顺序流
Stream<Integer> stream = list.stream();
// 集合创建一个并行流
Stream<Integer> parallelStream = list.parallelStream();
// 数组
int[] array = {1, 3, 5, 6, 8};
// 数组创建流方式
IntStream intStream = Arrays.stream(array);
}
}
stream和parallelStream的简单区分: stream是顺序流,由主线程按顺序对流执行操作,而parallelStream是并行流,内部以多线程并行执行的方式对流进行操作,但前提是流中的数据处理没有顺序要求
三.方法学习
1、遍历/匹配(foreach/find/match)
import java.util.*;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// foreach
list.forEach(System.out::println);
System.out.println("----------");
//find
Optional<Integer> firstData = list.stream().findFirst();
System.out.println(firstData.get());
System.out.println("----------");
//match: anyMatch有一个匹配就返回true noneMatch没有任何匹配才返回true allMatch所有匹配才返回true
System.out.println(list.stream().anyMatch(x -> x > 4));
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, 3000.0));
employeeList.add(new Employee("李四", 18, 5000.0));
employeeList.add(new Employee("王五", 28, 7000.0));
employeeList.add(new Employee("孙六", 38, 9000.0));
return employeeList;
}
}
执行程序返回
1
2
3
4
5
----------
1
----------
true
2、按条件匹配filter
import java.util.*;
import java.util.stream.Collectors;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> employeeList = initEmployee();
// 筛选年纪大于18岁的职工
List<Employee> employees = employeeList.stream().filter(s -> s.getAge() > 18).collect(Collectors.toList());
System.out.println(employees);
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, 3000.0));
employeeList.add(new Employee("李四", 18, 5000.0));
employeeList.add(new Employee("王五", 28, 7000.0));
employeeList.add(new Employee("孙六", 38, 9000.0));
return employeeList;
}
}
[Employee{name='王五', age=28, salary=7000.0}, Employee{name='孙六', age=38, salary=9000.0}]
3、聚合max、min、count
import java.util.*;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> employeeList = initEmployee();
// 获取薪水最高的职工
Optional<Employee> employeeOptional = employeeList.stream().max(Comparator.comparing(Employee::getSalary, Double::compareTo));
System.out.println(employeeOptional.get());
// 获取年级最小的职工
Optional<Employee> employeeOptional1 = employeeList.stream().min(Comparator.comparing(Employee::getAge, Integer::compareTo));
System.out.println(employeeOptional1.get());
// 获取年级大于18的职工数量
long count = employeeList.stream().filter(s -> s.getAge() > 18).count();
System.out.println(count);
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, 3000.0));
employeeList.add(new Employee("李四", 18, 5000.0));
employeeList.add(new Employee("王五", 28, 7000.0));
employeeList.add(new Employee("孙六", 38, 9000.0));
return employeeList;
}
}
Employee{name='孙六', age=38, salary=9000.0}
Employee{name='张三', age=8, salary=3000.0}
2
4、map与flatMap
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<String> list = Arrays.asList("a","b","c");
// map中把小写字母转换成大写
List<String> stringList = list.stream().map(String::toUpperCase).collect(Collectors.toList());
// 输出[A, B, C]
System.out.println(stringList);
}
}
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
String[] arr = {"z-h-a-n-g", "s-a-n"};
List<String> list = Arrays.asList(arr);
System.out.println(list);
// 将两个字符数组合并成一个新的字符数组
List<String> collect = list.stream().flatMap(x -> {
String[] array = x.split("-");
return Arrays.stream(array);
}).collect(Collectors.toList());
System.out.println(collect);
}
}
[z-h-a-n-g, s-a-n]
[z, h, a, n, g, s, a, n]
5、规约reduce
归约,也称缩减,顾名思义,是把一个流缩减成一个值,能实现对集合求和、求乘积和求最值操作。
import java.util.*;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> list = initEmployee();
// 求所有工资的和
Double sum = list.stream().map(Employee::getSalary).reduce(0.0, Double::sum);
System.out.println(sum);
// 求职工工资最大值
Optional<Double> max = list.stream().map(Employee::getSalary).reduce((a, b) -> a > b ? a : b);
System.out.println(max.get());
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, 3000.0));
employeeList.add(new Employee("李四", 18, 5000.0));
employeeList.add(new Employee("王五", 28, 7000.0));
employeeList.add(new Employee("孙六", 38, 9000.0));
return employeeList;
}
}
24000.0
9000.0
6、收集(toList、toSet、toMap)
import java.util.*;
import java.util.stream.Collectors;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> list = initEmployee();
// 返回名字做为key,工资做为value的map数据
Map<String, Double> employeeMap = list.stream().collect(Collectors.toMap(Employee::getName, Employee::getSalary));
System.out.println(employeeMap);
// 职工名字集合
List<String> employeeNameList = list.stream().map(Employee::getName).collect(Collectors.toList());
System.out.println(employeeNameList);
// 职工年龄集合
Set<Integer> ageSet = list.stream().map(s -> s.getAge()).collect(Collectors.toSet());
System.out.println(ageSet);
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, 3000.0));
employeeList.add(new Employee("李四", 18, 5000.0));
employeeList.add(new Employee("王五", 28, 7000.0));
employeeList.add(new Employee("孙六", 38, 9000.0));
return employeeList;
}
}
{李四=5000.0, 张三=3000.0, 王五=7000.0, 孙六=9000.0}
[张三, 李四, 王五, 孙六]
[18, 38, 8, 28]
7、collect
Collectors提供了一系列用于数据统计的静态方法:文章来源:https://www.toymoban.com/news/detail-471117.html
- 计数:count
- 平均值:averagingInt、averagingLong、averagingDouble
- 最值:maxBy、minBy
- 求和:summingInt、summingLong、summingDouble
- 统计以上所有:summarizingInt、summarizingLong、summarizingDouble
import java.util.*;
import java.util.stream.Collectors;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> employeeList = initEmployee();
// 统计职工人数
Long count = employeeList.stream().collect(Collectors.counting());
System.out.println(count);
// 获取职工最高工资
Optional<Double> salaryOptional = employeeList.stream().map(Employee::getSalary).collect(Collectors.maxBy((s1, s2) -> s1.compareTo(s2)));
System.out.println(salaryOptional);
// 获取职工平均工资
Double averageSalary = employeeList.stream().collect(Collectors.averagingDouble(Employee::getSalary));
System.out.println(averageSalary);
//一次性统计职工所有工资信息
DoubleSummaryStatistics summaryStatistics = employeeList.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
System.out.println(summaryStatistics);
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, 3000.0));
employeeList.add(new Employee("李四", 18, 5000.0));
employeeList.add(new Employee("王五", 28, 7000.0));
employeeList.add(new Employee("孙六", 38, 9000.0));
return employeeList;
}
}
4
Optional[9000.0]
6000.0
DoubleSummaryStatistics{count=4, sum=24000.000000, min=3000.000000, average=6000.000000, max=9000.000000}
8、分组(partitioningBy/groupingBy)
import java.util.*;
import java.util.stream.Collectors;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> employeeList = initEmployee();
// 将员工按薪资是否高于7000分组
Map<Boolean, List<Employee>> map = employeeList.stream().collect(Collectors.partitioningBy(s -> s.getSalary() > 7000));
System.out.println(map);
// 将职工按性别分组
Map<String, List<Employee>> employeeMap = employeeList.stream().collect(Collectors.groupingBy(Employee::getSex));
System.out.println(employeeMap);
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, "男", 3000.0));
employeeList.add(new Employee("李四", 18, "女", 5000.0));
employeeList.add(new Employee("王五", 28, "男", 7000.0));
employeeList.add(new Employee("孙六", 38, "女", 9000.0));
return employeeList;
}
}
{false=[Employee{name='张三', age=8, salary=3000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='王五', age=28, salary=7000.0}], true=[Employee{name='孙六', age=38, salary=9000.0}]}
{女=[Employee{name='李四', age=18, salary=5000.0}, Employee{name='孙六', age=38, salary=9000.0}], 男=[Employee{name='张三', age=8, salary=3000.0}, Employee{name='王五', age=28, salary=7000.0}]}
9、接合joining
joining可以将stream中的元素用特定的连接符(没有的话,则直接连接)连接成一个字符串。文章来源地址https://www.toymoban.com/news/detail-471117.html
import java.util.*;
import java.util.stream.Collectors;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> employeeList = initEmployee();
// 将职工姓名用逗号拼接返回
String nameData = employeeList.stream().map(Employee::getName).collect(Collectors.joining(","));
System.out.println(nameData);
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, "男", 3000.0));
employeeList.add(new Employee("李四", 18, "女", 5000.0));
employeeList.add(new Employee("王五", 28, "男", 7000.0));
employeeList.add(new Employee("孙六", 38, "女", 9000.0));
return employeeList;
}
}
张三,李四,王五,孙六
10、排序sorted
import java.util.*;
import java.util.stream.Collectors;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
List<Employee> employeeList = initEmployee();
// 将职工工资升序排序
List<Employee> employees = employeeList.stream().sorted(Comparator.comparing(Employee::getSalary)).collect(Collectors.toList());
System.out.println(employees);
// 将职工工资降序排序
List<Employee> list = employeeList.stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).collect(Collectors.toList());
System.out.println(list);
}
/**
* 初始化职工列表数据
*/
private static List<Employee> initEmployee() {
List<Employee> employeeList = new ArrayList<>();
employeeList.add(new Employee("张三", 8, "男", 3000.0));
employeeList.add(new Employee("李四", 18, "女", 5000.0));
employeeList.add(new Employee("王五", 28, "男", 7000.0));
employeeList.add(new Employee("孙六", 38, "女", 9000.0));
return employeeList;
}
}
[Employee{name='张三', age=8, salary=3000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='王五', age=28, salary=7000.0}, Employee{name='孙六', age=38, salary=9000.0}]
[Employee{name='孙六', age=38, salary=9000.0}, Employee{name='王五', age=28, salary=7000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='张三', age=8, salary=3000.0}]
11、提取/组合
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: 职工测试类
*/
public class EmployeeDemo {
public static void main(String[] args) {
String[] arr1 = {"a", "b", "c", "d"};
String[] arr2 = {"d", "e", "f", "g"};
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// 合并流
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
System.out.println(newList);
// 限制从流中获得前1个数据
System.out.println(Stream.of(arr1).limit(1).collect(Collectors.toList()));
// 跳过前2个数据
System.out.println(Stream.of(arr1).skip(2).collect(Collectors.toList()));
}
}
[a, b, c, d, e, f, g]
[a]
[c, d]
到了这里,关于Java8的Stream流的学习的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!