Top 20 Java 8 Coding Interview Questions and Answers 2026

Here are the top Java 8 Interview questions with answers for freshers and experienced 2026:

1. Write a Java 8 program using a lambda expression to add two integers.

import java.util.function.BiFunction;

public class LambdaAddition {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(5, 3)); // Output: 8
    }
}

Explanation

BiFunction is a functional interface that takes two arguments and returns a result. The lambda (a, b) -> a + b is an implementation of its apply method. apply(5,3) runs the addition and outputs the sum. This is a simple example of a lambda being used for arithmetic ops.

Output

8

2. Write a Java 8 program to filter and print even numbers from a list.

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

public class FilterEvenNumbers {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        numbers.stream()
               .filter(n -> n % 2 == 0)
               .forEach(System.out::println); // Output: 2 4 6
    }
}

Explanation

The stream() creates a pipeline. filter() uses lambda to check evenness (mod 2 == 0), intermediate op. forEach() terminal op prints via method reference. Demonstrates filtering collections functionally.

Output

2 4 6

3. Write a Java 8 program to map integers to their squares and print results.

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

public class MapToSquares {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
        numbers.stream()
               .map(n -> n * n)
               .forEach(System.out::println); // Output: 1 4 9 16
    }
}

Explanation

The function map() transforms each element using lambda n -> n*n. Chains to forEach for output. Shows data transformation in streams.

Output 

1 4 9 16

4. Write a Java 8 program to find and print the maximum value from a list.

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

public class FindMaxValue {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int max = numbers.stream()
                         .max(Integer::compare)
                         .get();
                          System.out.println(max); // Output: 5
    }
}

Explanation

max() reduces the stream using a Comparator via a method reference. .get() extracts Optional value (assumes non-empty). Efficient for aggregates.

Output

5

5. Write a Java 8 program to count and print the number of elements in a list.

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

public class CountElements {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "pear");
        long count = words.stream().count();
        System.out.println(count); // Output: 3
    }
}

Explanation

count() is a terminal op returning stream size. Simple aggregation without lambda is needed.

Output 

3

6. Write a Java 8 program to reduce a list of integers to their sum.

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

public class ReduceToSum {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        int sum = numbers.stream().reduce(0, Integer::sum);
        System.out.println(sum); // Output: 6
    }
}

Explanation 

reduce() combines elements: identity 0, accumulator adds via method ref. Folds list into single value.

Output 

6

7. Write a Java 8 program to print the lengths of strings in a list.

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

public class PrintLengths {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("Java", "Python", "JavaScript");
        words.forEach(word -> System.out.println(word.length())); // Output: 4 6 10
    }
}

Explanation

forEach on list (not stream) uses lambda to compute and print length() for each. Basic iteration with lambda.

Output

4 6 10

8. Write a Java 8 program to print distinct elements from a list of integers.

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

public class DistinctElements {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4);
        numbers.stream()
               .distinct()
               .forEach(System.out::println); // Output: 1 2 3 4
    }
}

Explanation

The distinct() intermediate removes duplicates (uses hash set internally). Then print.

Output

1 2 3 4

9. Write a Java 8 program to print names sorted in alphabetical order from a list.

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

public class SortedOrder {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Charlie", "Alice", "Bob");
        names.stream()
             .sorted()
             .forEach(System.out::println); // Output: Alice Bob Charlie
    }
}

Explanation

This program creates a list of names, sorts them alphabetically using the sorted() method, and prints them using forEach().

Output

Alice Bob Charlie

₹ 49,000

₹ 33,000

/-

Karthik was able to transform his career from a boring job to an exciting job in software!

Talk to a career expert

10. Write a Java 8 program using Optional to check if a value is present.

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Java");
        name.ifPresent(System.out::println); // Output: Java
    }
}

Explanation

This program uses the Optional class to handle a possibly null value. If the value is present, it gets printed using ifPresent()

Output

Java

11. Write a Java 8 program to group strings by their lengths and print the groups.

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

public class GroupByLength {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("a", "bb", "ccc", "dd");
        Map<Integer, List<String>> grouped = words.stream()
                                                  .collect(Collectors.groupingBy(String::length));
        System.out.println(grouped); // Output: {1=[a], 2=[bb, dd], 3=[ccc]}
    }
}

Explanation

This program groups strings by their lengths using Collectors.groupingBy() and prints the resulting map.

Output

