Introduction to Java 8 Features

Java 8 introduced several new features that enhance the programming experience and enable more efficient and expressive code. These features include:

• Lambdas: Lambdas provide a concise way to write code by allowing the use of anonymous functions.

• Stream API: The Stream API allows for efficient processing of collections, enabling filtering, mapping, and reducing operations.

• Default Methods: Default methods provide a way to add new methods to existing interfaces without breaking compatibility with implementing classes.

• Optional Class: The Optional class provides a way to deal with potentially null values in a more structured and safe manner.

• Date and Time API: Java 8 introduced a new Date and Time API that provides improved functionality for handling dates, times, and time zones.

• Method References: Method references allow for a more concise way to refer to existing methods and pass them as arguments.

• Functional Interfaces: Functional interfaces are interfaces with a single abstract method and can be used as the basis for lambda expressions and method references.

• Parallel Streams: Parallel streams allow for concurrent execution of stream operations, improving performance on multi-core systems.

To illustrate the usage of some of these features, here's an example of using the Stream API to calculate the sum of even numbers from a list:

1import java.util.Arrays;
2import java.util.List;
3
4public class Main {
5  public static void main(String[] args) {
6    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
7    int sum = numbers.stream()
8                    .filter(n -> n % 2 == 0)
9                    .mapToInt(n -> n)
10                    .sum();
11    System.out.println(sum); // Output: 6
12  }
13}

In this example, we create a stream from a list of integers and use the filter method to filter out odd numbers. Then, we use the mapToInt method to convert the stream of integers to an IntStream and calculate the sum using the sum method. The final result is printed, which is the sum of the even numbers from the list.

xxxxxxxxxx

import java.util.Arrays;

import java.util.List;

​

public class Main {

  public static void main(String[] args) {

    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

    int sum = numbers.stream()

                    .filter(n -> n % 2 == 0)

                    .mapToInt(n -> n)

                    .sum();

    System.out.println(sum); // Output: 6

  }

}

Lambda Expressions

Lambda expressions are a powerful feature introduced in Java 8 that allow you to write concise and expressive code. They provide a way to represent anonymous functions and can be used in place of functional interfaces.

Syntax

A lambda expression consists of the following parts:

• Parameter list: It represents the input parameters of the anonymous function.
• Arrow token: It separates the parameter list from the body of the lambda expression.
• Body: It represents the code that is executed when the lambda expression is invoked.

The general syntax of a lambda expression is:

1(parameter-list) -> { body }

Here's an example:

1Runnable r = () -> {
2    System.out.println("Hello, World!");
3};

In this example, the lambda expression represents an anonymous function that takes no parameters and prints "Hello, World!" when invoked.

Usage

Lambda expressions are most commonly used with functional interfaces, which are interfaces that have a single abstract method. The lambda expression provides an implementation for this single method, allowing you to pass behavior as an argument to methods or assign it to variables.

Here's an example of using a lambda expression with the forEach method of the List interface:

1import java.util.ArrayList;
2import java.util.List;
3
4public class Main {
5
6    public static void main(String[] args) {
7        List<Integer> numbers = new ArrayList<>();
8        numbers.add(1);
9        numbers.add(2);
10        numbers.add(3);
11        numbers.add(4);
12        numbers.add(5);
13        
14        numbers.forEach(n -> System.out.println(n));
15    }
16
17}

In this example, we create a list of integers and use the forEach method to iterate over each element and print it. The lambda expression (n -> System.out.println(n)) represents the code that is executed for each element of the list.

Lambda expressions provide a concise and expressive way to represent behavior, making your code more readable and maintainable.

xxxxxxxxxx

import java.util.ArrayList;

import java.util.List;

​

public class Main {

​

    public static void main(String[] args) {

        List<Integer> numbers = new ArrayList<>();

        numbers.add(1);

        numbers.add(2);

        numbers.add(3);

        numbers.add(4);

        numbers.add(5);

        numbers.forEach(n -> System.out.println(n));

    }

​

}

