• Lambda Expressions
• Functional Interfaces
• Stream API
• Default and Static Methods in Interfaces
• Optional Class
• New Date and Time API (java.time package)
• Collectors and Collectors API
• Improved Type Inference
• Parallel Streams
• CompletableFuture and Asynchronous Programming
• New JavaScript Engine (Nashorn)

A functional interface in Java 8 is an interface that contains exactly one abstract method. It can have multiple default and static methods.
Functional interfaces are used for lambda expressions and method references.

• Predicate<T> - Represents a boolean-valued function of one argument.
• Function<T, R> - Represents a function that takes one argument and produces a result.
• Consumer<T> - Represents an operation that takes a single argument and returns no result.
• Supplier<T> - Represents a supplier of results without taking any input.
• BiFunction<T, U, R> - Represents a function that takes two arguments and produces a result.
• UnaryOperator<T> - A function that takes one argument and returns a result of the same type.
• BinaryOperator<T> - A function that takes two arguments of the same type and returns a result of the same type.

• Lambda Expression: A lambda expression is a concise way to represent an anonymous function in Java. It allows passing behavior as a parameter.
• Syntax: (parameters) -> expression or (parameters) -> { statements }
• Example: (a, b) -> a + b;

• Differences from Anonymous Class:
• Lambda expressions do not create a separate class file, whereas anonymous classes do.
• They have a more concise syntax compared to anonymous classes.
• They can only be used for functional interfaces (interfaces with a single abstract method).
• Anonymous classes can have multiple methods and instance variables, whereas lambdas cannot.
• Anonymous classes allow access to this referring to their own instance, but lambdas refer to the enclosing class instance.

• Purpose of default methods:
  • Allow interfaces to have method implementations.
  • Help in backward compatibility without breaking existing code.
  • Provide a way to add new functionality to interfaces without affecting implementing classes.
• Purpose of static methods:
  • Provide utility methods that belong to the interface itself.
  • Cannot be overridden by implementing classes.
  • Help in avoiding utility classes like Collections for small helper methods.

• The Optional class in Java 8 is used to handle null values safely and avoid NullPointerException.
• It acts as a container that may or may not contain a non-null value.
• Key methods of Optional include:
  • of(value): Creates an Optional with a non-null value.
  • ofNullable(value): Creates an Optional that can hold a null value.
  • empty(): Returns an empty Optional.
  • isPresent(): Checks if a value is present.
  • ifPresent(Consumer): Executes an action if a value is present.
  • orElse(defaultValue): Returns the value or a default if empty.
  • orElseGet(Supplier): Returns a computed default value if empty.
  • orElseThrow(Supplier): Throws an exception if no value is present.
• Example usage:

  •     Optional optionalValue = Optional.ofNullable(null);
        String result = optionalValue.orElse("Default Value");
        System.out.println(result); // Output: Default Value
                            

• Stream API:
  • Introduced in Java 8, the Stream API allows processing sequences of elements in a functional programming style.
  • It provides operations such as filtering, mapping, reducing, and sorting, which can be performed declaratively.
  • Streams work on data sources like Collections, Arrays, or I/O channels.
• Differences between Stream API and Collections:
  • Storage vs. Computation:
    • Collections are used to store and manage data in memory.
    • Streams do not store data; instead, they perform computations on the data.
  • Iteration:
    • Collections use external iteration, where the developer controls how elements are retrieved (e.g., for or while loops).
    • Streams use internal iteration, where iteration is handled by the Stream itself.
  • Mutability:
    • Collections allow modification of elements (adding, updating, or deleting).
    • Streams do not modify the original data but create new transformed Streams.
  • Lazy Evaluation:
    • Collections execute operations immediately when called.
    • Streams operate lazily, meaning computations are not performed until a terminal operation is invoked.
  • Parallel Execution:
    • Collections process elements sequentially by default.
    • Streams support parallel processing using parallelStream(), which can improve performance on multi-core processors.
  • Single-use vs. Reusability:
    • Collections can be iterated multiple times.
    • Streams can be consumed only once. A new Stream must be created for reprocessing.