{1=[a], 2=[bb, dd], 3=[ccc]}

12. Write a Java 8 program to collect squares of numbers into a new list.

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

public class CollectToList {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        List<Integer> squares = numbers.stream()
                                        .map(n -> n * n)
                                        .collect(Collectors.toList());
        System.out.println(squares); // Output: [1, 4, 9]
    }
}

Explanation

This program squares each number in the list using map() and collects the results into a new list with Collectors.toList().

Output

[1, 4, 9]

13. Write a Java 8 program to limit and skip elements in a list, then print.

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

public class LimitAndSkip {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        numbers.stream()
               .limit(3)
               .forEach(System.out::println); // Output: 1 2 3
    }
}

Explanation

This program uses limit() to restrict the number of elements processed in the stream to the first 3 and prints them.

Output

1 2 3

14. Write a Java 8 program to find and print the first element in sorted order.

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

public class FindFirst {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
        int first = numbers.stream()
                           .sorted()
                           .findFirst()
                           .get();
        System.out.println(first); // Output: 1
    }
}

Explanation

This program sorts the list and then uses findFirst() to get and print the first element.

Output

1

15. Write a Java 8 program to create a custom functional interface for addition.

@FunctionalInterface
interface MyFunction {
    int apply(int a, int b);
}

public class CustomFunctionalInterface {
    public static void main(String[] args) {
        MyFunction add = (a, b) -> a + b;
        System.out.println(add.apply(10, 20)); // Output: 30
    }
}

Explanation

This program defines a custom functional interface MyFunction and uses a lambda expression to implement the apply() method for adding two numbers.

Output

30

16. Write a Java 8 program using flatMap to print characters from lists of strings.

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

public class FlatMapExample {
    public static void main(String[] args) {
        List<List<String>> list = Arrays.asList(
                Arrays.asList("A", "B"),
                Arrays.asList("C", "D"));
        list.stream()
            .flatMap(List::stream)
            .forEach(System.out::println); // Output: A B C D
    }
}

Explanation

This program uses flatMap() to flatten a list of lists into a single stream and prints each element.

Output

A B C D

17. Write a Java 8 program using peek to print processed elements during a stream operation.

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

public class PeekExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
        numbers.stream()
               .peek(n -> System.out.println("Processing: " + n))
               .map(n -> n * n)
               .forEach(System.out::println); // Output: Processing: 1, Processing: 2, ...
    }
}

Explanation

The peek() method lets you observe elements as the stream processes them. Here, it prints each element before it's squared. This is typically used for debugging.

Output

Processing: 1
Processing: 2
Processing: 3
Processing: 4
1
4
9
16

18. Write a Java 8 program to create and print result from a CompletableFuture asynchronously.

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 1 + 2);
        future.thenAccept(System.out::println); // Output: 3
    }
}

Explanation

This program uses CompletableFuture.supplyAsync() to compute 1 + 2 asynchronously, then prints the result with thenAccept().

Output

3

19. Write a Java 8 program using reduce to calculate the product of a list.

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

public class CustomReduce {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
        int prod = numbers.stream().reduce(1, (a, b) -> a * b);
        System.out.println(prod); // Output: 24
    }
}

Explanation

The reduce() method is used to perform a reduction operation. In this case, it multiplies all the elements in the list to calculate the product. The starting value is 1.

Output

24

20. Write a Java 8 program to check if any number in a list is even.

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

public class AnyMatchExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        boolean haseven = numbers.stream().anyMatch(n -> n % 2 == 0);
        System.out.println(haseven); // Output: true
    }
}

Explanation

The anyMatch() method checks if any element in the list satisfies the given condition (in this case, being even). It returns true if at least one element matches the condition. 

Output

true

Key Topics to Practice: Java Streams Interview Questions

Among the questions covered above, many are Java Streams interview questions that test your understanding of the Stream API and functional programming concepts. In technical interviews, recruiters frequently ask Stream API interview questions on operations such as filter(), map(), reduce(), collect(), sorted(), distinct(), flatMap(), and anyMatch(). Regular practice with these streams interview questions will help you write cleaner, more efficient code and confidently solve collection-processing problems during Java interviews.

Modern Java 8 interviews often include scenario-based questions that test your ability to apply core concepts to real-world problems. Below are some sample scenarios and coding challenges using terms such as Arrays.asList, Collectors, List<String>, map, toList, toUpperCase, charAt, and isPalindrome. Practicing these Java interview questions will help you demonstrate both your technical skills and problem-solving abilities in the IT sector.

