Sunday, September 06, 2015

Stack Overflow - swag!

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:

  • t-shirt,
  • mug,
  • moleskin notebook, embossed with the Stack Overflow logo, and
  • stickers of various Stack Exchange sites that I participate in.

Here are a couple of pictures:

Reverse of mug:

Sunday, July 26, 2015

Java 8: Creating infinite streams

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 =;

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,

int[] numbers = { 1, 3, 6, 8 };
IntStream stream =;
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);

Sunday, June 28, 2015

Java 8: Composing Comparators

In my last post, I showed how you can sort a list of Person objects by age, using the following statement:


What if you want to sort the objects in order of decreasing age instead? There's no need to create a new instance of Comparator, because the Comparator interface has a handy default method reversed that reverses its ordering:


Now, what if you want to sort people by name if they have the same age. The thenComparing method allows you to do just that, as shown below:


Saturday, June 27, 2015

Java 8: Sorting a List using Lambdas and Method References

This post shows how you can use Java 8 lambda expressions and method references to sort a list of Person objects by age. In Java 8, the List interface has a sort method, which expects a Comparator to compare two objects.

Traditionally, you would either sort a list by creating a specific class that implements the Comparator interface, like this:

public class AgeComparator implements Comparator<Person> {
  public int compare(Person p1, Person p2) {
    return, p2.getAge());

list.sort(new AgeComparator());

or, you would use an anonymous class, like this:

list.sort(new Comparator<Person>() {
  public int compare(Person p1, Person p2) {
    return, p2.getAge());

As you can see, this is quite verbose!

Java 8 introduces lambda expressions, which allow you to pass code more concisely. Since Comparator is a functional interface, you can use a lambda expression to sort the list:

list.sort((p1, p2) ->, p2.getAge()));

You may have noticed that the Comparator class has a static method called comparingInt that takes a ToIntFunction and returns a Comparator object. So, we can rewrite the code above to:

import static java.util.Comparator.comparingInt;
list.sort(comparingInt(p -> p.getAge()));

Finally, we can improve our code even further by using a method reference, which is just "syntactic sugar" for a lambda expression:


The final solution is not only shorter but is also easier to read :)

Monday, May 25, 2015

Java 8: Filtering an Optional

In my previous post, I wrote about how you can use optionals to model the absence of a value. Optionals also contain a useful filter method, which takes a predicate as an argument. If a value is present in the Optional object and the predicate is satisfied, the filter method returns that value; otherwise it returns an empty Optional object.

For example, let's suppose that the Phone class of the Person/Phone/Camera/Resolution model has a method to get the operating system of the phone, and we want to get the camera resolution of "Android" phones only. We can modify the getPhoneCameraResolution method to use a filter, as shown below:

public Resolution getPhoneCameraResolution(final Optional<Person> person) {
    person.flatMap(Person::getPhone)  // returns Optional<Phone>
          .filter(phone -> phone.getOS() == OS.Android) // match Android phones only
          .flatMap(Phone::getCamera) // returns Optional<Camera>
          .map(Camera::getResolution) // returns Optional<Resolution>
          .orElse(Resolution.UNKNOWN); // returns Resolution or UNKNOWN if not found

Related posts:
Java 8: Using Optional Objects