Java 8 Tips

This blog is listing key new features introduced in Java 8

It is best to think of a lambda expression as a function, not an object, and to accept that it can be converted to a functional interface.

Clean Code in Java 8

Here is the sample code in Java 8

calss DiscountService{
   Integer discount =getDiscountPercentage(customer.getMemberCard());
}

New comparator method in Java 8

List<Track> tracks = asList(new Track("Bakai", 524),
                            new Track("Violets for Your Furs", 378),
                            new Track("Time Was", 451));

Track shortestTrack = tracks.stream()
                            .min(Comparator.comparing(track -> track.getLength()))
                            .get();

assertEquals(tracks.get(1), shortestTrack);

When we think about maximum and minimum elements, the first thing we need to think about is the ordering that we’re going to be using. When it comes to finding the shortest track, the ordering is provided by the length of the ”

In order to inform the Stream that we’re using the length of the track, we give it a Comparator. Conveniently, Java 8 has added a static method called comparing that lets us build a comparator using keys. Previously, we always encountered an ugly pattern in which we had to write code that got a field out of both the objects being compared, then compare these field values. Now, to get the same element out of both elements being compared, we just provide a getter function for the value. In this case we’ll use length, which is a getter function in disguise. It’s worth reflecting on the comparing method for a moment. This is actually a function that takes a function and returns a function. Pretty meta, I know, but also incredibly useful. At any point in the past, this method could have been added to the Java standard library, but the poor readability and verbosity issues surrounding anonymous inner classes would have made it impractical. Now, with lambda expressions, it’s convenient and concise. ” But thinking of passing code to methods as a mere consequence of Streamsdownplays its range of uses within Java 8. It gives you a new concise way to express behavior parameterization.

It might sound surprising, but interfaces in Java 8 can now declare methods with implementation code; this can happen in two ways. First, Java 8 allows static methods inside interfaces. Second, Java 8 introduces a new feature called default methods that allows you to provide a default implementation for methods in an interface. In other words, interfaces can provide concrete implementation for methods. As a result, existing classes implementing an interface will automatically inherit the default implementations if they don’t provide one explicitly. This allows you to evolve interfaces nonintrusively. You’ve been using several default methods all along. Two examples you’ve seen are sort in the List interface and stream in the Collection interface. Wow! Are interfaces like abstract classes now? Yes and no; there are fundamental differences, which we explain in this chapter. But more important, why should you care about default methods? The main users of default methods are library designers. As we explain later, default methods were introduced to evolve libraries such as the Java API in a compatible way,

Now that static methods can exist inside interfaces, such utility classes in your code can go away and their static methods can be moved inside an interface. These companion classes will remain in the Java API in order to preserve backward compatibility. Adding a new method to an interface is binary compatible; this means existing class file implementations will still run without the implementation of the new method, if there’s no attempt to recompile them. In this case the game will still run (unless it’s recompiled) despite adding the method setRelativeSize to the Resizable interface

Abstract classes vs. interfaces in Java 8

So what’s the difference between an abstract class and an interface? They both can contain abstract methods and methods with a body.

• First, a class can extend only from one abstract class, but a class can implement multiple interfaces.

• Second, an abstract class can enforce a common state through instance variables (fields). An interface can’t have instance variables.

Keeping interfaces minimal and orthogonal lets you achieve great reuse and composition of behavior inside your codebase.

Minimal interfaces with orthogonal functionalities Inheritance considered harmful Inheritance shouldn’t be your answer to everything when it comes down to reusing code. For example, inheriting from a class that has 100 methods and fields just to reuse one method is a bad idea, because it adds unnecessary complexity. You’d be better off using delegation: create a method that calls directly the method of the class you need via a member variable. This is why you’ll sometime find classes that are declared “final” intentionally: they can’t be inherited from to prevent this kind of antipattern or have their core behavior messed with. Note that sometimes final classes have a place; for example, String is final because we don’t want anybody to be able to interfere with such core functionality.