• map(): Transforms each element in the stream using a function and returns a Stream of transformed elements.
• flatMap(): Transforms each element into a Stream and then flattens all resulting Streams into a single Stream.
• Key Difference:
  • map() produces a Stream of Streams when dealing with nested structures.
  • flatMap() merges the nested Streams into a single Stream.
• map() Example:
  • Given a list of numbers, we want to square each number.
  • List numbers = Arrays.asList(1, 2, 3, 4);
  • List squaredNumbers = numbers.stream().map(n -> n * n).collect(Collectors.toList());
  • Result: [1, 4, 9, 16]
• flatMap() Example:
  • Given a list of sentences, we want to split each sentence into words and flatten the result.
  • List sentences = Arrays.asList("Hello World", "Java Streams");
  • List words = sentences.stream().flatMap(sentence -> Arrays.stream(sentence.split(" "))).collect(Collectors.toList());
  • Result: [Hello, World, Java, Streams]

The forEach() method in Streams is used to iterate over the elements of the stream and perform a given action. It is part of the Stream API introduced in Java 8 and provides a functional-style iteration mechanism compared to the traditional for loop.

• How forEach() works in Streams:
  • It is a terminal operation in the Stream API.
  • It accepts a Consumer functional interface, which is applied to each element of the stream.
  • It performs the action on each element but does not return a value (void return type).
  • It is often used for side effects, such as printing or updating external variables.
• Example using forEach() in Streams:

      List names = Arrays.asList("Alice", "Bob", "Charlie");
      names.stream().forEach(name -> System.out.println(name));
          

  • Here, the stream processes the list of names and applies the System.out.println() method to each element in the stream.
• How is forEach() different from a traditional for loop?
  • Iteration style:
    • forEach() is functional and declarative, focusing on the action to perform.
    • The traditional for loop is imperative and focuses on the control flow.
  • Parallelism:
    • forEach() can work with parallel streams, allowing concurrent processing of elements.
    • Traditional for loops are usually sequential, and parallelism must be manually handled.
  • Side effects:
    • forEach() is commonly used for side effects (printing, logging, etc.), but it can sometimes make the code harder to debug due to the lack of control flow.
    • In contrast, traditional for loops are more predictable and flexible in controlling the iteration process.

Difference between findFirst() and findAny()

• findFirst():
  • Returns the first element of a stream.
  • It respects the encounter order of the stream.
  • If the stream is ordered (e.g., List, SortedSet), it will return the first element as per the order.
  • It is usually used when you want to guarantee getting the first element in a stream.
  • Example:
  • Optional first = Stream.of(1, 2, 3, 4).findFirst();
  • first.ifPresent(System.out::println); // Output: 1
• findAny():
  • Returns any element from the stream. It does not guarantee any specific element.
  • It is often used in parallel streams, where it can return any element without worrying about the order.
  • If the stream is unordered, it may return any element; if it is ordered, it can still return any element.
  • Example:
  • Optional any = Stream.of(1, 2, 3, 4).findAny();
  • any.ifPresent(System.out::println); // Output: (could be any element, e.g., 1)

Method references provide a way to refer to methods of classes or objects directly, using a compact, readable syntax. They are shorthand for lambda expressions when calling a method. Method references can be used where a functional interface is expected.

• Syntax: ClassName::methodName
• Types of method references:
  • Static method reference: Refers to a static method.
  • Instance method reference: Refers to an instance method of a specific object.
  • Instance method reference of an arbitrary object: Refers to an instance method of an object of a particular class.
  • Constructor reference: Refers to a constructor to create objects.

Examples:

• Static method reference:

  ClassName::staticMethodName

  Example: Math::max

  List numbers = Arrays.asList(1, 3, 2);
        numbers.stream().max(Math::max).ifPresent(System.out::println);

• Instance method reference:

  object::instanceMethodName

  Example: String::toUpperCase

  List words = Arrays.asList("hello", "world");
        words.stream().map(String::toUpperCase).forEach(System.out::println);

• Instance method reference of an arbitrary object of a particular type:

  ClassName::instanceMethodName

  Example: List::add

  List words = new ArrayList<>();
        Stream.of("apple", "banana").forEach(words::add);

• Constructor reference:

  ClassName::new

  Example: ArrayList::new

  Supplier> listSupplier = ArrayList::new;
        List list = listSupplier.get();