Functional Interfaces

In Java 8, the concept of functional interfaces was introduced to support lambda expressions. A functional interface is an interface that contains only one abstract method. The @FunctionalInterface annotation is used to indicate that an interface is intended to be functional.

Functional interfaces play a crucial role in lambda expressions because they allow lambda expressions to be bound to them. By implementing a functional interface, you can define the behavior of the lambda expressions.

Here is an example of a functional interface:

1@FunctionalInterface
2interface FunctionalInterface {
3  void execute();
4}

In this example, the FunctionalInterface defines a single abstract method execute(). Any lambda expression that matches the signature of this method can be used as an instance of the FunctionalInterface.

To use a functional interface and its corresponding lambda expression, you can write code like this:

1FunctionalInterface fi = () -> {
2  // Code block
3};
4fi.execute();

In this code, we declare an instance of the FunctionalInterface and assign a lambda expression to it. The lambda expression represents the implementation of the execute() method.

Functional interfaces are widely used in Java 8 features such as the Stream API and the forEach method of the Iterable interface. They provide a powerful mechanism for defining behavior in a concise and expressive way, making your code more readable and maintainable.

xxxxxxxxxx

class Main {

  public static void main(String[] args) {

    // replace with your Java logic here

    FunctionalInterface fi = () -> {

      // Code block

    };

    fi.execute();

  }

}

Stream API

The Stream API introduced in Java 8 provides a more efficient and concise way to process collections of data.

Java Stream API allows you to perform various operations such as filtering, mapping, reducing, and collecting on collection objects.

To begin using the Stream API, you first need to create a stream from a collection or an array. You can then apply various stream operations to process the elements of the stream.

Let's take a look at an example using the Stream API:

1import java.util.ArrayList;
2import java.util.List;
3
4public class StreamExample {
5
6  public static void main(String[] args) {
7    List<String> fruits = new ArrayList<>();
8    fruits.add("Apple");
9    fruits.add("Banana");
10    fruits.add("Orange");
11    
12    // Stream API example
13    fruits.stream()
14            .filter(fruit -> fruit.length() > 5)
15            .forEach(System.out::println);
16  }
17}

In this example, we have a list of fruits and we want to filter out the fruits whose names have more than 5 characters. Using the Stream API, we can easily achieve this by chaining the filter() operation followed by the forEach() operation.

The filter() operation takes a lambda expression as an argument and returns a new stream that contains only the elements that match the given condition. In this case, we filter out the fruits whose length is greater than 5.

The forEach() operation then iterates over the filtered stream and performs an action on each element. In this case, we print each filtered fruit to the console.

By using the Stream API, we can write more expressive and concise code to process collections of data, making our code more readable and maintainable.

xxxxxxxxxx

import java.util.ArrayList;

import java.util.List;

​

public class StreamExample {

​

  public static void main(String[] args) {

    List<String> fruits = new ArrayList<>();

    fruits.add("Apple");

    fruits.add("Banana");

    fruits.add("Orange");

    // Stream API example

    fruits.stream()

            .filter(fruit -> fruit.length() > 5)

            .forEach(System.out::println);

  }

}

Method References

In Java 8, a method reference is a shorthand notation for a lambda expression that calls a specific method.

Method references can be used when the lambda expression simply calls an existing method without doing any additional computation or modification. This allows for cleaner and more concise code.

Let's take a look at an example using method references:

1import java.util.ArrayList;
2import java.util.List;
3
4public class MethodReferencesExample {
5
6  public static void main(String[] args) {
7    List<String> fruits = new ArrayList<>();
8    fruits.add("Apple");
9    fruits.add("Banana");
10    fruits.add("Orange");
11    
12    // Method references example
13    fruits.forEach(System.out::println);
14  }
15}

In this example, we have a list of fruits and we want to print each fruit to the console. Instead of using a lambda expression, we can use a method reference System.out::println as a shorthand notation. This method reference refers to the static method println of the System.out object.

