Java Java 8 Interview Questions

Stream provides lazy, functional pipeline for processing collections; chains operations (map, filter, reduce) without modifying source, enabling parallel processing.

List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
nums.stream().filter(n -> n > 2).map(n -> n * 2).forEach(System.out::println);

Functional interface has exactly one abstract method, allowing lambda expression implementation; annotated with @FunctionalInterface (e.g., Comparator, Function).

@FunctionalInterface interface Calculator {
  int calculate(int a, int b);
}
Calculator add = (a, b) -> a + b;
System.out.println(add.calculate(5, 3));

Lambda is a concise anonymous function syntax (parameter -> expression) in Java 8+ that enables functional programming, often used with functional interfaces and streams.

List<String> fruits = Arrays.asList("apple", "banana", "orange");
fruits.forEach(f -> System.out.println(f));
Function<Integer, Integer> square = x -> x * x;

Enhanced for-loop (for-each) iterates over collections and arrays using Iterator internally; syntax: for(Type item : collection) eliminates index management and is cleaner than traditional for loops.

ForkJoinPool implements parallel streams using work-stealing algorithm where idle threads steal tasks from busy threads' queues, enabling efficient multi-core processing.

Method references are shortcuts for lambda expressions that call existing methods using syntax ClassName::methodName; internally compiled to invokedynamic bytecode instruction for runtime dispatch.

Java 8 introduced lambdas, streams API, functional interfaces, method references, default methods in interfaces, java.time package, and the Optional class.

Lambda expressions can access effectively final local variables and all instance/static variables from the enclosing scope.

Use `Collections.sort(list, (s1, s2) -> s1.compareTo(s2))` or `list.sort((s1, s2) -> s1.compareTo(s2))` for sorting with lambda expressions.

Four types: static method references (Class::staticMethod), instance method references (obj::method), constructor references (Class::new), and type method references (String::compareTo).

System.out::println is a method reference that passes System.out.println as a Consumer functional interface, equivalent to x -> System.out.println(x).

Primitive functional interfaces (DoubleFunction, IntFunction, LongFunction) avoid autoboxing overhead when working exclusively with primitive types.

Primitive BinaryOperator interfaces avoid autoboxing and are optimized for primitive arithmetic operations returning the same primitive type.

Primitive Predicate interfaces avoid boxing and provide optimized predicates for primitive type boolean tests.

Primitive Consumer interfaces avoid boxing for operations that consume primitive values without returning a result.

BiConsumer<T, U> accepts two parameters of different types and performs an action without returning a result.

BiFunction<T, U, R> accepts two parameters of different types and returns a result of type R, useful for binary operations.

BiPredicate<T, U> accepts two parameters of different types and returns a boolean, for testing conditions on two values.

Primitive conversion functional interfaces (ToDoubleFunction, ToIntFunction, ToLongFunction) convert from a type T to a primitive type.

ToDoubleBiFunction, ToIntBiFunction, ToLongBiFunction convert from two types T and U to their respective primitive types.

ToDoubleFunction<T>, ToIntFunction<T>, ToLongFunction<T> convert from type T to double, int, and long primitives respectively.

ObjDoubleConsumer, ObjIntConsumer, ObjLongConsumer consume an object and a primitive type without returning a result.

StringJoiner efficiently concatenates string sequences with a delimiter, prefix, and suffix, replacing manual StringBuilder concatenation.

Call a default method using `super.methodName()` in the implementing class, or explicitly reference it as `InterfaceName.super.methodName()`.

Static interface methods are concrete methods in interfaces (introduced Java 8) that can be called via the interface name without an instance, similar to static class methods.

Call static interface methods using the interface name directly: InterfaceName.staticMethod(), not through implementing classes or instances.

Streams can be created from Collections (collection.stream()), Arrays (Arrays.stream()), primitive sources (IntStream.range()), or using Stream.of() and Stream.generate().

Collections are in-memory data structures that hold all elements eagerly; Streams are lazy, functional pipelines that process elements on-demand without storing them.

collect() is a terminal operation that transforms stream elements into a different collection type using Collectors (e.g., toList(), toMap(), groupingBy()).

map() transforms each element to another value, while mapToInt/Double/Long() specialize in primitive streams to avoid boxing overhead and enable primitive-specific operations.

limit(n) is an intermediate operation that truncates the stream to return only the first n elements, useful for pagination or preventing infinite streams.

sorted() is an intermediate operation that orders stream elements either naturally or via a custom Comparator before passing them downstream.

flatMap() flattens nested streams by mapping each element to a stream and merging results; primitive variants (flatMapToInt/Double/Long) return primitive streams efficiently.

Terminal operations: forEach(), collect(), reduce(), min(), max(), count(), anyMatch(), allMatch(), findFirst(), findAny() - these produce final results or side effects.

Intermediate operations: filter(), map(), flatMap(), distinct(), sorted(), peek(), limit(), skip() - these return streams and can be chained.

Java 8 Map methods: getOrDefault(), putIfAbsent(), merge(), compute(), computeIfPresent(), computeIfAbsent(), forEach() for iteration without entrySet().

LocalDateTime represents an immutable date-time without timezone (e.g., 2024-01-15T10:30:00), used for local operations independent of geographic location.

ZonedDateTime represents an immutable date-time with timezone information (e.g., 2024-01-15T10:30:00+02:00[Europe/Paris]), handling zone-aware calculations.

Nashorn is a JavaScript engine that allows running JavaScript code on the JVM, included in Java 8-14; enables Java-JavaScript interoperability.

jjs is a command-line tool (Java Shell) that executes JavaScript files directly using the Nashorn engine without needing a separate JavaScript runtime.

Base64 class appears in java.util package for encoding/decoding Base64 data via Base64.getEncoder() and Base64.getDecoder().