Three resolution rules to know

There are three rules to follow when a class inherits a method with the same signature from multiple places (such as another class or interface):

1. Classes always win. A method declaration in the class or a superclass takes priority over any default method declaration.

2. Otherwise, sub-interfaces win: the method with the same signature in the most specific default-providing interface is selected. (If B extends A, B is more specific than A).

3. Finally, if the choice is still ambiguous, the class inheriting from multiple interfaces has to explicitly select which default method implementation to use by overriding it and calling the desired method explicitly.

These are the only rules you need to know!

Lambda Interfaces

This conversion to interfaces is what makes lambda expressions so compelling. The syntax is short and simple.

BiFunction<String, String, Integer> comp
   = (first, second) -> Integer.compare(first.length(), second.length());

The expression System.out::printlnis a method reference that is equivalent to the lambda expression x -> System.out.println(x).

There are three principal cases:

• object::instanceMethod
• Class::staticMethod
• Class::instanceMethod

In the third case, the first parameter becomes the target of the method. For example, String::compareToIgnoreCaseis the same as (x, y) -> x.compareToIgnoreCase(y).

Just like lambda expressions, method references don’t live in isolation. They are always turned into instances of functional interfaces.

Constructor References

Constructor references are just like method references, except that the name of the method is newå. For example, Button::new is a reference to a Button constructor. Which constructor? It depends on the context.

List<String> labels = ...;
Stream<Button> stream = labels.stream().map(Button::new);
List<Button> buttons = stream.collect(Collectors.toList());

For example, suppose we want to have an array of buttons. The Stream interface has a toArraymethod that returns an Object array:

Object[] buttons = stream.toArray();

we need to refine our understanding of a lambda expression. A lambda expression has three ingredients:

1. A block of code
2. Parameters
3. Values for the free variables, that is, the variables that are not parameters and not defined inside the code

The technical term for a block of code together with the values of the free variables is a closure. If someone gloats that their language has closures, rest assured that Java has them as well. In Java, lambda expressions are closures. In fact, inner classes have been closures all along. Java 8 gives us closures with an attractive syntax.

Inner classes can also capture values from an enclosing scope. Before Java 8, inner classes were only allowed to access finallocal variables. This rule has now been relaxed to match that for lambda expressions. An inner class can access any effectively final local variable—that is, any variable whose value does not change.

When you use the this keyword in a lambda expression, you refer to the this parameter of the method that creates the lambda. For example, consider

public class Application {
   public void doWork() {
      Runnable runner = () -> { ...; System.out.println(this.toString()); ... };
      ...
   }
}

The expression this.toString()calls the toString method of the Application object, not the Runnable instance. There is nothing special about the use of this in a lambda expression. The scope of the lambda expression is nested inside the doWork method, and this has the same meaning anywhere in that method.

default methods

The Java designers decided to solve this problem once and for all by allowing interface methods with concrete implementations (called default methods). Those methods can be safely added to existing interfaces.

interface Person {
   long getId();
   default String getName() { return "John Q. Public"; }
}

The interface has two methods: getId, which is an abstract method, and the default method getName. A concrete class that implements the Person interface must, of course, provide an implementation of getId, but it can choose to keep the implementation of getName or to override it.

Default methods put an end to the classic pattern of providing an interface and an abstract class that implements most or all of its methods, such as Collection/AbstractCollectionor/WindowListener/WindowAdapter. Now you can just implement the methods in the interface.

To compare Person objects by name, use Comparator.comparing(Person::getName).

we have compared strings by length with the lambda expression

(first, second) -> Integer.compare(first.length(), second.length()). 

But with the static compare method, we can do much better and simply use

Comparator.comparing(String::length).

In Java 8, static methods have been added to quite a few interfaces. For example, the Comparator interface has a very useful static comparing method that accepts a “key extraction” function and yields a comparator that compares the extracted keys.

Stream vs collections

A stream seems superficially similar to a collection, allowing you to transform and retrieve data. But there are significant differences:

