共计 5918 个字符,预计需要花费 15 分钟才能阅读完成。
简介
Stream 是 Java 8 引入的一个功能强大的流式处理 API。它允许我们以声明性的方式操作集合(数组、集合等)的元素。通过使用 Stream,我们可以将多个操作连接起来,形成一个流水线,从而简化代码并提高可读性。
Stream 类中包含的方法,可以进行数据筛选、转换、排序、去重、限制、跳过、归约、统计、匹配、查找和遍历等操作。
数据筛选和转换:
filter(Predicate<T> predicate)
:根据指定条件过滤流中的元素。map(Function<T, R> mapper)
:对流中的元素进行映射操作,转换为另一种类型。flatMap(Function<T, Stream<R>> mapper)
:对流中的元素进行映射操作,将每个元素映射为一个流,并将所有流的元素合并成一个流。
数据排序和去重:
sorted()
:对流中的元素进行排序操作。distinct()
:去除流中的重复元素。
数据归约和统计:
count()
:返回流中的元素数量。reduce(BinaryOperator<T> accumulator)
:对流中的元素进行归约操作,得到一个最终结果。collect(Collector<T, A, R> collector)
:将流中的元素收集到一个集合或其他数据结构中。
数据匹配和查找:
max(Comparator<T> comparator)
:返回流中的最大元素。min(Comparator<T> comparator)
:返回流中的最小元素。findFirst()
:返回流中的第一个元素。findAny()
:返回流中的任意一个元素。anyMatch(Predicate<T> predicate)
:检查流中是否存在满足条件的元素。allMatch(Predicate<T> predicate)
:检查流中的所有元素是否都满足条件。noneMatch(Predicate<T> predicate)
:检查流中是否没有任何元素满足条件。
数据限制和跳过:
limit(long maxSize)
:限制流中元素的数量。skip(long n)
:跳过流中的前 n 个元素。
其他方法:
forEach(Consumer<T> action)
:对流中的每个元素执行指定的操作。
使用
1. 数据筛选和转换
数据的筛选和转换用得最多的当属 filter 和 map 方法。
1.1 filter
根据指定的条件过滤流中的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(evenNumbers); // 输出结果:[2, 4, 6]
1.2 map
对流中的元素进行映射操作,将其转换为另一种类型。
List<String> names = Arrays.asList("John", "Jane", "Tom");
List<Integer> nameLengths = names.stream()
.map(String::length)
.collect(Collectors.toList());
System.out.println(nameLengths); // 输出结果:[4, 4, 3]
2. 数据排序和去重
数据的排序和去重用得也是比较多的方法。
2.1 sorted
对流中的元素进行排序操作。
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 6);
List<Integer> sortedNumbers = numbers.stream()
.sorted()
.collect(Collectors.toList());
System.out.println(sortedNumbers);v // 输出结果:[1, 2, 5, 6, 8]
2.2 distinct
去除流中重复的元素。
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 4, 5);
List<Integer> distinctNumbers = numbers.stream()
.distinct()
.collect(Collectors.toList());
System.out.println(distinctNumbers); // 输出结果:[1, 2, 3, 4, 5]
3. 数据归约和统计
3.1 count
返回流中的元素数量。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
long count = numbers.stream()
.count();
System.out.println(count); // 输出结果:5
3.2 reduce
对流中的元素进行归约操作,将流中的元素通过指定的操作进行组合,得到一个最终结果。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream()
.reduce((a, b) -> a + b);
System.out.println(sum.orElse(0)); // 输出结果:15
3.3 collect
用于将流中的元素收集到一个集合或其他数据结构中。
将流元素收集到 List 中
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> collectedList = numbers.stream()
.collect(Collectors.toList());
System.out.println(collectedList);
将流元素收集到 Set 中
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 4, 5);
Set<Integer> collectedSet = numbers.stream()
.collect(Collectors.toSet());
System.out.println(collectedSet);
将流元素收集到 Map 中
List<String> names = Arrays.asList("John", "Jane", "Tom");
Map<String, Integer> nameLengthMap = names.stream()
.collect(Collectors.toMap(
name -> name,
name -> name.length()
));
System.out.println(nameLengthMap); // 输出结果:{John=4, Jane=4, Tom=3}
根据某个属性对流中的元素进行分组
Person 类
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
可以根据年龄对 Person 对象进行分组:
List<Person> persons = Arrays.asList(
new Person("John", 25),
new Person("Jane", 30),
new Person("Tom", 22),
new Person("Alice", 30)
);
Map<Integer, List<Person>> ageGroupMap = persons.stream()
.collect(Collectors.groupingBy(Person::getAge));
System.out.println(ageGroupMap); // 输出结果:{22=[Person{name='Tom', age=22}], 25=[Person{name='John', age=25}], 30=[Person{name='Jane', age=30}, Person{name='Alice', age=30}]}
将流元素收集到自定义的容器中
自定义的容器类 PersonContainer
public class PersonContainer {
private List<Person> persons = new ArrayList<>();
public void addPerson(Person person) {
persons.add(person);
}
public List<Person> getPersons() {
return persons;
}
}
示例代码:
List<Person> persons = Arrays.asList(
new Person("John", 25),
new Person("Jane", 30),
new Person("Tom", 22)
);
PersonContainer container = persons.stream()
.collect(
PersonContainer::new,
PersonContainer::addPerson,
PersonContainer::addPerson
);
List<Person> collectedPersons = container.getPersons();
System.out.println(collectedPersons); // 输出结果:[Person{name='John', age=25}, Person{name='Jane', age=30}, Person{name='Tom', age=22}]
4. 数据匹配和查找
4.1 max
返回流中的最大的元素,返回是一个 Optional 类。
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 6);
Optional<Integer> maxNumber = numbers.stream()
.max(Integer::compareTo);
System.out.println(maxNumber.orElse(0)); // 输出 8
4.2 min
返回流中的最小的元素,返回是一个 Optional 类。
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 6);
Optional<Integer> minNumber = numbers.stream()
.min(Integer::compareTo);
System.out.println(minNumber.orElse(0)); // 输出 1
4.3 findFirst
返回流中的第一个元素(按照流的遍历顺序),返回是一个 Optional 类。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstNumber = numbers.stream()
.findFirst();
System.out.println(firstNumber.orElse(0)); // 输出 1
4.4 findAny
返回流中的任意一个元素,返回是一个 Optional 类。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> anyNumber = numbers.stream()
.findAny();
System.out.println(anyNumber.orElse(0)); // 输出结果:1(可能的结果因为随机性而有所不同)
4.5 anyMatch
检查流中是否存在满足给定条件的元素,返回是一个布尔值。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean hasEvenNumber = numbers.stream()
.anyMatch(n -> n % 2 == 0);
System.out.println(hasEvenNumber); // 输出结果:true
4.6 anyMatch
检查流中的所有元素是否都满足给定条件,返回是一个布尔值。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean allEvenNumbers = numbers.stream()
.allMatch(n -> n % 2 == 0);
System.out.println(allEvenNumbers); // 输出结果:false
4.7 noneMatch
检查流中是否没有任何元素满足给定条件。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean noNegativeNumbers = numbers.stream()
.noneMatch(n -> n < 0);
System.out.println(noNegativeNumbers); // 输出结果:true
5. 数据限制和跳过
5.1 limit
限制流中元素的数量。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> limitedNumbers = numbers.stream()
.limit(3)
.collect(Collectors.toList());
System.out.println(limitedNumbers); // 输出结果:[1, 2, 3]
5.2 skip
跳过流中的前 n 个元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> skippedNumbers = numbers.stream()
.skip(2)
.collect(Collectors.toList());
System.out.println(skippedNumbers);
6. 其他方法
6.1 forEach
对流中的每个元素执行指定的操作。
List<String> names = Arrays.asList("John", "Jane", "Tom");
names.stream()
.forEach(System.out::println);
提醒:本文发布于415天前,文中所关联的信息可能已发生改变,请知悉!