Play Store Application link – https://play.google.com/store/apps/details?id=com.ideepro.java25hours

Note – The latest stable release of Java is Java 17. Java 17 was released on September 17, 2021 and is the latest long-term support (LTS) release.

Java 18, 19 are also available, but these releases are not long-term support releases and are intended for early adopters and developers who want to try out new features and APIs.

JAVA 20 and JAVA 21 – See last line of this page-

Java 7 (released in 2011)

Java 8 (released in 2014)

1- In Java, you can use lambda expressions to create implementation of functional interfaces. A functional interface is an interface with a single abstract method. Here is an example of a lambda expression in Java:

// Functional interface
@FunctionalInterface
interface MultiInter {
  int multiply(int x, int y);
}

public class Main {
  public static void main(String[] args) {
    // Lambda expression to multiply two numbers
    MultiInter multi = (int x, int y) -> x * y;
    
    // Call the lambda function
    int result = multi.multiply(4, 5);
    System.out.println(result);  // Output: 20
  }
}

In this example, the functional interface MultiInter has a single abstract method multiply that takes two int arguments and returns an int. The lambda expression (int x, int y) -> x * y implements this abstract method and defines the logic for multiplying two numbers. The lambda expression is assigned to the functional interface MultiInter , and the lambda function can be called by calling the multiply method on the interface.

2- Stream API: The Stream API is a set of methods that allow you to perform operations on collections of data in a functional style. For example, the following code uses the Stream API to find the first even number in a list:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> firstEven = numbers.stream()
.filter(x -> x % 2 == 0)
.findFirst();
System.out.println(firstEven.get()); // prints 2

3- In Java, a method reference is a way to refer to a method without actually invoking it. Method references can be used to pass methods as arguments to other methods, or to construct new functions from existing methods.

Here is an example of a method reference in Java 8:

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
public static void main(String[] args) {
List<String> strings = Arrays.asList("a", "b", "c", "d");

// Use a lambda expression to print all elements in the list
strings.forEach(s -> System.out.println(s));

// Use a method reference to print all elements in the list
strings.forEach(System.out::println);
}
}
In this example, the forEach method of the List interface takes a lambda expression as an argument. The lambda expression specifies that for each element in the list, it should be printed to the console. The second call to forEach uses a method reference to the println method of the System.out object instead of a lambda expression.

Both of these calls to forEach will have the same effect, printing all elements of the strings list to the console.

Java 9 (released in 2017)

Java 10 (released in 2018)

Java 11 (released in September 2018)

Java 12 (released in March 2019)

Java 13 (released in September 2019)

Java 14 (released in March 2020)

Java 15 (released in September 2020)

Java 16 (released in March 2021)

Java 17 (released in September 2021)

Java 18 (released in March 2022)

Java 19 (released in September 2022)

• Records:
  • In Java 19, records have been further improved with the ability to specify custom “deep copy” methods, which are used to create a new instance of the record with copies of its components.
  Copy coderecord Point(double x, double y) { public Point { if (x < 0 || y < 0) { throw new IllegalArgumentException("Coordinates must be non-negative"); } } // Custom deep copy method public Point copy() { return new Point(x, y); } }
• Enhanced Enums:
  • Java 19 introduces several new features for enums, including the ability to use the record keyword to define an enum with record components, and the ability to use the sealed keyword to restrict the inheritance of an enum.
  Copy codesealed interface Shape permits Circle, Rectangle { } record Circle(double radius) implements Shape { } record Rectangle(double width, double height) implements Shape { }

JAVA 20 and JAVA 21 – Going to be released in March 2023 and September 2023 respectively, Stay tuned!