93 lines
3.1 KiB
Markdown
93 lines
3.1 KiB
Markdown
---
|
|
title: Streams
|
|
---
|
|
# Streams
|
|
|
|
In Java 8 Streams got added as a new feature the Java toolbox. Streams allow you to quickly and cleanly process Collections.
|
|
|
|
Please read the chapter about lambdas and functional programming before continuing.
|
|
|
|
## How it works
|
|
The Stream loops the elements of the collection for you.
|
|
Each intermediate and the terminal operation are called for each object.
|
|
Once all operations are finished for the first objects, then the second object is loaded.
|
|
|
|
## Important Methods
|
|
### Creation
|
|
- `Collection.stream()`: create a Stream from any object from any class implementing `Collection`
|
|
- `Arrays.stream(array)`: create a Stream from an Array
|
|
|
|
### Intermediate Operations
|
|
These operations convert the Stream Objects somehow.
|
|
- `Stream.map(Function<In,Out> function)`: apply a Function to convert In to Out
|
|
- `Stream.filter(Predicate<In> predicate)`: remove Objects from Stream for which the Predicate does not test true
|
|
- `Stream.distinct()`: remove Objects from Stream which are duplicates
|
|
- `Stream.sorted()`: sort the Objects in the Stream
|
|
- `Stream.limit(int n)`: end Stream after n Objects
|
|
|
|
### Terminal Operations
|
|
These operations receive the Stream Objects and end the Stream.
|
|
- `Stream.collect(Collector<In,?,Out> collector)`: collect all Objects in Stream into Object
|
|
- `Stream.forEach(Consumer<In> consumer)`: consume all Objects in Stream using the consumer function
|
|
- `Stream.count()`: count all Objects in Stream
|
|
- `Stream.findFirst()`: return the first Object of the Stream and stop
|
|
- `Stream.anyMatch(Predicate<In> predicate)`: return true if any Object in the Stream tests true for the Predicate
|
|
- `Stream.allMatch(Predicate<In> predicate)`: return true if all Object in the Stream test true for the Predicate
|
|
|
|
## Examples
|
|
|
|
```java
|
|
// print the length of all Strings in a List
|
|
for (String string : Arrays.asList("abc", "de", "f", "abc")) {
|
|
int length = string.length();
|
|
System.out.println(length);
|
|
}
|
|
|
|
Arrays.asList("abc", "de", "f", "abc")
|
|
.stream()
|
|
.map(String::length)
|
|
.forEach(System.out::println);
|
|
|
|
// output: 3 2 1 3
|
|
```
|
|
|
|
```java
|
|
// print all Strings in a List with a Length greater than 2
|
|
for (String string : Arrays.asList("abc", "de", "f", "abc")) {
|
|
if (string.length() > 2) {
|
|
System.out.println(string);
|
|
}
|
|
}
|
|
|
|
Arrays.asList("abc", "de", "f", "abc")
|
|
.stream()
|
|
.filter(string -> string.length() > 2)
|
|
.forEach(System.out::println);
|
|
|
|
// output: abc abc
|
|
```
|
|
|
|
```java
|
|
// create a sorted List with all unique Strings from another List which are longer than or requal 2
|
|
List<String> result = new ArrayList<>();
|
|
for (String string : Arrays.asList("de", "abc", "f", "abc")) {
|
|
if (string.length() >= 2
|
|
&& ! result.contains(string)) {
|
|
result.add(string);
|
|
}
|
|
}
|
|
Collections.sort(result);
|
|
|
|
List<String> result2 = Arrays.asList("de", "abc", "f", "abc")
|
|
.stream()
|
|
.filter(string -> string.length() >= 2)
|
|
.distinct()
|
|
.sorted()
|
|
.collect(Collectors.toList());
|
|
|
|
// result: abc de
|
|
```
|
|
|
|
### Sources
|
|
1. [Processing Data with Java SE 8 Streams, Part 1](http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html)
|