30+ Must-Know Java 8 Interview Questions for 2023 - IQCode

Overview of Java 8 and its features

Java, first created in 1996, was developed by Sir James Gosling at Sun Microsystems and is an open-source project now maintained by Oracle. One of its major releases was Java 8, also known by the codename Spider, in 2014. This article will provide Java 8 interview questions for both freshers and experienced individuals, as well as information on the language's scope and opportunities.

Java 8 Interview Questions for Freshers

1. Can you describe the newly added features in Java 8?

Programming Paradigm of Java 8

Java 8 falls under the Object-Oriented Programming (OOP) paradigm.

Significant Advantages of Java 8

Java 8 has several significant advantages that make it one of the most popular programming languages today. One of the most important features is the introduction of lambda expressions, which makes it easier and faster to write code. Java 8 also introduces the Stream API, which allows developers to more easily work with collections of data.

Another key advantage of Java 8 is its improved performance, particularly in terms of memory management. Additionally, Java 8 includes a new date and time API, making it easier to work with dates and times in Java programs.

Overall, the new features and improvements in Java 8 have made it a more efficient and powerful programming language, leading to increased productivity for developers.

What is Metaspace and How Does it Differ from PermGen?

Metaspace is a memory area used by Java to store metadata about classes and methods. It was introduced in Java 8 to replace PermGen, which was used in earlier versions of Java.

There are a few key differences between Metaspace and PermGen. Firstly, PermGen had a fixed size, while Metaspace can automatically resize itself based on the application's demand for memory. This helps prevent common PermGen errors, such as OutOfMemoryError.

Secondly, Metaspace is garbage-collected like any other memory area in Java, while PermGen was not. This means that unused class metadata can be automatically cleared out of memory, improving overall performance and reducing the risk of memory leaks.

Overall, Metaspace is a more efficient and flexible solution for storing metadata in Java applications compared to PermGen.

Functional or SAM Interfaces

A functional interface (FI) is an interface that has exactly one abstract method within it. It is also known as a Single Abstract Method (SAM) interface. Typically, functional interfaces are used with lambda expressions and method references to implement functional programming in Java. SAM interfaces are also considered as functional interfaces.

