I find it a bit strange that the Java API does not provide a method to convert a String to a Stream<Character>, but this is how you can do it:
Stream<Character> stream = string.chars().mapToObj(i -> (char)i);
// or:
Stream<Character> stream = IntStream.range(0, string.length())
.mapToObj(string::charAt);
This post shows how you can use the Collectors available in the Streams API to group elements of a stream with groupingBy and partition elements of a stream with partitioningBy.
Consider a stream of Employee objects, each with a name, city and number of sales, as shown in the table below:
+----------+------------+-----------------+ | Name | City | Number of Sales | +----------+------------+-----------------+ | Alice | London | 200 | | Bob | London | 150 | | Charles | New York | 160 | | Dorothy | Hong Kong | 190 | +----------+------------+-----------------+
Grouping
Let's start by grouping employees by city using imperative style (pre-lamba) Java:
Map<String, List<Employee>> result = new HashMap<>();
for (Employee e : employees) {
String city = e.getCity();
List<Employee> empsInCity = result.get(city);
if (empsInCity == null) {
empsInCity = new ArrayList<>();
result.put(city, empsInCity);
}
empsInCity.add(e);
}
You're probably familiar with writing code like this, and as you can see, it's a lot of code for such a simple task!
In Java 8, you can do the same thing with a single statement using a groupingBy collector, like this:
Map<String, List<Employee>> employeesByCity = employees.stream().collect(groupingBy(Employee::getCity));
This results in the following map:
{New York=[Charles], Hong Kong=[Dorothy], London=[Alice, Bob]}
It's also possible to count the number of employees in each city, by passing a counting collector to the groupingBy collector. The second collector performs a further reduction operation on all the elements in the stream classified into the same group.
Map<String, Long> numEmployeesByCity = employees.stream().collect(groupingBy(Employee::getCity, counting()));
The result is the following map:
{New York=1, Hong Kong=1, London=2}
Just as an aside, this is equivalent to the following SQL statement:
select city, count(*) from Employee group by city
Another example is calculating the average number of sales in each city, which can be done using the averagingInt collector in conjuction with the groupingBy collector:
Map<String, Double> avgSalesByCity =
employees.stream().collect(groupingBy(Employee::getCity,
averagingInt(Employee::getNumSales)));
The result is the following map:
{New York=160.0, Hong Kong=190.0, London=175.0}
Partitioning
Partitioning is a special kind of grouping, in which the resultant map contains at most two different groups - one for true and one for false. For instance, if you want to find out who your best employees are, you can partition them into those who made more than N sales and those who didn't, using the partitioningBy collector:
Map<Boolean, List<Employee>> partitioned = employees.stream().collect(partitioningBy(e -> e.getNumSales() > 150));
This will produce the following result:
{false=[Bob], true=[Alice, Charles, Dorothy]}
You can also combine partitioning and grouping by passing a groupingBy collector to the partitioningBy collector. For example, you could count the number of employees in each city within each partition:
Map<Boolean, Map<String, Long>> result =
employees.stream().collect(partitioningBy(e -> e.getNumSales() > 150,
groupingBy(Employee::getCity, counting())));
This will produce a two-level Map:
{false={London=1}, true={New York=1, Hong Kong=1, London=1}}
The Streams API provides some useful methods to determine whether elements in a stream match a given condition.
anyMatch
The anyMatch method can be used to check if there exists an element in the stream that matches a given predicate. For example, to find out whether a stream of random numbers has a number greater than 5:
IntStream randomStream = new Random(100, 1, 11);
if (randomStream.anyMatch(i -> i > 5)) {
System.out.println("The stream has a number greater than 5");
}
allMatch
The allMatch method can be used to check if all elements in the stream match a given predicate. For example, to find out whether a stream of random numbers only contains positive numbers:
boolean isPositive = randomStream.allMatch(i -> i > 0);
noneMatch
noneMatch is the opposite of allMatch and can be used to check that no elements in the stream match a given predicate. The previous example could be rewritten using noneMatch as follows:
boolean isPositive = randomStream.noneMatch(i -> i <= 0);
findAny
The findAny method returns an arbitrary element of the stream. It returns an Optional because it's possible that no element might be returned by findAny. For example, to find a number greater than 5 in our random number stream:
OptionalInt number = randomStream.filter(i -> i > 5)
.findAny();
findFirst
findFirst is similar to findAny but returns the first element in the stream. For example, to find the first number greater than 5 in our random number stream:
OptionalInt number = randomStream.filter(i -> i > 5)
.findFirst();
The difference between findAny and findFirst arises when using parallel streams. Finding an arbitrary element in a stream is less constraining than finding the first element, when running in parallel mode, so findAny may perform better. So, if you don't care about which element is returned, use findAny.
An interesting thing to note is that the operations described above use short-circuiting i.e. they don't need to process the entire stream to produce a result. As soon as an appropriate element is found, a result is returned.
After waiting for what has seemed like forever, my Stack Overflow box of swag has finally arrived! The nice people at Stack Overflow sent me this stuff to congratulate me for reaching 100,000 reputation!
The box contained a:
Here are a couple of pictures:
Reverse of mug:
There are many ways you can build a Stream in Java 8. One of the most common ways, is to get a stream from a collection using the stream method as shown below:
List<String> list = Arrays.asList("Alice", "Bob");
Stream<String> stream = list.stream();
stream.forEach(System.out::println);
You can also create a stream from values using the static method, Stream.of:
Stream<String> stream = Stream.of("Alice", "Bob");
Arrays can be converted to streams using the static method, Arrays.stream:
int[] numbers = { 1, 3, 6, 8 };
IntStream stream = Arrays.stream(numbers);
Creating infinite streams:The Streams API provides two static methods: Stream.iterate and Stream.generate, which allow you to create an infinite stream. Here's an example:
Stream<Integer> evenNumbers = Stream.iterate(0, n -> n + 2);
The example above produces an infinite stream of even numbers. The iterate method takes a starting value and a lambda that is used to generate a new value from the previous one. In this case, the lambda returns the previous value added with 2. The stream is infinite because values are computed on demand and can be computed forever. (Note that you can use the limit method to explicitly limit the size of the stream.)
Similarly, Stream.generate also lets you produce an infinite stream, but the difference is that it takes a lamba of type Supplier<T> to provide new values, rather than a lambda that applies successively to the previous value. Here's an example:
Stream<Integer> randomNumbers = Stream.generate(Math::random);