Scenario 1: Filtering and Manipulating Lists

Suppose you are given a list of strings and need to filter out those that start with the letter 'A', then convert the remaining strings to uppercase.

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

public class ScenarioFilterAndUppercase {
    public static void main(String[] args) {
        // List of words to process
        List<String> words = Arrays.asList("Apple", "Banana", "Apricot", "Orange");
        
        // Stream processing: Filter words not starting with 'A' and convert to uppercase
        List<String> result = words.stream()
            .filter(s -> !s.startsWith("A")) 
            .map(String::toUpperCase)          // Convert remaining words to uppercase
            .collect(Collectors.toList());     // Collect the result into a list
        
        // Output the result
        System.out.println(result); 
    }
}

Explanation

This program filters out words starting with the letter 'A' and converts the remaining words to uppercase. It uses filter() to exclude words beginning with 'A', then map() to transform the remaining words to uppercase. Finally, collect() gathers the results into a list.

Output

[BANANA, ORANGE]

Scenario 2: Checking for Palindromes

A common coding interview question is to check if a given string is a palindrome using Java 8 features, such as IntStream and charAt.

import java.util.stream.IntStream;

public class PalindromeCheck {
    public static void main(String[] args) {
        String input = "madam";
        
        // Check if the string is a palindrome
        boolean isPalindrome = IntStream.range(0, input.length() / 2)
            .allMatch(i -> input.charAt(i) == input.charAt(input.length() - i - 1));

        // Output the result
        System.out.println(isPalindrome); 
    }
}

Explanation

The program aims to verify if a given string is a palindrome or not, meaning the string reads the same way from left to right and from right to left. To perform the iteration over the first half of the string, the program uses IntStream.range(), and with the help of allMatch(), it checks whether the characters from both ends of the string are identical.

Output

true

Scenario 3: Counting Character Occurrences

Given a string, count the number of occurrences of each character using Java 8 streams and collectors.

import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class CharCount {
    public static void main(String[] args) {
        String input = "interview";
        
        // Using stream to count character occurrences
        Map<Character, Long> charCount = input.chars()
            .mapToObj(c -> (char) c)  // Convert int values to characters
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));  // Group by character and count
        
        // Print the result
        System.out.println(charCount);  
    }
}

Explanation

This program counts the occurrences of each character in a given string. It converts the string into an IntStream of character codes with chars(), then maps these codes to Character objects. Using collect() with groupingBy() and counting(), it creates a map of character frequencies.

Output

{i=2, n=1, t=1, e=2, r=1, v=1, w=1}

Such situational questions are typical of the difficulties that you might encounter in a Java 8 interview, particularly in the technology field. Working through these issues will enable you to take on actual coding tasks with confidence and demonstrate your skill with Java 8 features.

MCQs serve as an efficient way to assess your understanding of key Java 8 concepts. By answering these questions, developers can evaluate their proficiency with new features commonly used in real-world coding scenarios. Below are some of the critical Java 8 features that are often tested in coding questions for experienced developers:

1. Lambda Expressions: These expressions are among the most popular Java 8 features, providing a clear and concise way to implement functional interfaces. Understanding how to implement and apply lambda expressions is vital for developers working with Java 8.‍

‍‍Example MCQ:

1. What is the primary advantage of using lambda expressions in Java 8?
   
   • A) Improved memory management
   • B) Reduced lines of code
   • C) Enhanced thread synchronization
   • D) Increased performance during compilation
2. Optional Class: The Optional class was introduced to avoid NullPointerExceptions and to handle null values more expressively and safely. It is a container object that may or may not contain a non-null value. Mastery of Optional is essential for any Java developer aiming for cleaner and more reliable code.‍

Example MCQ:

• Which of the following methods is used to check if a value is present in an Optional object in Java 8?
  
  • A) isPresent()
  • B) isNull()
  • C) check()
  • D) exists()

3. Stream API: The Stream API is another revolutionary feature introduced in Java 8 that enables functional-style operations on sequences of elements, such as collections. It allows developers to perform operations like filtering, mapping, and reducing in a more declarative way.

Example MCQ:

• Which of the following is an example of a terminal operation in the Stream API?
  
  • A) map()
  • B) filter()
  • C) collect()
  • D) forEach()