• A stream does not store its elements. They may be stored in an underlying collection or generated on demand.
• Stream operations don’t mutate their source. Instead, they return new streams that hold the result.
• Stream operations are lazy when possible. This means they are not executed until their result is needed. For example, if you only ask for the first five long words instead of counting them all, then the filter method will stop filtering after the fifth match. As a consequence, you can even have infinite streams!

Streams follow the “what, not how” principle. In our stream example, we describe what needs to be done: get the long words and count them. We don’t specify in which order, or in which thread, this should happen.

Work with streams

When you work with streams, you set up a pipeline of operations in three stages.

1. You create a stream.
2. You specify intermediate operations for transforming the initial stream into others, in one or more steps.
3. You apply a terminal operation to produce a result. This operation forces the execution of the lazy operations that precede it. Afterwards, the stream can no longer be used.

long count = words.parallelStream().filter(w -> w.length() > 12).count();

Stream operations are not executed on the elements in the order in which they are invoked on the streams. In our example, nothing happens until count is called. When the count method asks for the first element, then the filter method starts requesting elements, until it finds one that has length > 12.

To produce infinite sequences such as 0 1 2 3 …, use the iterate method instead. It takes a “seed” value and a function (technically, a UnaryOperator), and repeatedly applies the function to the previous result. For example,

Stream<BigInteger> integers
   = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));

The first element in the sequence is the seed

You can use the following statement to split a string into words:

Stream<String> words
   = Pattern.compile("[\\P{L}]+").splitAsStream(contents);

The static Files.linesmethod returns a Stream of all lines in a file.

The Stream interface has AutoCloseableas a superinterface. When the close method is called on the stream, the underlying file is also closed.

To make sure that this happens, it is best to use the Java 7 try-with-resources statement:

try (Stream<String> lines = Files.lines(path)) {
   Do something with lines
}

The stream, and the underlying file with it, will be closed when the try block exits normally or through an exception.

The filter, map, and flatMapMethods A stream transformation reads data from a stream and puts the transformed data into another stream. You have already seen the filter transformation that yields a new stream with all elements that match a certain condition.

2.3. The filter, map, and flatMap Methods A stream transformation reads data from a stream and puts the transformed data into another stream. You have already seen the filtertransformation that yields a new stream with all elements that match a certain condition. Here, we transform a stream of strings into another stream containing only long words:

List<String> wordList = ...;
Stream<String> words = wordList.stream();
Stream<String> longWords = words.filter(w -> w.length() > 12);

The argument of filter is a Predicate—that is, a function from T to boolean.

Often, you want to transform the values in a stream in some way. Use the map method and pass the function that carries out the transformation. For example, you can transform all words to lowercase like this:

Stream<String> lowercaseWords = words.map(String::toLowerCase);

Here, we used mapwith a method reference. Often, you will use a lambda expression instead:

Stream<Character> firstChars = words.map(s -> s.charAt(0));

The resulting stream contains the first character of each word.

When you use map, a function is applied to each element, and the return values are collected in a new stream. Now suppose that you have a function that returns not just one value but a stream of values, such as this one:

public static Stream<Character> characterStream(String s) {
   List<Character> result = new ArrayList<>();
   for (char c : s.toCharArray()) result.add(c);
   return result.stream();
}

For example, characterStream(“boat”)is the stream [‘b’, ‘o’, ‘a’, ‘t’]. Suppose you map this method on a stream of strings:

Stream<Stream<Character>> result = words.map(w -> characterStream(w));

You will get a stream of streams, like [… [‘y’, ‘o’, ‘u’, ‘r’], [‘b’, ‘o’, ‘a’, ‘t’], …] To flatten it out to a stream of characters [… ‘y’, ‘o’, ‘u’, ‘r’, ‘b’, ‘o’, ‘a’, ‘t’, …], use the flatMapmethod instead of map:

Stream<Character> letters = words.flatMap(w -> characterStream(w))
    // CallscharacterStream on each word and flattens the results

