Java 8 introduced powerful features like Lambda Expressions, Streams, and Functional Interfaces—but are you truly ready to answer real interview questions?
This guide covers the most frequently asked Java 8 interview questions with clear explanations and practical examples to help you crack your next interview with confidence.

Program1 : Write a program that, given a list of integers, extracts and returns only the even numbers from the input collection.

package com.rkdigitalschool.msil.java8;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class EvenNumber {
	public static void main(String[] args) {
		List<Integer> list=Arrays.asList(12,13,14,15,16,17,19,21,23,25,26,27,29,30,32,34,36,42);
		List<Integer> res=list.stream().filter(num -> num%2 ==0).collect(Collectors.toList());
		res.forEach(System.out::println);
	}
}

Program2 : Write a program to Find the maximum number of given list using java8

package com.rkdigitalschool.msil.java8;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class MaximumNumber {
	public static void main(String[] args) {
		List<Integer> list=Arrays.asList(33,56,78,33,58,22,232,456,555,666,686,999);
		Optional<Integer> max=list.stream().max(Integer::compare);
		if(max.isPresent()) {
			int value=max.get();
			System.out.println(value);
		}
	}
}

Program3: Write a program to Find duplicate elements in a list

package com.rkdigitalschool.msil.java8;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class DuplicateElements {
	public static void main(String[] args) {
		List<Integer> list=Arrays.asList(22,34,33,36,22,33,76,88,99,87,57,98,55,45,98);
		List<Integer> res =list.stream()
				.filter(num -> Collections.frequency(list, num)>1)
				.distinct()
				.collect(Collectors.toList());
		res.forEach(System.out::println);		
	}
}

What is Collections.frequency()?.

It counts how many times an element (o) appears in a collection (c).frequency() is a utility method from the Java Collections Framework. Internally it perform below three steps .

• Iterates through the entire collection.
• Compares each element with the given object using .equals().
• Increments a counter when matched.

Program4: Write a program to  Count occurrences of each word in java8

package com.test.rkdigital.java8;

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

public class OccuranceWord {
	public static void main(String[] args) {
		String text = "Java 8 streams are powerful. Java streams are great!";
		Map<String, Long> freq = Arrays.stream(text.toLowerCase().split("\\W+"))
				.filter(s -> !s.isEmpty())
				.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
		
		for (Map.Entry<String, Long> entry : freq.entrySet()) {
		    System.out.println(entry.getKey() + " -> " + entry.getValue());
		}
	}

}

program5: Write a program to Remove all null values from a list

package com.test.rkdigital.java8;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
public class RemoveNull {
	public static void main(String[] args) {
		String text = "Java 8 streams are powerful. Java streams are great!";
		List<String> list=Arrays.stream(text.toLowerCase()
				.split("\\W+"))
				.filter(Objects::nonNull)
				.collect(Collectors.toList());
		System.out.println(list);
	}
}

Program6 : Write a program to Convert list of strings to uppercase

package com.test.rkdigital.java8;

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

public class ConvertUpperCase {

	public static void main(String[] args) {
		String text = "Java 8 streams are powerful. Java streams are great!";
		List<String> upper=Arrays.stream(text.toLowerCase().split("\\W+"))
		.map(String::toUpperCase).collect(Collectors.toList());
		System.out.println(upper);
	}
}

Program7: Write a program to sort a list of Integer Order

import java.util.*;
import java.util.stream.Collectors;

public class SortListDescending {
    public static void main(String[] args) {
        // Sample input list
        List<Integer> list = Arrays.asList(50,30,10, 5, 20, 15, 8);
        // Sorting in descending order using Java 8 Stream
        List<Integer> sorted = list.stream()
                                   .sorted(Comparator.reverseOrder())
                                   .collect(Collectors.toList());

        System.out.println("Original List: " + list);
        System.out.println("Sorted List: " + sorted);
    }
}

output

Original List: [50,30,10, 5, 20, 15, 8]
Sorted List (Descending): [50,30,20, 15, 10, 8, 5]

Program8: Write a Java program to find the first non-repeating character in a string using java8 stream

package com.test.rkdigital.java8;
public class FirstNonrepetedCharacter 
{
	public static void main(String[] args) {
		// Input string
        String str = "Javak8streamsarepowerfulJavastreamsaregreat!";

        // Finding first non-repeating character
        Character ch = str.chars()
                .mapToObj(c -> (char) c)
                .filter(c -> str.indexOf(c) == str.lastIndexOf(c))
                .findFirst()
                .orElse(null);

        // Output result
        if (ch != null) {
            System.out.println("First non-repeating character: " + ch);
        } else {
            System.out.println("No non-repeating character found.");
        }
	}

}

mapToObj()

mapToObj() is a method in Java Streams API used to convert a primitive stream (like IntStream, LongStream, DoubleStream) into a Stream of objects.

In Java Streams, there are two types of streams:

• Primitive Streams → IntStream, LongStream, DoubleStream
• Object Streams → Stream<T>

mapToObj() helps convert primitive values into objects.

Example 1: Convert int to String

IntStream numbers = IntStream.of(1, 2, 3, 4);
Stream<String> result = numbers.mapToObj(n -> "Number: " + n);
result.forEach(System.out::println);

Program 9: Write a program to find first repeated character

public class Repetedcharacter {
    public static void main(String[] args) {

        String str = "Javak8streamsarepowerfulJavastreamsaregreat";

        Character result = str.chars()
                .mapToObj(c -> (char) c)
                .filter(c -> str.indexOf(c) != str.lastIndexOf(c))
                .findFirst()
                .orElse(null);

        if (result != null) {
            System.out.println("First repeating character: " + result);
        } else {
            System.out.println("No repeating character found");
        }
    }
}

Program10 : Write a program to reverse each words in given sentence .

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

public class Reverseword{
    public static void main(String[] args) {
        String sentence = "Java streams are powerful and great";
        String res = Arrays.stream(sentence.split(" "))
                .map(s -> new StringBuilder(s).reverse().toString())
                .collect(Collectors.joining(" "));

        System.out.println("Original Sentence: " + sentence);
        System.out.println("Reversed Words Sentence: " + res);
    }
}