java 8 features

 

1. Lambda Expressions

A lambda expression allows you to write concise code by passing behavior as a parameter.

Example:

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

public class LambdaExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // Using lambda expression
        names.forEach(name -> System.out.println(name));
    }
}


2. Stream API
The Stream API provides a functional approach to process collections of data.
Example:
import java.util.Arrays;
import java.util.List;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        // Filtering and mapping with Stream API
        numbers.stream()
               .filter(n -> n % 2 == 0) // Filters even numbers
               .map(n -> n * n)        // Squares the numbers
               .forEach(System.out::println);
    }
}

3. Default Methods in Interfaces
Java 8 allows you to add default implementations to methods in interfaces.
Example:
interface Vehicle {
    default void start() {
        System.out.println("Vehicle is starting...");
    }
}

class Car implements Vehicle {
}

public class DefaultMethodExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.start(); // Calls the default method
    }
}

4. Functional Interfaces and @FunctionalInterface Annotation
A functional interface has exactly one abstract method and can be represented with 
a lambda expression.
Example:
@FunctionalInterface
interface Calculator {
    int operate(int a, int b);
}

public class FunctionalInterfaceExample {
    public static void main(String[] args) {
        Calculator addition = (a, b) -> a + b;
        System.out.println("Addition: " + addition.operate(5, 3));
    }
}

5. Optional Class
The Optional class is used to handle null values gracefully.
Example:
import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> name = Optional.ofNullable("John");

        name.ifPresentOrElse(
            System.out::println, 
            () -> System.out.println("Name is not present")
        );
    }
}
6. Method References
Method references are a shorthand for referring to methods or constructors using ::.
Example:
import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // Method reference to print each name
        names.forEach(System.out::println);
    }
}

7. Date and Time API
Java 8 introduced a new date and time API under the java.time package.
Example:
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;

public class DateTimeExample {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        LocalTime time = LocalTime.now();
        LocalDateTime dateTime = LocalDateTime.now();

        System.out.println("Date: " + date);
        System.out.println("Time: " + time);
        System.out.println("DateTime: " + dateTime);
    }
}

8. Collectors in Stream API
Collectors provides utility methods for processing streams.
Example:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CollectorsExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Bob");

        // Collect unique names into a list
        List<String> uniqueNames = names.stream()
                                        .distinct()
                                        .collect(Collectors.toList());
        System.out.println(uniqueNames);
    }
}