Day: October 26, 2021

When collecting a stream, the groupingBy() Collector(java.util.stream.Collector) can be used to put data into different groups based on specified conditions. groupingBy() is a little bit more complicated to use than partitioningBy() because the key can be of any type, whereas with partitioningBy(), the keys must be of type Boolean.

There are 3 overloaded variants of the groupingBy() method in the Collectors(java.util.stream.Collectors) class. In this tutorial, we are going to learn how to use all of these 3 variants of groupingBy().

At the end of the tutorial, you would have learned:

1. How to use the groupingBy() Collector.

1. Intermediate Java.
2. Java Streams(java.util.stream.Stream).

1. A Java IDE.

To follow along with the tutorial, perform the steps below:

1. Create a new Java project.

2. Create a package com.example.

3. Create a class called Entry.

4. Create the main() method inside Entry.java.

5. Our examples will use Cake objects with different properties to demonstrate groupingBy(), so declare the package-private top-level record class Cake inside Entry.java from the code below.

    record Cake(Shape shape, Color color, BigDecimal price){}

6. Then create an enum called Shape.

    enum Shape { TRIANGLE, CIRCLE, DIAMOND }

7. We do not have to create our own class to encapsulate colors, we will use the premade Java class java.awt.Color.

In main(), add the List of cakes using the code below:

var cakes = List.of(
   new Cake(Shape.TRIANGLE, Color.BLUE, BigDecimal.valueOf(4.99)),
   new Cake(Shape.CIRCLE, Color.RED, BigDecimal.valueOf(3.99)),
   new Cake(Shape.DIAMOND, Color.CYAN, BigDecimal.valueOf(5.25)),
   new Cake(Shape.CIRCLE, Color.GREEN, BigDecimal.valueOf(3.49)),
   new Cake(Shape.DIAMOND, Color.BLACK, BigDecimal.valueOf(5.99))
);

Whenever we collect a stream using groupingBy(), we have to tell groupingBy() the key that we want to group items by.

For example, if we wanted to group the Cakes by Shape alone, we will end up with a Map with 3 different keys, and the keys being the Shapes themselves. The picture below simplifies the data structure returned by groupingBy().

We do not necessarily tell groupingBy()"how" to group things, instead, we mostly want to tell it what to group things by. In the List of Cakes above, we can tell groupingBy() to group Cakes by their Shape, Color, or price. It is not that we are not allowed to tell it how to group things by, but if we are performing comparisons on the items themselves, then we might as well use partitioningBy().

The differences between groupingBy() and partitioningBy() are:

1. The Map returned by partitioningBy() will always produce only two Boolean keys, true and false, whereas the Map returned by groupingBy() can have keys of any type and can have as many keys as you want.
2. There is no version of partitioningBy() that allows you to specify a custom Map implementation of your choice, but there is a version of groupingBy() that allows you to do so.

Let us start with the simplest groupingBy() variant, where we only have to provide one argument. Its method signature is:

static <T, K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)

The only argument that we will have to provide is a Function object. It does not have to be anything fancy. A Function that extracts a property of each Cake will do. groupingBy() will automatically group the Cakes with the same property value for us.

In the Entry class, create a new method called groupByShape() from the code below:

private static void groupByShape(List<Cake> cakes){
   Map<Shape, List<Cake>> cakeGroups = cakes.stream()
           .collect(Collectors.groupingBy(Cake::shape)
           );

   cakeGroups.entrySet().forEach(System.out::println);
}

And then call it in main() with

groupByShape(cakes);

The output would be:

DIAMOND=[Cake[shape=DIAMOND, color=java.awt.Color[r=0,g=255,b=255], price=5.25], Cake[shape=DIAMOND, color=java.awt.Color[r=0,g=0,b=0], price=5.99]]

TRIANGLE=[Cake[shape=TRIANGLE, color=java.awt.Color[r=0,g=0,b=255], price=4.99]]

CIRCLE=[Cake[shape=CIRCLE, color=java.awt.Color[r=255,g=0,b=0], price=3.99], Cake[shape=CIRCLE, color=java.awt.Color[r=0,g=255,b=0], price=3.49]]

The groupByShape() method obviously groups Cakes by their Shape, and that is why our Map has 3 keys, with each being a Shape. Our List<Cake> only has one Cake with the TRIANGLE Shape, so we only see one Cake for the key TRIANGLE. For the other two Shapes, our List<Cake> has two of each, so that is why there are two Cakes for each Shape.

The second variant of groupingBy() allows you to pass additional Collectors into it. If you want to group the Cakes by Shape and by Color as well, then this is the correct variant to use. Its method signature is:

static <T, K, A, D> Collector<T,?,Map<K,D>> groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)

Add another method called groupByShapeThenColor() in the Entry class as well to see how the method is used:

private static void groupByShapeThenColor(List<Cake> cakes){
   Map<Shape, Map<Color, List<Cake>>> cakeGroups;
   cakeGroups = cakes.stream().collect(Collectors.groupingBy(
           Cake::shape,
           Collectors.groupingBy(Cake::color)
   ));

   cakeGroups.entrySet().forEach(System.out::println);
}

