Lambda Expressions
The biggest new feature of Java 8 is language level support for lambda expressions.
The point of lambda is to be able to pass some code to a method
rather than objects. Until java 8, the way to achieve this in java would
be to use callbacks. The issue with callbacks is that it leads to
verbose code. Like you would write 5 lines of code when the real job is
in 1 of these 5 lines.
The other scenario is when dealing with group of data to execute specific algorithm on it.
Here are few code examples of lambda expressions usage.
Inner classes
An example of what you would do today: btn.setOnAction(new EventHandler<ActionEvent>() {
@Override
public void handle(ActionEvent event) {
System.out.println("Hello World!");
}
});
btn.setOnAction(
event -> System.out.println("Hello World!")
);
Method references
Two examples with static and non statics methods.Statics method:
public class Utils {
public static int compareByLength(String in, String out){
return in.length() - out.length();
}
}
public class MyClass {
public void doSomething() {
String[] args = new String[] {"microsoft","apple","linux","oracle"}
Arrays.sort(args, Utils::compareByLength);
}
}
public class MyClass implements Comparable<MyObject> {
@Override
public int compareTo(MyObject obj) {return ...}
public void doSomething() {
MyObject myObject = new MyObject();
Arrays.sort(args, myObject::compareTo);
}
}
Date/Time changes
The Date/Time API is moved to java.time package and Joda time format is
followed. Another goodie is that most classes are Threadsafe and
immutable.
Stream Collection Types (java.util.stream)
A stream is a iterator that allows a single run over the collection it is called on. You can use streams to perform functional operations like filer or
map/reduce over collections which can be streamed as individual elements
using Stream objects. Streams can run sequentially or parallely as
desired. The parallel mode makes use of fork/join framework and can
leverage power of multiple cores.
Other – (nice to have) Changes
String.join() method is a welcome addition as a lot of self created
utility classes are created instead. So, the following example
Will get evaluated as “Java 8″.
The consequences of the PermGen removal is that obviously the PermSize and MaxPermSize JVM arguments are ignored and you will never get a java.lang.OutOfMemoryError: PermGen error.
However that doesn't mean you won't have to worry about the class metadata memory footprint and it does not eliminate class and classloader memory leaks.
Most allocations for the class metadata are now allocated out of native memory and classes used for describing the class metadata are removed. The Metaspace will dynamically re-size depending on the application demand at runtime. There is obviously some garbage collection involved but I don't think that there is much to worry about here unless you have a problem of classes, classloaders memory leak or an inadequate sizing of the metaspace (as you can specify the maximum metaspace capacity with MaxMetaspaceSize otherwise it is limited by the amount of available native memory).
String abc= String. join ( " " , "Java" , "8" ); |
Annotation on Java Types
Base64 Encoding/Decoding
Defines a standard API for BASE64 Encoding and Decoding
java.util.Base64.Encoder
java.util.Base64.Decoder
This feature means we don’t have to search around for other implementations, making things a bit easier.
Encoding
String base64 = Base64.getEncoder().encodeToString("string to encode".getBytes("utf-8")); |
Decoding
byte[] asBytes = Base64.getDecoder().decode("your base 64 string"); |
Functional interfaces
A functional interface is the one that defines exactly one abstract method. We have for instance “java.lang.Runnable” defining the run abstract method:
We can still add as many default methods (non abstract) as we like.
While defining a new functional interface, we will have to define the new annotation “@FunctionalInterface”. This will allow us to block bad usages of functional interfaces as it will not compile if used improperly with the new annotation.
public abstract void run(); |
While defining a new functional interface, we will have to define the new annotation “@FunctionalInterface”. This will allow us to block bad usages of functional interfaces as it will not compile if used improperly with the new annotation.
Remove the Permanent Generation
That is definitely a big one. The Permanent Generation (PermGen) space has completely been removed and is kind of replaced by a new space called Metaspace.The consequences of the PermGen removal is that obviously the PermSize and MaxPermSize JVM arguments are ignored and you will never get a java.lang.OutOfMemoryError: PermGen error.
However that doesn't mean you won't have to worry about the class metadata memory footprint and it does not eliminate class and classloader memory leaks.
Most allocations for the class metadata are now allocated out of native memory and classes used for describing the class metadata are removed. The Metaspace will dynamically re-size depending on the application demand at runtime. There is obviously some garbage collection involved but I don't think that there is much to worry about here unless you have a problem of classes, classloaders memory leak or an inadequate sizing of the metaspace (as you can specify the maximum metaspace capacity with MaxMetaspaceSize otherwise it is limited by the amount of available native memory).
Small VM
The goal here is to have a VM which is no more than 3Mb by allowing some features to be excluded at build time. The motivation behind this is to allow the JVM to run on small devices which have very strict static and dynamic memory-footprint requirements.
Parallel array sorting
Java 8 introduces a new API for sorting: Arrays#parallelSort.Arrays#parallelSort uses Fork/Join framework introduced in Java 7 to assign the sorting tasks to multiple threads available in the thread pool.
References:
https://leanpub.com/whatsnewinjava8/read
http://java.dzone.com/articles/java-8-permgen-metaspace
http://java.dzone.com/articles/introduction-functional-1
http://java.dzone.com/articles/introduction-functional-1