4. Scenario-Based Questions: Scenario-based MCQs test how well you can apply Java 8 concepts in real-life situations. These questions assess your problem-solving abilities and your understanding of how to use Java 8 features in practical applications.

Example Scenario-Based MCQ:

• You have a list of employee objects, and you want to find the names of all employees who earn more than $50,000. How would you implement this using Java 8’s Stream API?
  
  • A) Use a for loop to filter and print the names.
  • B) Use Stream.filter() to filter the employees and then map() to extract the names.
  • C) Use Optional to find the names.
  • D) Use Stream.forEach() to directly print the names.

Advanced Java 8 Concepts in MCQs

In addition to fundamental features, MCQs also assess your ability to understand and work with advanced Java 8 features. These features include method references, default methods in interfaces, and more.

1. Method References – Simplify the usage of lambda expressions when invoking methods.

Example MCQ:

• Which of the following is the correct way to use a method reference in Java 8?
  
  • A) list.forEach(x -> System.out.println(x))
  • B) list.forEach(System.out::println)
  • C) list.forEach(x => System.out.println(x))
  • D) list.forEach((x) -> System.out.println(x))

2. Default Methods in Interfaces – Introduced to allow adding new methods to interfaces without breaking existing implementations.

Example MCQ:

• What is the purpose of the default keyword in Java 8 interfaces?
  
  • A) To create an abstract method
  • B) To implement a method in the interface
  • C) To allow multiple inheritance of methods
  • D) To provide a default implementation for an interface method

In conclusion, when preparing for Java 8 coding interviews, it’s crucial to focus on a wide range of topics. Practice questions often involve writing code to manipulate collections using the Stream API. Solving Java 8 programming questions will sharpen your problem-solving skills and reinforce your understanding of modern Java features. Overall, consistent practice with Java 8 coding questions will help you excel in technical interviews. Along with mastering lambda expressions and the Optional class, regularly practicing Java Streams API interview questions will strengthen your understanding of functional programming and help you solve real-world coding problems more efficiently. Consistent practice with these streams interview questions can significantly improve your performance in Java 8 technical interviews. 

Why It Matters?

Java 8 skills are essential for building applications with frameworks such as Spring Boot and big-data tools like Apache Spark. Mastering Java 8 features demonstrates your understanding of functional programming, improves code readability, and helps you write more maintainable applications. Consistent practice with Java Coding Interview Questions prepares you to solve real-world coding challenges confidently during technical interviews.

Practical Advice for Learners

• Practice 5–10 Java Coding Interview Questions every day on platforms like LeetCode and HackerRank.
• Strengthen your fundamentals by reviewing Java programming interview questions and answers to understand different approaches and best practices.
• Debug Stream API operations step by step using peek() to understand data flow.
• Build small projects, such as a stream-based log analyzer, to apply Java 8 concepts in real-world scenarios.
• Practice explaining your solutions during mock interviews to improve your communication and problem-solving skills.

₹ 49,000

₹ 33,000

/-

Karthik was able to transform his career from a boring job to an exciting job in software!

Talk to a career expert

1. What are some common Java 8 coding questions for experienced professionals?

Common questions include those related to Stream API, lambda expressions, and functional programming concepts. They may also involve practical coding challenges to test problem-solving skills.

2. How can I practice Java 8 coding problems?

You can practice by solving problems on coding platforms like LeetCode, and HackerRank, or by working on personal projects that include Java 8 features.

3. What is the importance of the Stream API in Java 8?

The Stream API significantly simplifies data manipulation and enhances performance through parallel processing and functional programming techniques.

4. Are there any resources for Java 8 programming interview questions?

Yes, many online platforms, books, and coding challenge websites offer extensive resources on Java 8 interview questions and coding exercises.

5. Are Java Streams interview questions asked in every Java interview?

Yes. Java Streams interview questions are commonly asked in Java 8 and Spring Boot interviews because they evaluate your understanding of functional programming, collection processing, lambda expressions, and the Stream API. Freshers are usually asked basic stream operations, while experienced developers may face advanced Stream API interview questions involving collectors, parallel streams, and performance optimization.

6. What are the most common Java 8 interview coding questions?

The most common Java 8 interview coding questions cover lambda expressions, the Stream API, Optional, functional interfaces, collections, multithreading, and scenario-based coding problems. Practicing these topics helps candidates prepare for both fresher and experienced Java developer interviews.