When calling it in main(), the output is:

CIRCLE={java.awt.Color[r=0,g=255,b=0]=[Cake[shape=CIRCLE, color=java.awt.Color[r=0,g=255,b=0], price=3.49]], java.awt.Color[r=255,g=0,b=0]=[Cake[shape=CIRCLE, color=java.awt.Color[r=255,g=0,b=0], price=3.99]]}

TRIANGLE={java.awt.Color[r=0,g=0,b=255]=[Cake[shape=TRIANGLE, color=java.awt.Color[r=0,g=0,b=255], price=4.99]]}

DIAMOND={java.awt.Color[r=0,g=0,b=0]=[Cake[shape=DIAMOND, color=java.awt.Color[r=0,g=0,b=0], price=5.99]], java.awt.Color[r=0,g=255,b=255]=[Cake[shape=DIAMOND, color=java.awt.Color[r=0,g=255,b=255], price=5.25]]}

Now we have nested Maps where the top-level keys are Shapes and the secondary-level keys are the Colors. The Cakes are first grouped by Shapes, and within each group, there will be subgroups by Color.

All of the groupingBy() Collectors that we have used so far returned a Map, but did you notice that we were not able to specify a specific implementation of Map(HashMap, TreeMap) that we want? Fortunately, the last variant of groupingBy() allows us to do just that. It requires a Supplier that will supply a specific instance of Map. Its method signature is:

static <T, K, D, A, M extends Map<K, D>> Collector<T,?,M> groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)

To see how it is used, add a new method called groupByShapeThenColorCustomMap()into the Entry class.

private static void groupByShapeThenColorCustomMap(List<Cake> cakes){
   var cakeGroups = cakes.stream().collect(Collectors.groupingBy(
           Cake::shape,
           TreeMap::new,
           Collectors.groupingBy(Cake::color)
   ));

   cakeGroups.entrySet().forEach(System.out::println);
}

Notice that in the second parameter, we have specified that we want an instance of TreeMap, which will automatically sort the keys for us.

When we call it in main(), the output is:

TRIANGLE={java.awt.Color[r=0,g=0,b=255]=[Cake[shape=TRIANGLE, color=java.awt.Color[r=0,g=0,b=255], price=4.99]]}

CIRCLE={java.awt.Color[r=0,g=255,b=0]=[Cake[shape=CIRCLE, color=java.awt.Color[r=0,g=255,b=0], price=3.49]], java.awt.Color[r=255,g=0,b=0]=[Cake[shape=CIRCLE, color=java.awt.Color[r=255,g=0,b=0], price=3.99]]}

DIAMOND={java.awt.Color[r=0,g=0,b=0]=[Cake[shape=DIAMOND, color=java.awt.Color[r=0,g=0,b=0], price=5.99]], java.awt.Color[r=0,g=255,b=255]=[Cake[shape=DIAMOND, color=java.awt.Color[r=0,g=255,b=255], price=5.25]]}

enum constants are sorted by the order of their declaration, so that is why the keys are sorted in this order.

package com.example;

import java.awt.*;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class Entry {
   public static void main(String[] args){
       var cakes = List.of(
           new Cake(Shape.TRIANGLE, Color.BLUE, BigDecimal.valueOf(4.99)),
           new Cake(Shape.CIRCLE, Color.RED, BigDecimal.valueOf(3.99)),
           new Cake(Shape.DIAMOND, Color.CYAN, BigDecimal.valueOf(5.25)),
           new Cake(Shape.CIRCLE, Color.GREEN, BigDecimal.valueOf(3.49)),
           new Cake(Shape.DIAMOND, Color.BLACK, BigDecimal.valueOf(5.99))
       );

       //groupByShape(cakes);
       //groupByShapeThenColor(cakes);
       groupByShapeThenColorCustomMap(cakes);
   }

   private static void groupByShape(List<Cake> cakes){
       Map<Shape, List<Cake>> cakeGroups = cakes.stream()
               .collect(Collectors.groupingBy(Cake::shape)
               );

       cakeGroups.entrySet().forEach(System.out::println);
   }

   private static void groupByShapeThenColor(List<Cake> cakes){
       Map<Shape, Map<Color, List<Cake>>> cakeGroups;
       cakeGroups = cakes.stream().collect(Collectors.groupingBy(
               Cake::shape,
               Collectors.groupingBy(Cake::color)
       ));

       cakeGroups.entrySet().forEach(System.out::println);
   }

   private static void groupByShapeThenColorCustomMap(List<Cake> cakes){
       var cakeGroups = cakes.stream().collect(Collectors.groupingBy(
               Cake::shape,
               TreeMap::new,
               Collectors.groupingBy(Cake::color)
       ));

       cakeGroups.entrySet().forEach(System.out::println);
   }

}

record Cake(Shape shape, Color color, BigDecimal price){}

enum Shape { TRIANGLE, CIRCLE, DIAMOND }

We have learned how to use the groupingBy() Collector in this tutorial, the full project code can be found here https://github.com/dmitrilc/DaniwebJavaGroupingBy/tree/master