NOTE

You may find a flatMap method in classes other than streams. It is a general concept in computer science. Suppose you have a generic type G (such as Stream) and functions ffrom some type T to Gand g from U to G. Then you can compose them, that is, first apply f and then g, by using flatMap. This is a key idea in the theory of monads. But don’t worry—you can use flatMapwithout knowing anything about monads.

This method is particularly useful for cutting infinite streams down to size. For example,

Stream<Double> randoms = Stream.generate(Math::random).limit(100);

yields a stream with 100 random numbers.

The peek method yields another stream with the same elements as the original, but a function is invoked every time an element is retrieved. That is handy for debugging:

Object[] powers = Stream.iterate(1.0, p -> p * 2)
   .peek(e -> System.out.println("Fetching " + e))
   .limit(20).toArray();

When an element is actually accessed, a message is printed. This way you can verify that the infinite stream returned by iterate is processed lazily.

The stream transformations of the preceding sections were stateless. When an element is retrieved from a filtered or mapped stream, the answer does not depend on the previous elements. There are also a few stateful transformations. For example, the distinct method returns a stream that yields elements from the original stream, in the same order, except that duplicates are suppressed.

The stream must obviously remember the elements that it has already seen.

Stream<String> uniqueWords
   = Stream.of("merrily", "merrily", "merrily", "gently").distinct();
   // Only one"merrily" is retained

The sorted method must see the entire stream and sort it before it can give out any elements—after all, the smallest one might be the last one. Clearly, you can’t sort an infinite stream.

There are several sorted methods. One works for streams of Comparableelements, and another accepts a Comparator. Here, we sort strings so that the longest ones come first:

Click here to view code image

Stream longestFirst = words.sorted(Comparator.comparing(String::length).reversed()); Of course, you can sort a collection without using streams. The sorted method is useful when the sorting process is a part of a stream pipeline.

NOTE

The Collections.sortmethod sorts a collection in place, whereas Stream.sortedreturns a new sorted stream.

The methods that we cover in this section are called reductions. They reduce the stream to a value that can be used in your program. Reductions are terminal operations. After a terminal operation has been applied, the stream ceases to be usable.

In Java 8, the Optional type is the preferred way of indicating a missing return value. We discuss the Optional type in detail in the next section. Here is how you can get the maximum of a stream:

Click here to view code image

Optional largest = words.max(String::compareToIgnoreCase); if (largest.isPresent()) System.out.println("largest: " + largest.get());

reduce. Each segment needs to start out with its own empty hash set, and reduce only lets you supply one identity value. Instead, use collect. It takes three arguments:

1. A supplier to make new instances of the target object, for example, a constructor for a hash set

2. An accumulatorthat adds an element to the target, for example, an addmethod

3. A combiner that merges two objects into one, such as addAll

NOTE

The target object need not be a collection. It could be a StringBuilderor an object that tracks a count and a sum.

Here is how the collect method works for a hash set:

Click here to view code image

HashSet result = stream.collect(HashSet::new, HashSet::add, HashSet::addAll);

In practice, you don’t have to do that because there is a convenient Collector interface for these three functions, and a Collectors class with factory methods for common collectors. To collect a stream into a list or set, you can simply call

Click here to view code image

List result = stream.collect(Collectors.toList());

or

Click here to view code image

Set result = stream.collect(Collectors.toSet());

If you want to control which kind of set you get, use the following call instead:

Click here to view code image

TreeSet result = stream.collect(Collectors.toCollection(TreeSet::new));

Suppose you want to collect all strings in a stream by concatenating them. You can call

String result = stream.collect(Collectors.joining());

If you want a delimiter between elements, pass it to the joiningmethod:

Click here to view code image

String result = stream.collect(Collectors.joining(“, “));

If your stream contains objects other than strings, you need to first convert them to strings, like this:

Click here to view code image

String result = stream.map(Object::toString).collect(Collectors.joining(“, “));

Click here to view code image

