Java 8 features:--
Some of the important Java 8 features are,
- Lambda Expression
- static and default methods in interface
- Java Stream
- Functional Interfaces
- Java Time API
- Collection Improvement.
- Concurrency API improvement
- Java IO improvement
- Lambda Expression
->) and place the expression or body on the right side of the operator.//Java 7: new Thread(new Runnable() { @Override public void run() { System.out.println("Before Java8, runnable run() method"); } }).start(); //Java 8 way: new Thread(() -> System.out.println("In Java8, Lambda expression !!") ).start();
The advantages of lambda expressions are:
-
They reduce the amount of code.
-
They support both sequential and parallel execution by passing behavior into methods using the Stream API.
-
When combined with the Stream API, lambda expressions can achieve higher efficiency (through parallel execution) for bulk operations on collections.
- static and default methods in interface
Java 8 changed this by introducing default and static methods in interfaces. Default methods, in particular, were added to solve a long-standing problem: how to evolve an interface without breaking the classes that already implement it. With default methods, developers can now add new functionality directly to interfaces while still maintaining backward compatibility. This made interfaces far more powerful and flexible, especially when designing APIs.
Default method Example:-In the below example, InterfaceEx interface has default method method1(), which is implemented in interface itself, no need to implement in the implementing classes.
interface InterfaceEx { // This is a default method, no need to implement in the implementation classes. default void method1(){ System.out.println("Java 8 default method"); } // abstract method, need to implement in implementing classes public void existingabstractMethod(String str); } public class JavaEx implements InterfaceEx { // implementing abstract method public void existingabstractMethod(String str){ System.out.println("Existing Java abstract method implementation"); } public static void main(String[] args) { JavaEx ex = new JavaEx(); //calling the default method of interface ex.method1(); //calling the abstract method of interface ex.existingabstractMethod("Java 8 features"); } }
Output:--
Java 8 default method
Existing Java abstract method implementation
Static method in interfaces are similar to the default methods except that we cannot override these methods in the classes that implements these interfaces.
Static method example:--
interface InterfaceEx { // This is a default method, no need to implement in the implementation classes. default void method1(){ System.out.println("Java 8 default method"); } static void staticMethod() { System.out.println("Java 8 static method"); } // abstract method, need to implement in implementing classes public void existingabstractMethod(String str); } public class JavaEx implements InterfaceEx { // implementing abstract method public void existingabstractMethod(String str){ System.out.println("Existing Java abstract method implementation"); } public static void main(String[] args) { JavaEx ex = new JavaEx(); //calling the default method of interface ex.method1();
// call static method using interface InterfaceEx.staticMethod();
//calling the abstract method of interface
ex.existingabstractMethod("Java 8 features");
}
}
Output:--
Java 8 default method
Java 8 static method
Existing Java abstract method implementation.
- Java Stream
A stream does not store data and, in that sense, is not a data structure. It also never modifies the underlying data source.
In Java 8, a stream takes input from collections, arrays, or I/O channels and produces results based on the pipelined operations. Each intermediate operation is executed lazily and returns a stream, allowing multiple operations to be chained together. Terminal operations mark the end of the stream pipeline and produce the final result.
Different ways to build the Stream:--
1) Using Stream.of(val1, val2, val3….or arrayOfElements)
public class StreamApi { public static void main(String[] args){ Stream<Integer> stream = Stream.of(1,2,3,4,5,6,7,8,9); stream.forEach(p -> System.out.println(p)); } }
2) Using list.stream()
public class StreamEx { public static void main(String[] args){ List<Integer> list = Arrays.asList(new Integer[]{2,3,4,6,7,9}); Stream<Integer> stream = list.stream(); stream.forEach(p -> System.out.println(p)); } }
3) Using Stream.forEach() function
public class StreamEx { public static void main(String[] args){ List<Integer> list = Arrays.asList(new Integer[]{2,3,4,6,7,9}); Stream<Integer> stream = list.stream(); stream.forEach(p -> System.out.println(p)); } }
4) Using Stream.collect(Collectors.toList()) function - Convert Stream to List
public class StreamEx { public static void main(String[] args){ List<Integer> list = Arrays.asList(new Integer[]{2,3,4,6,7,9}); Stream<Integer> stream = list.stream(); List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0).collect(Collectors.toList()); System.out.print(evenNumbersList); } }
5) Using Stream.toArray(EntryType[]::new) function - Convert Stream to array
public class StreamEx { public static void main(String[] args){ List<Integer> list = Arrays.asList(new Integer[]{2,3,4,6,7,9}); Stream<Integer> stream = list.stream(); List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0).toArray(Integer[]::new); System.out.print(evenNumbersList); } }
6) Intermediate filter() Operation
Filter accepts a predicate to filter all elements of the stream. This operation is intermediate which enables us to call another stream operation (e.g. forEach) on the result.
list.stream().filter((s) -> i%2 == 0) .forEach(System.out::println); Output: 2 4
7) Intermediate map() operation
The intermediate operation map converts each element into another object via the given function. The following example converts each string into an upper-cased string. But you can also use map to transform each object into another type.
names.stream().filter((s) -> s.startsWith("A")) .map(String::toUpperCase) .forEach(System.out::println); Output: AMAR ANKITA
8) Intermediate sorted() operation
Sorted is an intermediate operation which returns a sorted view of the stream.
names.stream().sorted() .map(String::toUpperCase) .forEach(System.out::println); Output: AMAR KIRAN
- Functional Interface
The @FunctionalInterface annotation can be used explicitly to indicate that a given interface should be treated as a functional interface.
@FunctionalInterface interface FunctionalIntrface { int operation(int a, int b); }
If you try to add the second abstract method in the above code, will get compilation error.
@FunctionalInterface interface FnInteface { int operation(int a, int b); String getEmplName(Long empId); }
will get compilation error as,
Unexpected @FunctionalInterface annotation
@FunctionalInterface ^ FnInteface is not a functional interface
multiple non-overriding abstract methods found in interface FnInteface
Runnable is a great example of functional interface with single abstract method run().
- Java Time API
Working with date, time, and time zones in Java has always been challenging. Prior to Java 8, there was no standard API for handling date and time consistently. One of the notable additions in Java 8 is the
java.time package, which streamlines working with time in Java.From the structure of the Java Time API, it is clear that it is designed to be easy to use. It includes sub-packages such as java.time.format, which provides classes for printing and parsing dates and times, and java.time.zone, which offers support for time zones and their rules.
The new Time API prefers enums over integer constants for months and days of the week, making code more readable and less error-prone. One particularly useful class is DateTimeFormatter, which allows easy conversion between date-time objects and strings.
Reference :--Java 8 Date – LocalDate, LocalDateTime, Instant
- Collection API Improvement
forEach() method and the Stream API for collections. Several new methods have been added to the Collection API:-
Iterator: Default method
forEachRemaining(Consumer<? super E> action)performs the given action for each remaining element until all elements have been processed or the action throws an exception. -
Collection: Default method
removeIf(Predicate<? super E> filter)removes all elements of the collection that satisfy the given predicate. -
Collection: Method
spliterator()returns aSpliteratorinstance that can be used to traverse elements sequentially or in parallel. -
Map: New methods
replaceAll(),compute(), andmerge()provide more flexible operations on map entries. -
HashMap: Performance improvements have been made for handling key collisions more efficiently.
- Concurrency API improvements
- ConcurrentHashMap compute(), forEach(), forEachEntry(), forEachKey(), forEachValue(), merge(), reduce() and search() methods.
- CompletableFuture that may be explicitly completed (setting its value and status).
- Executors newWorkStealingPool() method to create a work-stealing thread pool using all available processors as its target parallelism level.
- Java IO Improvement
- Files.list(Path dir) that returns a lazily populated Stream, the elements of which are the entries in the directory.
- Files.lines(Path path) that reads all lines from a file as a Stream.
- Files.find() that returns a Stream that is lazily populated with Path by searching for files in a file tree rooted at a given starting file.
- BufferedReader.lines() that return a Stream, the elements of which are lines read from this BufferedReader.
No comments:
Post a Comment