Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs
Thanks to Michael Brush who contributed significantly to this article. -- ACO
Java 8 may be the most anticipated version of Java ever. Originally slated for release in September, Java 8 has been delayed until March of next year, supposedly to buy time to make security fixes aimed mainly at client-side Java (JavaFX/Swing). Since I, like most of you, stopped caring about client-side Java shortly after Duke finally finished jumping rope, we won't address any of that.
Java 8 is trying to "innovate," according to the Microsoft meaning of the word. This means stealing a lot of things that have typically been handled by other frameworks and languages, then incorporating them into the language or runtime (aka standardization). Ahead of the next release, the Java community is talking about Project Lambda, streams, functional interfaces, and all sorts of other goodies. So let's dive into what's great -- and what we can hate.
The changes to collections are driving a lot of the other changes in the language. The main component of making those collections better is a new collection called a "stream." This is not to be confused with java.io package's
OutputStream -- it's a separate concept altogether.
Streams are not meant to replace
ArrayLists or other collections. They are only meant to make manipulating the data easier and faster. A stream is a one-time-use
Object. Once it has been traversed, it cannot be traversed again.
Streams have the ability to filter, map, and reduce while being traversed. There are two "modes" for a stream: sequential
and parallel. This is where the ability of the stream to use the multicore processors of today comes into play. It uses
fork/join parallelism to split up the work and speed the processing along.
Using a sequential stream:
List <Person> people = list.getStream.collect(Collectors.toList());
Using a parallel stream:
List <Person> people = list.getStream.parallel().collect(Collectors.toList());
When the stream is traversed sequentially, each item in the stream is read processed, then the next item is read. When the stream is traversed in parallel, the array is split into multiple segments, each of which is processed individually on a different thread. The results are then put back together for the output.
Parallel stream flow:
List originalList = someData;
split1 = originalList(0, mid);
split2 = originalList(mid,end);
List revisedList = split1 + split2;
This very simplified example shows how the parallel
Stream would be processed. This is how it will take advantage of multicore processors.
Stream can only be traversed once and generally returns another
Stream, use a terminal method to get a useful result. Examples of a terminal method are
toArray(). Until the
Stream is terminated, the results of the operations are not realized. For example:
Double result = list.getStream().mapToDouble(f -> f.getAmount()).sum();
List<Person> people = list.getStream().filter(f -> f.getAge() > 21).collect(Collectors.toList());
The big benefit of this feature is the ability to use multiple processor cores for collection processing. Instead of doing
for loop, use
Stream in parallel mode -- theoretically, the speed goes up with each core added. The main problem that could arise from this is
readability. With all of the chaining of streams, the lines could get long, which will affect readability. The other problems
stem from the things that are built to support this new path. Those are functional Interfaces and Lambda.
Java 8 will have a new feature called functional interfaces. Basically, default methods are added to an interface and do not have to be overridden in the interface implementation. These methods can be run directly from the interface.
This was done for backward compatibility for your collections in your interfaces. It is to solve the problem of allowing the
Stream to be put into an interface without having to change all of the classes to implement the new method. Basically, create a
default method in the interface, and all the classes that implement the interface can use the
Stream (or whatever is put into the default method). If the default method is not correct for the implementation, it can be overridden
in the implementer.
What this essentially does is allow a form of multiple inheritance. This becomes the implementer's problem, as the implementer will be required to override the method anyway. The implementer could then choose which supermethod to use, but this means a lot of classes that implement interfaces could still be changed.
This is probably the detail that will concern most people in Java 8. Perhaps it won't bother those already familiar with Scala.
It can be compared directly with the concept of traits in Scala; although the concept is not unique to Scala, it is best known
to the Java world from Scala. However, there are some differences: Java 8 functional interfaces can not get a reference to
the implementing class. Scala allows this with the
self keyword. Language nerds will say that Java 8's functional interfaces allow multiple inheritance of behavior, but not state.
Scala's traits are multiple inheritance for both behavior and state.
Consider the power of traits and the stuff we do to work around not having them in Java. In Java to implement transactions and other items, we construct dynamic proxies and do bytecode manipulation with JavaAssist or extend classes with cglib. Traits give us ways to do this more directly in some cases.
On one hand, functional interfaces will probably be misused the way that inheritance is misused. On the other hand, they don't go as far as Scala's traits. We'll still be stuck with some level of bit-twiddling class-loader implementation via Aspect Oriented Programming-type notes in Java in places where traits could probably stand in.
Lambda expressions are coming to Java in version 8. Lambda expressions are designed to allow code to be streamlined. When a Lambda expression is written, it is translated into a functional interface at compile time. Here is an example of using Lambda expressions to replace an anonymous inner class with much cleaner and more readable code.