IntSummaryStatistics summary = words.collect( Collectors.summarizingInt(String::length)); double averageWordLength = summary.getAverage(); double maxWordLength = summary.getMax();

NOTE

So far, you have seen how to reduce or collect stream values. But perhaps you just want to print them or put them in a database. Then you can use the forEachmethod:

stream.forEach(System.out::println);

The function that you pass is applied to each element. On a parallel stream, it’s your responsibility to ensure that the function can be executed concurrently. We discuss this in Section 2.13, “Parallel Streams,” on page 40.

On a parallel stream, the elements can be traversed in arbitrary order. If you want to execute them in stream order, call forEachOrderedinstead. Of course, you might then give up most or all of the benefits of parallelism.

The forEachand forEachOrderedmethods are terminal operations. You cannot use the stream again after calling them. If you want to continue using the stream, use peekinstead—see

In the common case that the values should be the actual elements, use Function.identity()for the second function.

Click here to view code image

Map<Integer, Person> idToPerson = people.collect( Collectors.toMap(Person::getId, Function.identity())); If there is more than one element with the same key, the collector will throw an IllegalStateException. You can override that behavior by supplying a third function argument that determines the value for the key, given the existing and the new value. Your function could return the existing value, the new value, or a combination of them.

Here, we construct a map that contains, for each language in the available locales, as key its name in your default locale (such as “German”), and as value its localized name (such as “Deutsch”).

Click here to view code image

Stream locales = Stream.of(Locale.getAvailableLocales()); Map<String, String> languageNames = locales.collect( Collectors.toMap( l -> l.getDisplayLanguage(), l -> l.getDisplayLanguage(l), (existingValue, newValue) -> existingValue)); We don’t care that the same language might occur twice—for example, German in Germany and in Switzerland, and we just keep the first entry.

However, suppose we want to know all languages in a given country. Then we need a Map<String, Set>. For example, the value for "Switzerland"is the set [French, German, Italian]. At first, we store a singleton set for each language. Whenever a new language is found for a given country, we form the union of the existing and the new set.

Click here to view code image