// Example of functional interface
public interface Calculator {
    double calculate(int a, int b);

In this example, the Calculator interface is a functional interface with a single abstract method - calculate. It can be implemented using lambda or method reference as shown below:

Calculator calc = (a, b) -> a + b; // using lambda expression
Calculator calc = Integer::sum; // using method reference

Can a Functional Interface Extend/Inherit Another Interface?

In Java, a functional interface is an interface that contains only one abstract method. Java 8 introduced functional interfaces to support lambda expressions, method references, and streams.

Yes, a functional interface can extend another interface, provided the extended interface has only one abstract method or is also a functional interface. However, one cannot extend a non-functional interface with a functional interface, as the non-functional interface would require the implementation of all its methods except default and static methods.

Here's an example of extending a functional interface with another functional interface:

interface ExampleOne {
    void doSomething();

interface ExampleTwo extends ExampleOne {
    void doSomethingElse();

In this example, the ExampleTwo interface is a functional interface that extends the ExampleOne interface, which is also a functional interface. The ExampleTwo interface has two abstract methods, doSomething and doSomethingElse.

It is important to note that adding a default method to a functional interface still preserves its functional nature. However, adding a second abstract method to a functional interface will result in a compilation error.

What is the default method and why is it necessary?

The default method is a method in an interface that is used to provide a default implementation for a specific method. It is required to provide default functionality for an interface method so that if a class does not implement that method, it can still be executed without causing runtime errors. This is particularly useful when adding new methods to an existing interface, as it allows for backward compatibility with code that was written before the new method was introduced.

Static Methods in Interfaces

Static methods in interfaces are methods that can be called directly on the interface itself, rather than on an instance of a class that implements the interface. They are defined using the "static" keyword in the method signature.

One use case for static methods in interfaces is to provide utility methods that are common to all classes that implement the interface. By defining these methods as static, they can be called without creating an instance of the implementing class.

Here is an example of a static method in an interface:

public interface MyInterface {
    static void myStaticMethod() {
        System.out.println("This is a static method in an interface.");

This method can be called like this:


Note that static methods in interfaces cannot be overridden by implementing classes. They can be "hidden" by a static method with the same signature in a subclass, but they cannot be overridden in the traditional sense.

Standard Pre-defined Functional Interfaces in Java

Java provides several pre-defined functional interfaces. Some of the commonly used standard Java pre-defined functional interfaces are:



- it accepts one input parameter of type T, but does not return any result. 2.


- it does not accept any input, but produces a result of type T. 3.

Function<T, R>

- it accepts one input parameter of type T and returns a result of type R. 4.


- it accepts one input parameter of type T and returns a boolean value.

Using these functional interfaces, we can do a lot of things in Java, including iterating over lists, filtering data, and mapping data from one form to another.

Categories of Pre-defined Function Interfaces

In programming, there are several pre-defined function interfaces that can be categorized into various groups. Some of these categories include:

1. Mathematical Functions: These are functions that can perform mathematical calculations like solving equations, finding the absolute value of a number, etc. Examples of these functions include math.sqrt(), math.sin(), etc.

2. String Functions: These functions operate on strings, and they can perform operations like concatenation, searching for a substring, comparing strings, and so on. Examples include string.replace(), string.strip(), etc.

3. File I/O Functions: These permit you to manipulate files and directories, read from files, and write to files. Some examples of these functions include open(), read(), write(), close(), copy(), remove() to name a few.

4. Date and Time Functions: These are used for working with dates and time formats. Examples of these functions include datetime.now(), timedelta(), time.sleep(), etc.

5. Data Structure Functions: These are functions that manipulate data in various structures like lists, dictionaries, sets, tuples, and so on. Examples of these functions include list.append(), dict.get(), set.add(), tuple.index(), etc.

In conclusion, there are various categories of pre-defined function interfaces, which each has its specific use in programming. Understanding these interfaces is fundamental to enhance your programming skills, and it can make your code more efficient and reliable.

Explanation of Lambda Expression and its Relation to Functional Interface in Java

In Java, a lambda expression is an anonymous (unnamed) function that enables passing functionality as if it were data. It allows implementing functional programming concepts in Java. A lambda expression can be used to implement the abstract methods of functional interfaces, which are interfaces that have only one abstract method.

A lambda expression is defined using the syntax`(parameters) -> {body}`, where parameters are the input arguments of the function, and the body contains the code to be executed.

For example, consider the following functional interface `Calculator`:

interface Calculator {
    int calculate(int x, int y);

This interface contains only one abstract method called `calculate`. We can use a lambda expression to implement this interface as follows:

Calculator add = (x, y) -> x + y;

Here, we created a lambda expression to implement the `calculate` method of the `Calculator` interface. The lambda expression takes two integer parameters `x` and `y`, and returns their sum.

Lambda expressions make it easy to implement functional interfaces and provide a simpler and more concise way of writing code. They enable us to write more flexible and reusable code by passing functionality as data.

Java 8 Interview Questions for Experienced: Lambda Expressions

In Java 8, a Lambda expression is a shorthand syntax that allows us to declare and pass a small block of code (method) to a method as a parameter. A basic structure/syntax of a lambda expression consists of the following:

(parameter list) -> { // body of the function }

For example, the following lambda expression calculates the square of an integer number:

x -> x * x

Here, "x" is the parameter, and "x * x" is the body of the function.

Features of a Lambda Expression

A lambda expression is a way of defining an anonymous function, which means that it does not have a name. It can be seen as a shortcut for defining small, simple functions that can be passed as arguments to other functions. The features of a lambda expression in Java are as follows:

- Concise syntax: A lambda expression has a short and concise syntax, which makes it easy to read and write.

- Functional interface: It is used with a functional interface, which is an interface that has only one abstract method. The lambda function must be compatible with this method.

- Interchangeability: A lambda expression can be used wherever a functional interface is expected, which means that it can be passed as an argument to a method or assigned to a variable.

- No state: A lambda expression does not have any state, which means that it cannot change the values of variables outside of its scope.

- No return type: A lambda expression does not have a return type specified, as it is automatically inferred by the compiler.

- Optional parentheses: If the lambda expression has only one parameter, the parentheses around the parameter list can be omitted.

- Optional braces: If the lambda function body contains only one expression, the braces can be omitted.

What is a Type Interface?

Type Interface is a feature of programming languages that allows for automatic detection of the data type of a variable based on the value assigned to it. This eliminates the need for explicitly declaring variable types, making code more flexible and concise. The use of type inference can improve the readability, maintainability, and performance of code.

Types and Common Uses of Lambda Expressions

Lambda expressions are anonymous functions in Java that allow you to pass code as data. They're typically used with functional interfaces, which are interfaces with a single abstract method. Some common uses of lambda expressions include:

1. Filtering data: Lambdas can be used to filter data by defining a criteria that elements must meet in order to be included in a collection.

2. Sorting data: Lambdas can be used to sort data based on a specific criteria.

3. Event handling: Lambdas can be used to define event handlers for GUI components or other events.

4. Mapping data: Lambdas can be used to transform input data into output data.

5. Parallel processing: Lambdas can be used in parallel programming to execute code on multiple threads.

There are two types of lambda expressions in Java:

1. Non-capturing lambdas: These are lambdas that do not reference any variables from their enclosing scope.

2. Capturing lambdas: These are lambdas that reference variables from their enclosing scope.

Lambda expressions are a concise way to pass behavior as an argument to a method. They can help reduce code verbosity and improve readability in certain situations. Code:

Method Reference in Java 8

Method reference is a feature introduced in Java 8 that allows us to pass a method to a higher-order function or lambda expression. The syntax for method reference is "::". It simplifies lambda expressions by referring to an existing method by its name instead of providing a lambda expression to call that method. It can be used with four different types of methods: static, instance, constructor, and array. The use of method reference results in cleaner, more concise code that is easier to read and understand.

Meaning of the expression String::valueOf

The expression "String::valueOf" is a shorthand notation used in Java to create a new instance of a String object from a given input value of any data type. It is known as a method reference, which is a feature introduced in Java 8.

The syntax of this expression is as follows:


Here, "inputValue" can be any primitive or object type, and the resulting String object will contain the textual representation of that value.

For example, to create a String object containing the text "123", you can use the following code:

int num = 123; String str = String.valueOf(num);

In this case, the integer value "123" is used as the input value to the String::valueOf method, which returns a new string "123".

What is an Optional Class?

An optional class is a class in which its instances can have either a value or no value at all. When defining a variable of an optional class, it can be set to either contain a value of the class or to be empty. Optional classes are commonly used in Swift and other programming languages.

Advantages of Using the Optional Class

The Optional class in Java has several advantages, including:

1. It helps to prevent NullPointerExceptions that occur when a null value is assigned to a variable. 2. It improves code readability by making it clear where null values are allowed. 3. It allows for safer and more streamlined coding patterns by enabling developers to focus on business logic rather than null checks. 4. It works well with functional programming constructs in Java 8, such as lambda expressions and streams.

Overall, the Optional class helps to create more robust and maintainable code by providing a cleaner approach to dealing with null values.

Understanding Java 8 Streams

In Java 8, Streams are a new addition to the Collections framework. They are designed to provide a concise and functional way of processing and manipulating collections of objects.

A stream is a sequence of elements that can be processed in parallel or sequentially. It does not store data and does not alter the original data source. Instead, it provides a way to perform aggregate operations like filtering, mapping, and reducing on the collection of elements.

Streams can be obtained from various sources such as collections, arrays, and even I/O channels. Once you have a stream, you can use the various available terminal operations like forEach, toArray, min, max, count, and reduce, to perform the required operations on the elements.

In summary, Java 8 Streams provide a powerful and concise way of processing collections of data. They are especially useful when dealing with large datasets, where traditional looping constructs may not be efficient or optimal.

Main Components of a Stream

In computer science, a stream is a sequence of data elements made available over time. The main components of a stream are:

  • Source: The origin of the data within the stream.
  • Destination: The endpoint of the data within the stream.
  • Buffer: The temporary storage area where data is held before it is processed.
  • Flow: The movement of the data from the source to the destination.

Streams are commonly used in programming to handle large amounts of data. By breaking down the data into smaller pieces and processing it over time, streams can make it easier to work with and manipulate the information.

Sources of Data Objects for Stream Processing

In stream processing, there are several sources of data objects which can be processed. These include:

1. Sensors: Data from sensors like temperature, pressure, accelerometer, etc. 2. Social media feeds: Data from social media platforms like Twitter, Facebook, Instagram, etc. 3. Stock market feeds: Data from stock market exchanges. 4. IoT devices: Data from IoT devices connected to a network. 5. Web server logs: Data from web servers that can be used to study user behavior. 6. Databases: Data from databases like MySQL, MongoDB, etc. 7. File systems: Data from files stored in file systems.


sources_of_data = ['Sensors', 'Social media feeds', 'Stock market feeds', 'IoT devices', 'Web server logs', 'Databases', 'File systems']

In stream processing, these sources can be used to gather and analyze data in real-time to make informed decisions.

Intermediate and Terminal Operations in Java Streams

In Java Streams, intermediate operations are operations that are performed on a stream before a terminal operation is executed. These operations return a new stream, which can be used for further operations. Examples of intermediate operations are filter(), map(), and distinct().

On the other hand, terminal operations are operations that are performed on a stream to produce a result. Once a terminal operation is executed, it marks the end of the stream and cannot be reused. Examples of terminal operations are reduce(), collect(), and forEach().

It is important to note that intermediate operations are not executed until a terminal operation is invoked. This means that intermediate operations are lazy and can be optimized for performance. It is also possible to chain multiple intermediate operations before a terminal operation to perform complex data transformations.

Understanding the differences between intermediate and terminal operations is crucial in effectively using Java Streams to process and manipulate data.

Most Commonly Used Intermediate Operations

In Java 8, the most commonly used intermediate operations in streams include:

  • filter(Predicate<T> predicate)

    : Filters the elements of the stream by the given predicate.

  • map(Function<T, R> mapper)

    : Applies the given function to convert each element of the stream into another type.

  • flatMap(Function<T, Stream<R>> mapper)

    : Applies the given function to convert each element of the stream into a stream of another type, then flattens that stream into the main stream.

  • distinct()

    : Returns a stream containing only distinct elements.

  • sorted()

    : Returns a stream sorted in natural order.

  • peek(Consumer<T> action)

    : Allows you to inspect every element of the stream as they pass through, without changing the content of the stream.

These intermediate operations are used to manipulate and transform the stream data before terminating the stream with a terminal operation.

Stateful Intermediate Operations in Java Stream

Stateful intermediate operations are operations in Java Stream that perform stateful computations. These operations may incorporate information from previous elements or computations into the next intermediate operation. Examples of stateful intermediate operations in Java Stream include:

  • distinct()
  • sorted()
  • limit()
  • skip()
  • peek()

Stateful intermediate operations differ from stateless intermediate operations in that they may modify or use the state of the stream. This added complexity can have implications on the performance of the stream in certain circumstances. Therefore, it is important to use stateful intermediate operations only when necessary and to understand their impact on the stream's performance.

Most Common Types of Terminal Operations

In terminal operations, the most commonly used type is the "cd" command which is used to change the current working directory. Other common types of terminal operations include "ls" for listing the contents of a directory, "mkdir" for creating a new directory, "rm" for deleting files and directories, "mv" for moving files and directories, and "cp" for copying files and directories. These commands are used to navigate and manipulate the file system through the terminal.

Difference Between FindFirst() and FindAny() in Java

In Java, both FindFirst() and FindAny() are methods of the Stream interface that return an Optional object. However, there is a subtle difference between them:

1. FindFirst() returns the first element of the stream, or an empty Optional if the stream is empty.

2. FindAny() returns any element of the stream, or an empty Optional if the stream is empty.

The main difference is in parallel processing. When working with parallel streams, FindFirst() may not always return the actual first element, since the order of the elements in a parallel stream is not guaranteed. In such cases, FindAny() would be a better choice as it returns any element from the stream.

Differences Between Collections and Streams

In Java, collections are in-memory structures that store a group of objects, while streams are used to process and perform operations on a sequence of elements.

A collection is used when the group of elements needs to be stored or manipulated, while streams are used when a sequence of elements requires processing.

Collections are mutable, meaning the elements can be changed after they are added to the collection, whereas streams are immutable, meaning they cannot be modified once created.

Collections provide random access to elements using an index, while streams cannot access elements randomly and can only be accessed sequentially.

Streams are more efficient when dealing with large datasets since they don't store the data in memory but rather process it on the fly as it is being streamed. On the other hand, collections work well when the data can fit comfortably in memory without issues.

Features of the new Date and Time API in Java 8

Java 8 introduces a new Date and Time API, which has several features including:

1. Introduces a new set of date and time classes that are thread-safe and immutable.

2. Provides a clear and consistent way to parse and format dates and times.

3. Introduces the concept of date and time periods, making it easy to perform operations such as adding or subtracting days, months, or years.

4. Offers a wide range of built-in date and time manipulation methods, such as finding the difference between two dates and times.

5. Provides better support for time zones, allowing developers to easily perform time zone conversions.

6. Supports the ISO-8601 standard for representing dates and times, which makes it easier to communicate date and time values with other systems.

Overall, the new Date and Time API in Java 8 is a significant improvement over the previous API, and makes working with dates and times in Java much easier and more intuitive.

Important Packages in the New Date and Time API

The Java 8 version introduced a new Date and Time API that provides several new classes to replace the outdated Date and Calendar classes. Some of the important packages in this API are:

- java.time: Contains classes like LocalDate, LocalTime, LocalDateTime, ZonedDateTime, and many more for representing date and time values.

- java.time.format: Contains classes for formatting and parsing date and time objects, including DateTimeFormatter.

- java.time.temporal: Contains classes for manipulating and calculating date and time values, including TemporalAdjusters.

- java.time.zone: Contains classes for working with time zones, including ZoneId and ZoneOffset.

By using these packages, Java developers can handle date and time more effectively and avoid the pitfalls of the old API.

Explanation of LocalDate, LocalTime, and LocalDateTime APIs with Examples

The LocalDate, LocalTime, and LocalDateTime are part of the Java 8 Date Time API. These APIs provide a simple way to work with date and time values.

LocalDate: LocalDate represents a date in a specific timezone. It has various method to perform operations on a date. Some of the methods are:

LocalDate currentDate = LocalDate.now();   // returns the current date in system default timezone
LocalDate date1 = LocalDate.of(2021, 8, 1);  // creates a LocalDate object of 1st August 2021
LocalDate date2 = LocalDate.parse("2021-08-05");  // creates a LocalDate object by parsing a string

LocalTime: LocalTime represents a time in a specific timezone. It has various method to perform operations on a time. Some of the methods are:

LocalTime currentTime = LocalTime.now();   // returns the current time in system default timezone
LocalTime time1 = LocalTime.of(10, 30);  // creates a LocalTime object of 10:30
LocalTime time2 = LocalTime.parse("13:45:30");  // creates a LocalTime object by parsing a string

LocalDateTime: LocalDateTime represents a date and time in a specific timezone. It has various method to perform operations on a date and time. Some of the methods are:

LocalDateTime currentDateTime = LocalDateTime.now();   // returns the current date and time in system default timezone
LocalDateTime dateTime1 = LocalDateTime.of(2021, 8, 1, 10, 30);  // creates a LocalDateTime object of 1st August 2021, 10:30
LocalDateTime dateTime2 = LocalDateTime.parse("2021-08-05T09:15:30");  // creates a LocalDateTime object by parsing a string

By using these APIs, we can easily manipulate and perform operations on date and time values in our Java programs.

Definition of Nashorn in Java 8

Nashorn is a JavaScript engine that first appeared in Java 8. It allows Java developers to embed JavaScript code within their applications and execute it directly on the JVM (Java Virtual Machine). It supports the latest ECMAScript 5.1 standard and can also execute JSON (JavaScript Object Notation) and Node.js scripts. Nashorn is intended to provide a lightweight and high-performance alternative to other Java-based JavaScript engines, such as Rhino. With its introduction in Java 8, Nashorn has become the default JavaScript engine for Java.

Usage of JJS in Java 8

JJS, also known as Nashorn, is a JavaScript engine for Java 8. It allows developers to execute JavaScript code within Java applications and use Java libraries from within JavaScript code.

JJS can be used to perform various tasks such as scripting, testing, and automation. It provides a command-line interface for running JavaScript code directly from the terminal.

Additionally, JJS can also be embedded within Java applications to provide scripting capabilities to end users.

Overall, JJS in Java 8 offers a convenient way to integrate JavaScript and Java and provides flexibility to developers in terms of scripting, testing, and automation.

Technical Interview Guides

Here are guides for technical interviews, categorized from introductory to advanced levels.

View All

Best MCQ

As part of their written examination, numerous tech companies necessitate candidates to complete multiple-choice questions (MCQs) assessing their technical aptitude.

View MCQ's
Made with love
This website uses cookies to make IQCode work for you. By using this site, you agree to our cookie policy

Welcome Back!

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign in
Recover lost password
Or log in with

Create a Free Account

Sign up to unlock all of IQCode features:
  • Test your skills and track progress
  • Engage in comprehensive interactive courses
  • Commit to daily skill-enhancing challenges
  • Solve practical, real-world issues
  • Share your insights and learnings
Create an account
Sign up
Or sign up with
By signing up, you agree to the Terms and Conditions and Privacy Policy. You also agree to receive product-related marketing emails from IQCode, which you can unsubscribe from at any time.