Whenever we want to modify numbers from multiple threads running concurrently, such as modifying a counter, one of the best options is to use the AtomicX classes. The most basic numeric atomic classes are AtomicInteger and AtomicLong.

In this tutorial, we will learn how to use the AtomicInteger class to atomically update numbers as well as some of its common operators.

At the end of the tutorial, you would have learned:

1. How to use AtomicInteger to make numerics thread-safe.

1. Intermediate Java.
2. Basic Java Concurrency.

1. A Java IDE such as IntelliJ Community Edition.

To follow along with the tutorial, perform the steps below:

1. Create a new Java project.
2. Create a package com.example.
3. Create a class called Entry.
4. Create the main() method inside Entry.java.

Before learning how to use AtomicInteger, let us take a look at what problem it solves. First, we will try to modify a regular int from multiple threads, so create a static counterproperty for the Entry class.

static int counter;

And then add the method called unsafe() from the code below into the Entry class as well.

private static void unsafe(){
   ExecutorService executorService = Executors.newCachedThreadPool();

   for (int i = 0; i < 5; i++){
       executorService.submit(() -> {
           System.out.println(counter++);
       });
   }

   try {
       executorService.awaitTermination(1, TimeUnit.SECONDS);
   } catch (InterruptedException e) {
       e.printStackTrace();
   } finally {
       executorService.shutdown();
   }
}

We chose the name unsafe() to signify that modifying an int from multiple threads in this case is not thread safe. What the method above does can be summarized in a few words:

1. It submits 5 Runnables into a Thread pool. This particular ExecutorService creates new Threads as needed.
2. The Runnable lambdas try to print the counter value, and the counter value is also incrementing at the same time.
3. The ExecutorService waits for one second before timing out.

When we call this method in main() with

unsafe();

We might get some output that repeats the same number multiple times. The output that I received on my computer is:

1
3
2
0
0

As you can see, the code fails to print the number 4 and printed zero twice. This unpredictable behavior is explained below:

1. The postfix increment operator(x++) is actually a shortcut for 3 different operations: return the value, increment the value, and then reassign the value.
2. There are multiple threads vying to do all 3 tasks in parallel, so one thread might have received a value of the variable counter before another thread was able to assign a new value for it.

To fix the problem presented in the previous section, we can use an AtomicInteger instead of an int. An AtomicInteger prevents thread interference by only allowing one thread to modify the underlying value at a time.

Add a new atomic variable in the Entry class from the code below.

static AtomicInteger atomicCounter = new AtomicInteger();

And then create a new method called safe() in the Entry class as well.

private static void safe(){
   ExecutorService executorService = Executors.newCachedThreadPool();

   for (int i = 0; i < 5; i++){
       executorService.submit(() -> {
           System.out.println(atomicCounter.getAndIncrement());
       });
   }

   try {
       executorService.awaitTermination(1, TimeUnit.SECONDS);
   } catch (InterruptedException e) {
       e.printStackTrace();
   } finally {
       executorService.shutdown();
   }
}

Because we cannot use Java operators on AtomicInteger, we replaced the postfix operator(x++) with a method called getAndIncrement(). Comment out the unsafe() call used previously and call safe() from main().

//unsafe();
safe();

We can see that the output does not contain any duplicate or missing number. 0-4 are all printed:

0
2
1
3
4

Even though the incrementing and assigning operations are synchronized, the println() calls are not, so we still would not see the digits from increasing order(0 -> 1 -> 2 -> 3 -> 4).

Because we are not able to use Java operators on an AtomicInteger reference, we will have to resort to these methods in place of their respective operators. Below are some of the most common.

1. Postfix increment(x++) : getAndIncrement()
2. Postfix decrement(x--) : getAndDecrement()
3. Prefix increment(++x): incrementAndGet()
4. Prefix decrement(--x): decrementAndGet()
5. Assignment(=): set()

package com.example;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Entry {

   static int counter;
   static AtomicInteger atomicCounter = new AtomicInteger();

   public static void main(String[] args) {
       //unsafe();
       safe();
   }

   private static void unsafe(){
       ExecutorService executorService = Executors.newCachedThreadPool();

       for (int i = 0; i < 5; i++){
           executorService.submit(() -> {
               System.out.println(counter++);
           });
       }

       try {
           executorService.awaitTermination(1, TimeUnit.SECONDS);
       } catch (InterruptedException e) {
           e.printStackTrace();
       } finally {
           executorService.shutdown();
       }
   }

   private static void safe(){
       ExecutorService executorService = Executors.newCachedThreadPool();

       for (int i = 0; i < 5; i++){
           executorService.submit(() -> {
               System.out.println(atomicCounter.getAndIncrement());
           });
       }

       try {
           executorService.awaitTermination(1, TimeUnit.SECONDS);
       } catch (InterruptedException e) {
           e.printStackTrace();
       } finally {
           executorService.shutdown();
       }
   }

}

We have learned how to use AtomicInteger. The full project code can be found here: https://github.com/dmitrilc/DaniWebAtomicInteger