Map<String, Set> countryLanguageSets = locales.collect( Collectors.toMap( l -> l.getDisplayCountry(), l -> Collections.singleton(l.getDisplayLanguage()), (a, b) -> { // Union of a and b Set r = new HashSet<>(a); r.addAll(b); return r; })); You will see a simpler way of obtaining this map in the next section.

If you want a TreeMap, then you supply the constructor as the fourth argument. You must provide a merge function. Here is one of the examples from the beginning of the section, now yielding a TreeMap:

Click here to view code image

Map<Integer, Person> idToPerson = people.collect( Collectors.toMap( Person::getId, Function.identity(), (existingValue, newValue) -> { throw new IllegalStateException(); }, TreeMap::new));

For example, if you want sets instead of lists, you can use the Collectors.toSetcollector that you saw in the preceding section:

Click here to view code image

Map<String, Set> countryToLocaleSet = locales.collect( groupingBy(Locale::getCountry, toSet()));

Several other collectors are provided for downstream processing of grouped elements:

• countingproduces a count of the collected elements. For example,

Click here to view code image

Map<String, Long> countryToLocaleCounts = locales.collect( groupingBy(Locale::getCountry, counting())); counts how many locales there are for each country.

Click here to view code image

Map<String, Integer> stateToCityPopulation = cities.collect( groupingBy(City::getState, summingInt(City::getPopulation))); computes the sum of populations per state in a stream of cities.

• maxBy and minBytake a comparator and produce maximum and minimum of the downstream elements. For example,

Click here to view code image

Map<String, City> stateToLargestCity = cities.collect( groupingBy(City::getState, maxBy(Comparator.comparing(City::getPopulation)))); produces the largest city per state.

• mapping applies a function to downstream results, and it requires yet another collector for processing its results. For example,

Click here to view code image

Map<String, Optional> stateToLongestCityName = cities.collect( groupingBy(City::getState, mapping(City::getName, maxBy(Comparator.comparing(String::length))))); Here, we group cities by state. Within each state, we produce the names of the cities and reduce by maximum length.

The mappingmethod also yields a nicer solution to a problem from the preceding section, to gather a set of all languages in a country.

Click here to view code image

Map<String, Set> countryToLanguages = locales.collect( groupingBy(l -> l.getDisplayCountry(), mapping(l -> l.getDisplayLanguage(), toSet()))); In the preceding section, I used toMap instead of groupingBy. In this form, you don’t need to worry about combining the individual sets.

• If the grouping or mapping function has return type int, long, or double, you can collect elements into a summary statistics object, as discussed in Section 2.9, “Collecting Results,” on page 33. For example,

Click here to view code image

Map<String, IntSummaryStatistics> stateToCityPopulationSummary = cities.collect( groupingBy(City::getState, summarizingInt(City::getPopulation))); Then you can get the sum, count, average, minimum, and maximum of the function values from the summary statistics objects of each group.

• Finally, the reducingmethods apply a general reduction to downstream elements. There are three forms: reducing(binaryOperator), reducing(identity, binaryOperator), and reducing(identity, mapper, binaryOperator). In the first form, the identity is null. (Note that this is different from the forms of Stream::reduce, where the method without an identity parameter yields an Optional result.) In the third form, the mapperfunction is applied and its values are reduced.

Here is an example that gets a comma-separated string of all city names in each state. We map each city to its name and then concatenate them.

Click here to view code image

Map<String, String> stateToCityNames = cities.collect( groupingBy(City::getState, reducing(“”, City::getName, (s, t) -> s.length() == 0 ? t : s + “, “ + t))); As with Stream.reduce, Collectors.reducingis rarely necessary. In this case, you can achieve the same result more naturally as

Click here to view code image

Map<String, String> stateToCityNames = cities.collect( groupingBy(City::getState, mapping(City::getName, joining(“, “)))); Frankly, the downstream collectors can yield very convoluted expressions. You should only use them in connection with groupingBy or partitioningBy to process the “downstream” map values. Otherwise, simply apply methods such as map, reduce, count, max, or mindirectly on streams.

2.12. Primitive Type Streams So far, we have collected integers in a Stream, even though it is clearly inefficient to wrap each integer into a wrapper object. The same is true for the other primitive types double, float, long, short, char, byte, and boolean. The stream library has specialized types IntStream, LongStream, and DoubleStream that store primitive values directly, without using wrappers. If you want to store short, char, byte, and boolean, use an IntStream, and for float, use a DoubleStream. The library designers didn’t think it was worth adding another five stream types.

To create an IntStream, you can call the IntStream.of and Arrays.streammethods:

Click here to view code image

IntStream stream = IntStream.of(1, 1, 2, 3, 5); stream = Arrays.stream(values, from, to); // values is an int[] array As with object streams, you can also use the static generate and iterate methods. In addition, IntStreamand LongStreamhave static methods range and rangeClosed that generate integer ranges with step size one:

Click here to view code image

IntStream zeroToNinetyNine = IntStream.range(0, 100); // Upper bound is excluded IntStream zeroToHundred = IntStream.rangeClosed(0, 100); // Upper bound is included The CharSequenceinterface has methods codePoints and chars that yield an IntStream of the Unicode codes of the characters or of the code units in the UTF-16 encoding. (If you don’t know what code units are, you probably shouldn’t use the chars method. Read up on the sordid details in Core Java, 9th Edition, Volume 1, Section 3.3.3.)

Click here to view code image

String sentence = “\uD835\uDD46 is the set of octonions.”; // \uD835\uDD46 is the UTF-16 encoding of the letter

, unicode U+1D546

IntStream codes = sentence.codePoints(); // The stream with hex values 1D546 20 69 73 20 … When you have a stream of objects, you can transform it to a primitive type stream with the mapToInt, mapToLong, or mapToDoublemethods. For example, if you have a stream of strings and want to process their lengths as integers, you might as well do it in an IntStream:

Click here to view code image

Stream words = ...; IntStream lengths = words.mapToInt(String::length); To convert a primitive type stream to an object stream, use the boxed method:

Click here to view code image

Stream integers = IntStream.range(0, 100).boxed();

Generally, the methods on primitive type streams are analogous to those on object streams. Here are the most notable differences:

• The toArraymethods return primitive type arrays.

• Methods that yield an optional result return an OptionalInt, OptionalLong, or OptionalDouble. These classes are analogous to the Optional class, but they have methods getAsInt, getAsLong, and getAsDoubleinstead of the getmethod.

• There are methods sum, average, max, and min that return the sum, average, maximum, and minimum. These methods are not defined for object streams.

• The summaryStatisticsmethod yields an object of type IntSummaryStatistics, LongSummaryStatistics, or DoubleSummaryStatisticsthat can simultaneously report the sum, average, maximum, and minimum of the stream.

NOTE

The Randomclass has methods ints, longs, and doubles that return primitive type streams of random numbers.

2.13. Parallel Streams Streams make it easy to parallelize bulk operations. The process is mostly automatic, but you need to follow a few rules. First of all, you must have a parallel stream. By default, stream operations create sequential streams, except for Collection.parallelStream(). The parallelmethod converts any sequential stream into a parallel one. For example:

Click here to view code image

Stream parallelWords = Stream.of(wordArray).parallel();

As long as the stream is in parallel mode when the terminal method executes, all lazy intermediate stream operations will be parallelized.

When stream operations run in parallel, the intent is that the same result is returned as if they had run serially. It is important that the operations are stateless and can be executed in an arbitrary order.

Here is an example of something you cannot do. Suppose you want to count all short words in a stream of strings:

Click here to view code image

int[] shortWords = new int[12]; words.parallel().forEach( s -> { if (s.length() < 12) shortWords[s.length()]++; }); // Error—race condition! System.out.println(Arrays.toString(shortWords)); This is very, very bad code. The function passed to forEachruns concurrently in multiple threads, updating a shared array. That’s a classic race condition. If you run this program multiple times, you are quite likely to get a different sequence of counts in each run, each of them wrong.

It is your responsibility to ensure that any functions that you pass to parallel stream operations are threadsafe. In our example, you could use an array of AtomicIntegerobjects for the counters (see Exercise 12). Or you could simply use the facilities of the streams library and group strings by length (see Exercise 13).

By default, streams that arise from ordered collections (arrays and lists), from ranges, generators, and iterators, or from calling Stream.sorted, are ordered. Results are accumulated in the order of the original elements, and are entirely predictable. If you run the same operations twice, you will get exactly the same results.

Ordering does not preclude parallelization. For example, when computing stream.map(fun), the stream can be partitioned into nsegments, each of which is concurrently processed. Then the results are reassembled in order.

Some operations can be more effectively parallelized when the ordering requirement is dropped. By calling the Stream.unorderedmethod, you indicate that you are not interested in ordering. One operation that can benefit from this is Stream.distinct. On an ordered stream, distinct retains the first of all equal elements. That impedes parallelization—the thread processing a segment can’t know which elements to discard until the preceding segment has been processed. If it is acceptable to retain any of the unique elements, all segments can be processed concurrently (using a shared set to track duplicates).

You can also speed up the limit method by dropping ordering. If you just want any nelements from a stream and you don’t care which ones you get, call

Click here to view code image

Stream sample = stream.parallel().unordered().limit(n);

As discussed in Section 2.10, “Collecting into Maps,” on page 34, merging maps is expensive. For that reason, the Collectors.groupingByConcurrentmethod uses a shared concurrent map. Clearly, to benefit from parallelism, the order of the map values will not be the same as the stream order. Even on an ordered stream, that collector has a “characteristic” of being unordered, so that it can be used efficiently without having to make the stream unordered. You still need to make the stream parallel, though:

Click here to view code image

Map<String, List> result = cities.parallel().collect( Collectors.groupingByConcurrent(City::getState)); // Values aren’t collected in stream order

CAUTION

It is very important that you don’t modify the collection that is backing a stream while carrying out a stream operation (even if the modification is threadsafe). Remember that streams don’t collect their own data—the data is always in a separate collection. If you were to modify that collection, the outcome of the stream operations would be undefined. The JDK documentation refers to this requirement as noninterference. It applies both to sequential and parallel streams.

To be exact, since intermediate stream operations are lazy, it is possible to mutate the collection up to the point when the terminal operation executes. For example, the following is correct:

Click here to view code image

List wordList = ...; Stream words = wordList.stream(); wordList.add("END"); // Ok long n = words.distinct().count(); But this code is not:

Click here to view code image

Stream words = wordList.stream(); words.forEach(s -> if (s.length() < 12) wordList.remove(s)); // Error—interference

Exercises

1. Write a parallel version of the forloop in Section 2.1, “From Iteration to Stream Operations,” on page 22. Obtain the number of processors. Make that many separate threads, each working on a segment of the list, and total up the results as they come in. (You don’t want the threads to update a single counter. Why?)

2. Verify that asking for the first five long words does not call the filter method once the fifth long word has been found. Simply log each method call.

3. Measure the difference when counting long words with a parallelStreaminstead of a stream. Call System.nanoTimebefore and after the call, and print the difference. Switch to a larger document (such as War and Peace) if you have a fast computer.

4. Suppose you have an array int[] values = { 1, 4, 9, 16 }. What is Stream.of(values)? How do you get a stream of intinstead?

5. Using Stream.iterate, make an infinite stream of random numbers—not by calling Math.random but by directly implementing a linear congruential generator. In such a generator, you start with x0 = seedand then produce xn + 1 = (a xn + c) %m, for appropriate values of a, c, and m. You should implement a method with parameters a, c, m, and seed that yields a Stream. Try out a = 25214903917, c = 11, and m = 248.

6. The characterStreammethod in Section 2.3, “The filter, map, and flatMapMethods,” on page 25, was a bit clumsy, first filling an array list and then turning it into a stream. Write a stream-based one-liner instead. One approach is to make a stream of integers from 0 to s.length() - 1and map that with the s::charAtmethod reference.

7. Your manager asks you to write a method public static boolean isFinite(Stream stream). Why isn’t that such a good idea? Go ahead and write it anyway.

8. Write a method public static Stream zip(Stream first, Stream second) that alternates elements from the streams first and second, stopping when one of them runs out of elements.

9. Join all elements in a Stream<ArrayList>to one ArrayList. Show how to do this with the three forms of reduce.

10. Write a call to reduce that can be used to compute the average of a Stream. Why can’t you simply compute the sum and divide by count()?

11. It should be possible to concurrently collect stream results in a single ArrayList, instead of merging multiple array lists, provided it has been constructed with the stream’s size, since concurrent setoperations at disjoint positions are threadsafe. How can you achieve that?

12. Count all short words in a parallel Stream, as described in Section 2.13, “Parallel Streams,” on page 40, by updating an array of AtomicInteger. Use the atomic getAndIncrementmethod to safely increment each counter.

13. Repeat the preceding exercise, but filter out the short strings and use the collectmethod with Collectors.groupingByand Collectors.counting.

A function type is alwayscontravariant in its arguments and covariant in its return value. For example, if you have a Function<Person, Employee>, you can safely pass it on to someone who needs a Function<Employee, Person>. They will only call it with employees, whereas your function can handle any person. They will expect the function to return a person, and you give them something even better.

For example, look at the javadoc for Stream:

Click here to view code image

void forEach(Consumer<? super T> action) Stream filter(Predicate<? super T> predicate)

• 2024 10
• 2023 98
• 2022 51
• 2021 19
• 2020 25
• 2019 7
• 2018 39
• 2017 38
• 2016 50