Java 8 Interview Questions

A concise way to represent an anonymous function that can be passed as an argument

A lambda expression is a concise representation of an anonymous function that can be passed around. It has parameters, an arrow token (->), and a body. For example: (a, b) -> a + b. Lambdas enable functional programming in Java and are primarily used to implement functional interfaces.

An interface with exactly one abstract method

A functional interface is an interface with exactly one abstract method (SAM — Single Abstract Method). It can have multiple default or static methods. The @FunctionalInterface annotation is optional but recommended — it causes a compile error if the interface has more than one abstract method.

A function that takes an argument and returns a boolean

Predicate<T> represents a boolean-valued function of one argument. Its abstract method is test(T t) which returns a boolean. It also provides default methods like and(), or(), and negate() for composing predicates. It is commonly used with Stream.filter().

Function takes an argument and returns a result; Consumer takes an argument and returns nothing (void)

Function<T, R> represents a function that accepts an argument of type T and produces a result of type R via its apply(T t) method. Consumer<T> represents an operation that accepts a single argument and returns no result via its accept(T t) method. Supplier<T> is the opposite of Consumer — it takes no arguments and returns a result.

ALICE CHARLIE

The stream first filters names with length > 3, keeping "Alice" (5) and "Charlie" (7) while removing "Bob" (3). Then map(String::toUpperCase) converts them to uppercase. Finally, forEach prints each element. The result is ALICE and CHARLIE on separate lines.

map() transforms each element to one element; flatMap() transforms each element to a stream and flattens the results

map() applies a one-to-one transformation: each input element produces exactly one output element. flatMap() applies a one-to-many transformation: each input element produces a stream of elements, and all resulting streams are flattened into a single stream. For example, if you have a List<List<String>>, flatMap() can flatten it into a Stream<String>.

15

The reduce() operation combines all elements of the stream into a single result. Starting with the identity value 0, it applies (a, b) -> a + b cumulatively: 0+1=1, 1+2=3, 3+3=6, 6+4=10, 10+5=15. The final result is 15.

Intermediate operations are lazy and return a new Stream; terminal operations trigger processing and produce a result or side-effect

Intermediate operations (filter, map, flatMap, sorted, distinct, peek) are lazy — they don't process elements until a terminal operation is invoked. They return a new Stream allowing chaining. Terminal operations (collect, forEach, reduce, count, findFirst, anyMatch) trigger the actual processing pipeline and produce a non-stream result. A stream can have many intermediate operations but only one terminal operation.

[1, 3, 5]

First, flatMap(Collection::stream) flattens the nested lists into a single stream: 1, 2, 3, 4, 5, 6. Then filter(n -> n % 2 != 0) keeps only odd numbers: 1, 3, 5. Finally, collect(Collectors.toList()) gathers them into a list. The result is [1, 3, 5].

Optional.ofNullable(value)

Optional.ofNullable(value) is the correct choice when the value might be null — it returns Optional.empty() for null and Optional.of(value) otherwise. Optional.of(value) throws NullPointerException if value is null. Optional has no public constructor, so new Optional() won't compile.

default

The Optional contains "Hello" (length 5). The filter checks if length > 10, which is false, so it returns Optional.empty(). The subsequent map() on an empty Optional does nothing. Finally, orElse("default") returns "default" since the Optional is empty.

All four (1, 2, 3, and 4)

Java 8 supports four kinds of method references: (1) Reference to a static method (ClassName::staticMethod), (2) Reference to an instance method of an arbitrary object of a particular type (ClassName::instanceMethod), (3) Reference to an instance method of a particular object (object::instanceMethod), and (4) Reference to a constructor (ClassName::new).

To provide backward-compatible evolution of interfaces by adding methods with a default implementation

Default methods allow interfaces to provide method implementations using the 'default' keyword. The primary motivation was to evolve existing interfaces (like java.util.Collection) with new methods (like stream(), forEach()) without breaking all implementing classes. Interfaces still cannot hold instance state.

The compiler throws an error unless the class overrides the method to resolve the conflict

When a class implements two interfaces with the same default method signature, there is a diamond problem. The compiler forces the class to override the conflicting method. Inside the override, you can explicitly call a specific interface's default using InterfaceName.super.methodName().

Groups employees into a Map where the key is the department and the value is a list of employees in that department

Collectors.groupingBy() is a collector that groups stream elements by a classification function and returns a Map. The key is the classification result (department name) and the value is a List of elements sharing that key. You can pass a downstream collector as a second argument, e.g., Collectors.groupingBy(Employee::getDepartment, Collectors.counting()) to get counts per department.

It returns an immutable list that throws UnsupportedOperationException on modification attempts

Collectors.toUnmodifiableList() (introduced in Java 10, building on Java 8 patterns) returns a list that cannot be modified — any call to add(), remove(), or set() throws UnsupportedOperationException. It also does not permit null elements. Collectors.toList() returns a regular mutable ArrayList with no such guarantees.

java.time.LocalDate

LocalDate represents a date without time-of-day and without timezone (e.g., 2026-04-04). LocalDateTime includes time but no timezone. ZonedDateTime includes both time and timezone. java.util.Date is the legacy class that Java 8's java.time API was designed to replace.

legacyDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime()

The bridge between legacy Date and Java 8's API is the Instant class. Date.toInstant() converts to an Instant, then atZone() attaches a timezone to get a ZonedDateTime, and toLocalDateTime() strips the timezone. Going the other way: Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant()).

They use the common ForkJoinPool, can introduce overhead for small datasets, and may cause issues with non-thread-safe operations or ordering-dependent logic

Parallel streams split work across multiple threads using the common ForkJoinPool. Risks include: (1) overhead from thread coordination can make small datasets slower, (2) shared mutable state can cause race conditions, (3) operations depending on encounter order may produce wrong results, (4) blocking operations can starve the shared pool affecting the entire application. Measure before parallelizing.

Using HashMap::new as the map factory with a parallel stream can cause race conditions; use Collectors.groupingByConcurrent() or a ConcurrentHashMap factory instead

When using parallelStream(), the regular groupingBy() collector with a HashMap factory is not thread-safe. The parallel stream processes elements concurrently, and merging into a HashMap can cause data corruption or lost entries. The safe alternatives are: (1) use Collectors.groupingByConcurrent() which uses a ConcurrentHashMap internally, or (2) use a ConcurrentHashMap::new factory. groupingByConcurrent() is also more efficient for parallel streams because it allows concurrent accumulation instead of merging separate maps.