Method references offer a more concise and readable way to express certain lambda expressions, making our code easier to understand and maintain.

xxxxxxxxxx

import java.util.ArrayList;

import java.util.List;

​

public class MethodReferencesExample {

​

  public static void main(String[] args) {

    List<String> fruits = new ArrayList<>();

    fruits.add("Apple");

    fruits.add("Banana");

    fruits.add("Orange");

    // Method references example

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

  }

}

Default Methods

In Java 8, default methods were introduced in interfaces to provide a way to add new functionality to existing interfaces without breaking compatibility with the classes that implemented those interfaces.

Default methods in interfaces have a method body, allowing them to provide a default implementation of the method. Classes that implement the interface can use this default implementation or override it with their own implementation.

Let's take a look at an example:

1interface Animal {
2
3    void eat();
4
5    default void sleep() {
6        System.out.println("Animal is sleeping");
7    }
8
9}
10
11class Dog implements Animal {
12
13    public void eat() {
14        System.out.println("Dog is eating");
15    }
16
17}
18
19public class Main {
20
21    public static void main(String[] args) {
22        Dog dog = new Dog();
23        dog.eat();
24        dog.sleep();
25    }
26
27}

In this example, we have an interface Animal with a default method sleep(). The class Dog implements the Animal interface and provides its own implementation of the eat() method. The sleep() method inherits the default implementation from the interface.

The output of the above program will be:

1Dog is eating
2Animal is sleeping
3```\n\n\nDefault methods in interfaces are useful when we want to add new functionality to interfaces in a backward-compatible manner. They provide a way to extend interfaces without breaking existing code that implements those interfaces.

xxxxxxxxxx

interface Animal {

​

    void eat();

​

    default void sleep() {

        System.out.println("Animal is sleeping");

    }

​

}

​

class Dog implements Animal {

​

    public void eat() {

        System.out.println("Dog is eating");

    }

​

}

​

class Main {

​

    public static void main(String[] args) {

        Dog dog = new Dog();

        dog.eat();

        dog.sleep();

    }

​

}

Optional Class

In Java, the Optional class was introduced in Java 8 to handle null values and avoid NullPointerExceptions. It provides a way to encapsulate an optional value.

To create an Optional object, you can use the static methods of() and ofNullable(). The of() method expects a non-null value, while the ofNullable() method can accept both null and non-null values.

Here's an example:

1import java.util.Optional;
2
3public class Main {
4
5    public static void main(String[] args) {
6        String name = null;
7        Optional<String> optionalName = Optional.ofNullable(name);
8
9        if (optionalName.isPresent()) {
10            System.out.println("Name: " + optionalName.get());
11        } else {
12            System.out.println("Name is not present");
13        }
14    }
15
16}

In this example, we have a variable name that is null. We create an Optional object, optionalName, using the ofNullable() method. We can then use the isPresent() method to check if a value is present in the Optional object, and the get() method to retrieve the value.

If the value is present, we print it as "Name: [value]", otherwise, we print "Name is not present".

By using the Optional class, we can handle null values more gracefully and avoid NullPointerExceptions. It encourages a more explicit and safer coding style by forcing the developer to check for the presence of a value before using it.

xxxxxxxxxx

import java.util.Optional;

​

public class Main {

​

    public static void main(String[] args) {

        String name = null;

        Optional<String> optionalName = Optional.ofNullable(name);

        if (optionalName.isPresent()) {

            System.out.println("Name: " + optionalName.get());

        } else {

            System.out.println("Name is not present");

        }

    }

​

}

The Optional class in Java 8 is used to handle null values and avoid NullPointerExceptions. (Solution: true)

Explanation: The statement is true because the Optional class provides a way to encapsulate an optional value and avoids the need to explicitly check for null values. It encourages a more explicit and safer coding style by forcing the developer to check for the presence of a value before using it.

Date and Time API

The Date and Time API in Java 8 introduced a new set of classes for handling dates, times, and time zones. It provides a more comprehensive and intuitive way to work with dates and times compared to the older java.util.Date and java.util.Calendar classes.

Java 8 Date and Time Classes

The main classes in the Date and Time API include:

• LocalDate: Represents a date without time, such as 2023-07-12.
• LocalTime: Represents a time without a date, such as 14:30:45.
• LocalDateTime: Represents a date and time, such as 2023-07-12T14:30:45.
• ZonedDateTime: Represents a date, time, and time zone.

These classes provide various methods for manipulating and formatting dates and times.

Example

Here's an example of how to use the Date and Time API:

1import java.time.LocalDate;
2import java.time.LocalTime;
3import java.time.LocalDateTime;
4
5public class Main {
6  public static void main(String[] args) {
7    LocalDate date = LocalDate.now();
8    LocalTime time = LocalTime.now();
9    LocalDateTime dateTime = LocalDateTime.now();
10
11    System.out.println("Current Date: " + date);
12    System.out.println("Current Time: " + time);
13    System.out.println("Current Date and Time: " + dateTime);
14  }
15}

This code snippet demonstrates how to get the current date, time, and date-time using the Date and Time API. The now() method is used to obtain the current date, time, or date-time instance.

The output will vary every time you run the program, but it will be similar to:

1Current Date: 2023-07-12
2Current Time: 14:30:45
3Current Date and Time: 2023-07-12T14:30:45

xxxxxxxxxx

import java.time.LocalDate;

import java.time.LocalTime;

import java.time.LocalDateTime;

​

public class Main {

  public static void main(String[] args) {

    LocalDate date = LocalDate.now();

    LocalTime time = LocalTime.now();

    LocalDateTime dateTime = LocalDateTime.now();

​

    System.out.println("Current Date: " + date);

    System.out.println("Current Time: " + time);

    System.out.println("Current Date and Time: " + dateTime);

  }

}

Completable Futures

CompletableFuture is a class introduced in Java 8 to support asynchronous and concurrent programming. It represents a computation that may or may not have completed yet and provides a way to chain dependent computations, handle exceptions, and compose multiple CompletableFuture instances.

Creating a CompletableFuture

To create a CompletableFuture, you can use the CompletableFuture constructor, which creates an incomplete CompletableFuture that can be completed manually later. Here's an example:

1CompletableFuture<String> completableFuture = new CompletableFuture<>();

xxxxxxxxxx

import java.util.concurrent.CompletableFuture;

​

public class Main {

​

  public static void main(String[] args) {

    // Create a CompletableFuture

    CompletableFuture<String> completableFuture = new CompletableFuture<>();

​

    // Perform some async task

    new Thread(() -> {

      try {

        // Simulate a long-running task

        Thread.sleep(2000);

        // Complete the CompletableFuture with a result

        completableFuture.complete("Async task completed!");

      } catch (InterruptedException e) {

        // Handle any exceptions

        completableFuture.completeExceptionally(e);

      }

    }).start();

​

    // Get the result from the CompletableFuture

    completableFuture.thenAccept(result -> {

      System.out.println(result);

    });

​

    System.out.println("Waiting for async task to complete...");

  }

}

Collectors

In Java 8, the Collectors class provides various static methods that allow us to perform reduction operations on streams. A reduction operation combines the elements of a stream into a single result by applying a specified reduction function.

One commonly used collector is summingInt(), which calculates the sum of the elements in a stream. Here's an example:

1List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
2
3int sum = numbers.stream()
4                .collect(Collectors.summingInt(Integer::intValue));
5
6System.out.println(sum); // Output: 15

In this example, we have a list of integers and we use the stream() method to create a stream from the list. We then use the summingInt() collector to calculate the sum of the elements in the stream.

Feel free to modify the list of numbers and see the result!

By using collectors, we can easily perform common reduction tasks on streams without having to write complex logic manually.

xxxxxxxxxx

```java\nclass Main {\n  public static void main(String[] args) {\n  // replace with your Java logic here\n  List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);\n  int sum = numbers.stream()\n              .collect(Collectors.summingInt(Integer::intValue));\n  System.out.println(sum);\n  }\n}\n```

Parallel Streams

In Java 8, the Stream API introduced the concept of parallel streams, which allows us to harness the power of multi-threading in order to process stream elements in parallel and improve performance.

Traditionally, stream operations are performed sequentially, where each element is processed one by one. However, when dealing with large datasets or computationally intensive operations, processing elements sequentially may result in slower performance.

By utilizing parallel streams, we can divide the stream into multiple chunks and process each chunk in parallel on separate threads. This enables us to take advantage of multi-core processors and distribute the workload, potentially reducing the overall processing time.

To create a parallel stream, we simply need to call the parallelStream() method instead of the stream() method. Here's a code example:

1List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
2
3int sum = numbers.parallelStream()
4                .reduce(0, Integer::sum);
5
6System.out.println(sum); // Output: 15

In this example, we have a list of integers and we use the parallelStream() method to create a parallel stream. We then use the reduce() method to calculate the sum of the elements in the stream, with an initial value of 0. Finally, we print the result.

Keep in mind that not all operations are suitable for parallel processing, as some operations may have dependencies or produce non-deterministic results. It's important to evaluate the requirements and characteristics of your specific use case to determine whether parallel streams can provide performance benefits.

Feel free to modify the list of numbers and see the result!

By leveraging parallel streams, we can effectively utilize multi-threading capabilities to improve the performance of stream operations in Java 8.

xxxxxxxxxx

import java.util.Arrays;

import java.util.List;

​

public class Main {

​

    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

​

        int sum = numbers.parallelStream()

                .reduce(0, Integer::sum);

​

        System.out.println(sum);

    }

​

}

New IO API

In Java 8, a new IO API was introduced to provide more efficient and versatile options for handling input and output operations. This API includes classes such as InputStream, OutputStream, Reader, and Writer along with their respective subclasses and implementations.

One of the major improvements in the new IO API is the addition of try-with-resources statement, which automates the closing of resources after use. This helps in avoiding resource leaks and simplifies the code.

Here's an example that demonstrates the usage of the new IO API to read a file using the BufferedReader class:

1import java.io.BufferedReader;
2import java.io.FileReader;
3import java.io.IOException;
4
5public class NewIOAPIExample {
6
7    public static void main(String[] args) {
8        try {
9            // Creating a FileReader object
10            FileReader fileReader = new FileReader("example.txt");
11
12            // Creating a BufferedReader object
13            BufferedReader bufferedReader = new BufferedReader(fileReader);
14
15            // Reading the file line by line
16            String line;
17            while ((line = bufferedReader.readLine()) != null) {
18                System.out.println(line);
19            }
20
21            // Closing the BufferedReader
22            bufferedReader.close();
23        } catch (IOException e) {
24            e.printStackTrace();
25        }
26    }
27}

In this example, we create an instance of FileReader and BufferedReader. We then use the BufferedReader object to read the contents of a file line by line and print them to the console. Finally, we close the BufferedReader in the try block using the try-with-resources statement.

The new IO API provides more flexibility and convenience for handling input and output operations in Java 8, making it easier to work with files, streams, and other sources of data.

xxxxxxxxxx

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

​

public class NewIOAPIExample {

​

    public static void main(String[] args) {

        try {

            // Creating a FileReader object

            FileReader fileReader = new FileReader("example.txt");

​

            // Creating a BufferedReader object

            BufferedReader bufferedReader = new BufferedReader(fileReader);

​

            // Reading the file line by line

            String line;

            while ((line = bufferedReader.readLine()) != null) {

                System.out.println(line);

            }

​

            // Closing the BufferedReader

            bufferedReader.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}