Top Java Interview Questions – Toiler’s Recommended

Ans: Compiling the Java source code into bytecode is the important part of the Java Program executions. Bytecode is an intermediate representation of the code that is platform-independent and can be executed on any Java Virtual Machine (JVM). This Bytecode makes Java Program platform independent.

Writing Java Source Code: Our first step is writing Java source code using a text editor or Integrated Development Environment (IDE). Save the Java source code files with a .java extension.

Compilation: Once the source code is written and saved in .java file. Now next turn is to compile it. Compilation is the process of translating human-readable Java source code into platform-independent bytecode. javac compiler is used for this translation. It is included with the Java Development Kit (JDK).

Command to compile Java File

javac YourJavaFile.java

Above code will generate a bytecode file with a .class extension. If your source file is named MyClass.java, the bytecode file will be named MyClass.class.

Bytecode and Machine code, both are the forms of low-level representations of code. They both have different purposes and are used in different contexts.

Bytecode

Bytecode is an intermediate representation of code that is generated by a compiler from the human readable source code. It is not directly executed by a physical computer’s CPU. It is designed to be executed by a virtual machine. In Java Programing language there is Java Virtual Machine (JVM) to execute bytecode. And in .NET languages there is Common Language Runtime (CLR) to execute byte code.

Machine Code

Machine code is a binary representation of instructions that can be directly executed by a computer’s central processing unit (CPU). It consists of sequences of binary numbers (1s and 0s) that correspond to specific CPU instructions.

Ans: A Java class file is a binary file that contains the compiled bytecode representation of a Java class. It adheres to a specific structure defined by the Java Virtual Machine (JVM) specification. The structure of a Java class file is organized into various sections and data structures.

Key components and structure of a typical Java class file:

1. Magic Number: The class file begins with a 4-byte “magic number” that identifies it as a valid Java class file. The magic number is always 0xCAFEBABE in hexadecimal.
2. Minor and Major Version: Following the magic number are two 2-byte fields that represent the minor and major versions of the class file format.
3. Constant Pool: The constant pool is a table of constants used within the class. It includes literal values, symbolic references to classes, fields, and methods, and other constant data.
4. Access Flags: A 2-byte field that specifies access modifiers and other flags associated with the class, such as whether it is public, final, abstract, etc.
5. This Class and Super Class: These two fields are 2-byte indices into the constant pool, specifying the fully qualified names of the current class and its superclass.
6. Interfaces: A count of the number of interfaces the class implements, followed by an array of 2-byte indices pointing to the constant pool entries representing those interfaces.

and some more are Fields, Methods, Attributes and Class File Attributes.

Ans: The Java Virtual Machine (JVM) is responsible for executing Java bytecode, which is the compiled form of Java source code. Here’s a high-level overview of how the JVM executes Java bytecode:

Class Loading:

Here JVM first loads the necessary classes into memory. Class loading is typically performed as needed, so classes are loaded when they are first referenced in the code.

The class loading process involves locating the bytecode for a class (usually from .class files or JAR files), reading the bytecode, and creating a representation of the class in memory. This representation includes the class’s methods, fields, and other metadata.

Bytecode Verification:

After a class is loaded, the JVM performs bytecode verification to ensure that the bytecode is valid, safe, and adheres to the language’s rules.

Execution:

Once a class is loaded and verified, the JVM is ready to execute its bytecode.

Two commonly used methods to execute bytecode are interpretation and Just-In-Time (JIT) compilation:

Interpretation: In the interpretation mode, the JVM reads each bytecode instruction and executes it step by step. This is a straightforward but relatively slower approach.

Just-In-Time (JIT) Compilation: In JIT compilation, the JVM translates bytecode into native machine code for the host platform just before executing it. The generated native code is then executed directly by the CPU, which is significantly faster than interpretation.

JVM provide platform independence for Java applications by providing bytecode execution independently.

Java source code is first compiled into bytecode, which is a platform-independent representation of the code. Bytecode consists of instructions that are not tied to any specific hardware or operating system. The JVM is responsible for interpreting or compiling this bytecode into native machine code at runtime. And this makes it executable on any platform that has a compatible JVM.

Classpath is a parameter in the Java Virtual Machine or the Java compiler that specifies the location of user-defined classes and packages. This is where the Java Virtual Machine (JVM) looks for classes and resources when loading them at runtime.

It specifies directories and JAR (Java Archive) files where the JVM should search for class files and resources (such as configuration files, images, and property files) required by a Java application.

Just-In-Time (JIT) compilation is a technique to improve the execution performance of programs. It dynamically compiling and optimizing code during execution. It combines the advantages of both interpretation and native code execution while adapting to the specific runtime environment and usage patterns.

In JIT compilation, the JVM translates bytecode into native machine code for the host platform just before executing it. The generated native code is then executed directly by the CPU, which is significantly faster than interpretation.

In the Java runtime environment, the Java stack, heap, and method area play distinct roles in managing memory and executing Java applications.

Java Stack

The Java stack is responsible for managing and keep tracking the execution of Java methods. It keeps track of method call frames, which contain information about a method’s local variables and its execution context.

When a method is invoked, a new frame is pushed onto the stack, storing the method’s local variables and other context information. When the method completes, its frame is popped from the stack.

Java Heap

Java heap memory, often referred to simply as the “heap,” is a region of memory within the Java Virtual Machine (JVM) that is used for dynamic memory allocation. It is the area where Java objects are created and managed during the execution of a Java program.

It is responsible for object creation, garbage collection, and memory management. Java heap memory area is basically used for dynamic memory allocation, specifically for objects that have a longer lifespan than local variables on the stack.

Method Area

The method area is used to store class-level information, including class metadata, bytecode, and static fields. It is shared among all threads in the JVM and contains data related to classes, methods, and other class-level structures.

Class metadata, such as class names, methods, and fields, is stored in the method area. This information is needed for class loading, verification, and execution.

In the Java Virtual Machine (JVM), several components work together to load, verify, and execute Java bytecode. Among these components, the class loader, bytecode verifier, and execution engine play crucial roles in the execution of Java programs.

Class Loader

The class loader is responsible for loading classes into the JVM at runtime. It takes care of locating class files, reading their bytecode, and creating the necessary data structures to represent these classes in memory.

The class loading process typically involves three phases: loading, linking, and initialization.

Bytecode Verifier

The bytecode verifier is a crucial security component in the JVM. Its primary role is to verify that the loaded bytecode adheres to the Java language’s type safety rules and does not violate memory constraints.

It ensures that bytecode does not access memory outside its allocated space, preventing buffer overflows and other security vulnerabilities.

Execution Engine

The execution engine is responsible for executing the verified bytecode. It interprets or compiles bytecode into native machine code for execution by the CPU. Just-In-Time(JIT) compilation is its part.

In Java, encapsulation and data hiding are closely related concepts, but they have distinct meanings and purposes.

Generics in programming languages, including Java, are a powerful feature. It allows us to write code that can work with different data types in a type-safe and reusable manner. The primary purpose of generics is to enable you to create classes, interfaces, and methods that operate on generic types. It ensure compile-time type safety.

Example:

public class Box<T> {
    private T contents;

    public Box(T contents) {
        this.contents = contents;
    }

    public T getContents() {
        return contents;
    }

    public void setContents(T contents) {
        this.contents = contents;
    }
}

Generics are widely used in Java for collections (e.g., ArrayList<T>), data structures, and libraries to provide flexibility, type safety, and code reusability.

There are a total of 12 access modifiers in Java. It basically control the visibility and accessibility of classes, methods, fields, and other members within a Java program.

These modifiers determine which parts of a Java class or interface can be accessed from other classes and packages.

List of modifiers are

1. Public : Members with the public modifier are accessible from any class or package.

2. Private: Members with the private modifier are only accessible within the same class.

3. Protected: Members with the protected modifier are accessible within the same package or different package by subclasses. It is not accessibly outside the packages if there is no subclass.

4. Default (No Modifier): Members with no explicit access modifier (i.e., no public, private, or protected modifier) are also known as package-private or default. They are accessible within the same package but not from outside the package.

In Java there are two ways to declare a String.

1). Using String Literal

String str= "Hello, World!";

This is Simple and concise. For same string, it share the references of heap memory rather than creating the new memory. It saves memory and improve performance.

Use string literals for constant strings that won’t change during the program’s execution.

2).Using the new Keyword

String str = new String("Hello, World!");

Allows for dynamic creation of strings. it creates a new string object on the heap for each call, which can be less memory-efficient and slower compared to string literals.

Used it when you specifically want to create a new string object or when dealing with strings obtained from external sources.

Its compile time.

In java, methods are categorized into two main types: static methods and instance methods.

Static Methods:

• It is declared using the static keyword.
• Example: public static void doSomething() { ... }.
• Static methods are called with the class name, not on instances of the class.
• Example: ClassName.doSomething();
• Static methods are often used for utility functions that are not tied to a specific instance but are related to the class as a whole.
• Examples include factory methods, helper functions, and mathematical operations.

public class MathUtils {
    // Static method to calculate the factorial of a number
    public static int factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int num = 5;

        // Calling a static method directly on the class
        int factorialResult = MathUtils.factorial(num);
        System.out.println("Factorial of " + num + " is " + factorialResult);

    }
}

Instance Methods:

• Instance methods are declared without the static keyword.
• Example: public void doSomething() { ... }
• Instance methods are called on instances (objects) of the class.
• Example: myObject.doSomething();
• Instance methods can access instance-specific data, including instance fields and other instance methods.
• They have access to this, which refers to the current instance of the class.

public class Person {
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Instance method to greet
    public void greet() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        // Creating instances of the Person class
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);

        // Calling instance methods on the objects
        person1.greet();
        person2.greet();
    }
}

There are multiple types of memory in java and each have their own uses.

Here we are going to see two types

1). Heap Memory

2). Stack Memory

Heap Memory

• Heap memory is the region where objects are allocated and deallocated during the runtime of a Java program.
• Specifically for objects that have a longer lifespan than local variables on the stack.
• It is the primary storage area for objects created using the new keyword and includes objects, arrays, and their instance variables.
• The Java Garbage Collector manages heap memory by reclaiming memory from objects that are no longer reachable or in use.

Stack Memory

• Stack memory is used for method execution and storing local variables, method parameters, and call stack frames.
• Local variables are short-lived and have a limited scope, as they exist only within the context of a single method call.
• Each thread in java has their own stack memory.
• The stack operates on a last-in, first-out (LIFO) basis, making it efficient for managing method calls and local data.

In Java, Boolean algebra evaluations can be done using logical operators and conditional statements. Boolean algebra involves operations such as AND, OR, NOT, and XOR on Boolean values (true or false).

In Java, Serialization is a mechanism to convert objects into a bytes stream that can be easily stored to a file, transmitted over a network, or persisted in a database. This process allows you to save the state of an object and recreate it later, possibly on a different JVM (Java Virtual Machine).

Serializable interface works in Java

Serializable interface implementation

import java.io.Serializable;

public class MyClass implements Serializable {
    // Class members and methods
}

Serialization Process

Create an instance of the ObjectOutputStream class, passing it an output stream (e.g., a FileOutputStream or a network socket stream).

ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("data.txt"));

Use the writeObject() method of the ObjectOutputStream to write the object to the output stream.

MyClass myObject = new MyClass();
outputStream.writeObject(myObject);

Static Block:

1. Static blocks are used to initialize static members (static fields or static methods) of a class.
2. They are executed only once when the class is loaded into memory. It happens before any objects of the class are created.

static {
    // Initialization code for static members
}

Instance Initialization Block:

1. Instance initialization blocks are used to initialize instance members (instance fields) of a class.
2. They are executed every time an object of the class is created, before the constructor(s) of the class are invoked.

{
    // Initialization code for instance members
}

Example to demonstrate Static block and instance block

public class StaticInstanceExample{
    static {
        System.out.println("Static block");
    }

    {
        System.out.println("Instance block");
    }

    public StaticInstanceExample() {
        System.out.println("Constructor executed");
    }

    public static void main(String[] args) {
        StaticInstanceExample obj1 = new StaticInstanceExample();
        StaticInstanceExample obj2 = new StaticInstanceExample();
    }
}

Output

Static block
Instance block
Constructor executed
Instance block
Constructor executed

Yes, Java Development Kit (JDK) 8 introduced several performance improvements and optimizations over earlier versions of Java. And this improvements makes it a more performance-tuned release.

Some improvements to notice are Lambda Expressions, Streams API, PermGen Removal, Method References, Improved Garbage Collection, Improved Date and Time API, Parallel and Concurrent APIs etc.

Java 7 introduced the Fork/Join Framework, which is a framework for parallelizing computations in Java applications. The primary goal of the Fork/Join Framework is to provide a simple and efficient way to divide a task into smaller subtasks, execute them in parallel, and then combine their results. In Java 7, this framework was considered a significant step forward for parallelism in Java.

In Java, class loaders are responsible for loading classes and resources into memory when they are needed by a Java program.

Different types of class loaders are:

• Bootstrap Class Loader
• Extension Class Loader
• System Class Loader
• Custom Class Loaders
• Thread Context Class Loader
• Parallel and Concurrent Class Loaders

In Java, Composition and aggregation are two fundamental concepts. It describes the relationships between objects in object-oriented programming. These relationships help define the structure and behavior of a software system.

Composition

Composition is a strong association between two or more classes, where one class (the composite) contains or is composed of other objects (the components) as its parts.

In composition, the lifetime of the contained objects is controlled by the composite object. When the composite object is destroyed, its parts are also destroyed.

An example of composition is a Car class composed of Engine, Wheels, and Seats objects. When the Car object is created, it creates and owns its parts.

Aggregation

Aggregation is a weaker association between two or more classes, where one class (the whole) is associated with other objects (the parts), but the parts can exist independently of the whole.

In aggregation, the lifetime of the contained objects is not controlled by the whole, they can exist before or after the whole object.

An example of a Library class and Book objects. The Library class is associated with Book objects, but books can exist independently.

In Java, marker interface is a interface without any methods and any fields. It is used to indicate certain characteristics or behaviors of a class that implements it. Marker interfaces are typically used to add metadata or to provide some special instructions to the compiler or runtime environment. They serve as a way to “mark” or “tag” classes, indicating that they possess certain qualities or should be treated in a particular way.

Some Marker Interfaces are:

1). Serializable Interface

2). Cloneable Interface

3). Remote Interface (for RMI)

4). Custom Marker Interfaces

Singleton Design Pattern ensure that a class can have only one instance and that instance is shared by all parts of the code that need to access it. To prevent external instantiation, the Singleton class typically has a private constructor, making it impossible to create instances from outside the class.

Example

public class Singleton{
     private static volatile Singleton instance;
     private Singleton(){
         
     }
     public static synchronized Singleton getInstance(){
         if(instance == null){
             instance = new Singleton();
         }
         return instance;
     }
}

Singletons are commonly used in scenarios where there must be exactly one instance of a class to coordinate actions across the system, control access to a shared resource, or maintain a single point of control, such as:

• Database connections.
• Configuration management.
• Logging services.
• Caching mechanisms.
• Thread pools.
• Hardware access.

The Builder design pattern is a creational pattern used to construct a complex object step by step. It’s particularly useful when an object needs to be created with many possible configurations, some of which might be optional.

The Builder pattern encapsulates the construction of an object and allows it to be constructed in steps. This pattern separates the construction of a complex object from its representation, making it possible to use the same construction process to create different representations.

Example

Let’s illustrate the Builder pattern with a simple example of building a User object with various attributes.

Step 1: Construct the User Class

public class User {
    private final String firstName; // required
    private final String lastName;  // required
    private final int age;          // optional
    private final String phone;     // optional

    public User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.phone = builder.phone;
    }

    // Getters here

    public static class UserBuilder {
        private final String firstName;
        private final String lastName;
        private int age;
        private String phone;

        public UserBuilder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }

        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

Step 2: Construct the Object

User user = new User.UserBuilder("John", "Doe")
                .age(30)
                .phone("1234567890")
                .build();

No

Java is often referred to as an object-oriented programming (OOP) language due to its emphasis on encapsulating data and behavior into objects and its use of core OOP principles such as inheritance, polymorphism, and abstraction. Here are few reasons that java is not 100% object oriented programming language:

• Java includes eight primitive data types (boolean, byte, char, short, int, long, float, double) that are not objects. These primitive types are used for performance reasons, as they have a lower overhead than their object counterparts. While Java provides wrapper classes (like Integer for int, Float for float, etc.) that encapsulate primitives in objects, the existence and use of primitives themselves are seen as a deviation from pure object-oriented design where everything should be an object.
• Java allows the use of static methods and variables that can be called without creating an instance of a class. This means that static methods and variables are not associated with any object instance but rather with the class itself. In a purely object-oriented language, all methods would need to be accessed through instances of objects, and all data would belong to objects.

The introduction of functional programming features in Java 8 marked a significant evolution of the language, aimed at making Java more expressive, efficient, and capable of handling modern computing challenges.

One of the primary motivations for introducing functional programming in Java 8 was to simplify the development of parallel and asynchronous programs. With the increasing importance of multicore processors, there was a need for a programming model that could more easily leverage these hardware capabilities. Functional programming, with its emphasis on immutability and stateless operations, fits well with parallel computing. Features like Streams API allow for more readable and concise code that can be parallelized with minimal effort.

In Java, both PermGen (Permanent Generation) and Metaspace deal with the storage of class metadata in the Java Virtual Machine (JVM). However, they are parts of different versions of Java, with Metaspace replacing PermGen in Java 8 due to various limitations and problems associated with PermGen.

PermGen (Permanent Generation)

PermGen was a specialized heap space separate from the main memory heap where Java stores its objects. Introduced in earlier versions of Java, it specifically held metadata describing user classes (classes that are not part of the Java language itself), such as class structures, method data, field data, and other information about classes and methods.

Key Characteristics and Challenges of PermGen:

• Fixed Size: PermGen had a fixed maximum size which had to be specified using JVM options at startup. If the space was exhausted, it caused java.lang.OutOfMemoryError: PermGen space errors.
• Non-Resizable: Unlike the regular heap, the size of PermGen could not dynamically adjust at runtime based on the application’s demands.
• Garbage Collection: Although garbage collection did occur in PermGen, it was often not as effective because class metadata is generally long-lived, reducing the effectiveness of cleanup operations.

These characteristics often led to issues in environments with dynamic class loading and unloading, such as web servers and application servers, where applications are frequently redeployed without restarting the JVM.

Metaspace

Introduced in Java 8, Metaspace replaced PermGen. Metaspace addresses many of the limitations of PermGen by using native memory (the memory available to the JVM from the underlying operating system) to store class metadata.

Key Features of Metaspace:

• Dynamic Resizing: Unlike PermGen, Metaspace can dynamically resize depending on the application’s demands, reducing the likelihood of OutOfMemoryError related to class metadata storage.
• Native Memory Usage: Metaspace uses native memory, which generally allows for a larger amount of memory than what was typically allocated to PermGen. The size of Metaspace is only limited by the amount of native memory available to the Java process.
• Configurable Size Limits: While Metaspace can grow dynamically, developers can still control its growth using JVM options like -XX:MetaspaceSize for the initial size and -XX:MaxMetaspaceSize for the maximum size, the latter of which can be left unbounded to allow Metaspace to grow as needed.

Benefits of Metaspace over PermGen:

1. Scalability: The use of native memory allows Metaspace to scale more smoothly as the demand for class metadata storage increases, without the strict bounds that PermGen imposed.
2. Fewer OutOfMemoryErrors: The dynamic resizing capability helps to avoid out-of-memory errors under normal circumstances.
3. Improved Performance: Allocating and deallocating native memory can be faster than managing the same operations within a bounded space like PermGen.

Yes, multiple catch blocks can exist in a Java try-catch statement to handle different types of exceptions. The catch blocks are evaluated in top-down order. The first catch block that matches the type of the thrown exception (or a subtype) will be executed. This means that the order of catch blocks matters, and you should place more specific catch blocks before more general ones.

Or you can say first we keep the child class of exception then parent class.

Here’s an example:

try {
    int result = 10 / 0; // ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("ArithmeticException occurred.");
} catch (NullPointerException e) {
    System.out.println("NullPointerException occurred.");
} catch (Exception e) {
    System.out.println("General Exception occurred.");
}

Ans: An exception is an abnormal and unexpected event that occurs during the execution of a program. Whenever exception occurs, It disrupts its normal flow. Exceptions handling in programing language is used to handle exception and protect it from the abnormal termination.

Custom Exception Creation

Custom exceptions can be created by extending either the Exception class for checked exceptions, which must be either caught or declared to be thrown, or the RuntimeException class for unchecked exceptions, which do not need to be explicitly handled.

Steps to Create a Custom Exception

1. Define a New Exception Class: This class should extend either Exception or RuntimeException, depending on whether you want it to be a checked or unchecked exception.
2. Add Constructors: Typically, you would add at least two constructors: one default constructor and one that takes a string message as an argument, which passes this message to the superclass constructor. You can also add a constructor that handles cause or one that handles both message and cause.

Example

class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            // Simulate an error condition
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (CustomException ex) {
            // Handle the custom exception
            System.err.println("Custom Exception: " + ex.getMessage());
        }
    }

    public static int divide(int numerator, int denominator) throws CustomException {
        if (denominator == 0) {
            // Throw the custom exception when division by zero occurs
            throw new CustomException("Cannot divide by zero");
        }
        return numerator / denominator;
    }
}

Ans: No, a try block doesn’t exist independently. It usually needs at least one catch or finally block to handle exceptions or perform cleanup operations. The try block, along with catch and finally blocks, forms a structured exception handling construct.

Example:

public class Main
{
	public static void main(String[] args) {
	try{
        int result = divide(10, 0);
        System.out.println("Result: " + result);
	    }
	}
}

Output

Main.java:12: error: 'try' without 'catch', 'finally' or resource declarations
	try{
	^
1 error

Ans: “Try with resources” is a feature introduced in Java, specifically in Java 7, to simplify resource management, such as handling files, network connections, or other resources that need to be opened and closed properly. It helps ensure that resources are automatically closed when they are no longer needed, reducing the risk of resource leaks and making code cleaner and more reliable.

In Java, you can use the try-with-resources statement to automatically close resources that are declared within the parentheses of the try block. Resources that can be used with try-with-resources must implement the AutoCloseable interface, which includes the close() method. The try-with-resources statement ensures that the close() method is called on the resource(s) when the try block is exited, either normally or due to an exception.

Here’s the basic syntax of try-with-resources:

try (ResourceType resource1 = new ResourceType1();
     ResourceType resource2 = new ResourceType2()) {
    // Code that uses the resources
} catch (Exception e) {
    // Exception handling
}

Here’s an example of using try-with-resources to read data from a file in Java:

try (FileReader reader = new FileReader("example.txt")) {
    int data;
    while ((data = reader.read()) != -1) {
        System.out.print((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

In this example:

• FileReader is a resource that implements AutoCloseable.
• The try block declares and initializes the FileReader resource within the parentheses.
• The code reads data from the file within the try block.
• When the try block is exited (either normally or due to an exception), the close() method of the FileReader is automatically called to close the file, ensuring proper resource management.

try-with-resources simplifies the code by removing the need for explicit finally blocks to close resources and by automatically handling exceptions related to resource closure. It’s considered a best practice for managing resources in Java.

Yes, it is possible to have a try-catch block within another try block. This is often referred to as nested try-catch blocks.

Nested try-catch blocks can be useful when you want to handle exceptions at different levels of your code. The outer catch block can handle exceptions that are not caught by inner catch blocks, providing a way to manage exceptions at various scopes in your code.

final:

• final is a keyword in Java that can be applied to classes, methods, and variables.
• When applied to a class, it makes the class uninheritable, meaning it cannot be extended by other classes.
• When applied to a method, it prevents the method from being overridden by subclasses.
• When applied to a variable, it makes the variable a constant, and its value cannot be changed once assigned.

public class FinalExample {
    public static void main(String[] args) {
        final int x = 20;  // A final variable
        // x = 40; // This would result in a compilation error because x is final
        System.out.println("Value of x: " + x);
    }
}

finally:

• finally is a keyword used in Java to define a block of code that is always executed, whether an exception is thrown or not, after the try or try-catch block.
• It is commonly used for cleanup tasks or to ensure certain code is executed even in the presence of exceptions.

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // This will throw an exception
        } catch (ArithmeticException e) {
            System.out.println("An exception occurred: " + e.getMessage());
        } finally {
            System.out.println("Finally block always executes.");
        }
    }
}

finalize:

• finalize is a method defined in the java.lang.Object class.
• It’s called by the Java Virtual Machine (JVM) when an object is about to be garbage collected (i.e., when there are no more references to the object).
• You can override this method in your classes to perform cleanup or resource release operations before the object is destroyed.
• In Summary, finalize is a method called by the JVM during garbage collection and can be overridden for custom cleanup operations, but it’s not commonly used for resource management in modern Java.

class MyResource {
    public void open() {
        System.out.println("Resource opened.");
    }

    public void close() {
        System.out.println("Resource closed.");
    }

    @Override
    protected void finalize() throws Throwable {
        close(); // Perform cleanup when the object is garbage collected
    }
}

public class FinalizeExample {
    public static void main(String[] args) {
        MyResource resource = new MyResource();
        resource.open();
        // resource = null; // Uncomment this line to make the object eligible for garbage collection
        System.gc(); // Suggest the JVM to run garbage collection
    }
}

Java 8’s introduction of lambda expressions and the Stream API indirectly affected how developers might deal with exceptions in certain contexts, particularly in functional-style programming constructs.

Catch Exceptions Within the Lambda: Directly handling exceptions inside the lambda expression.

Runnable r = () -> {
    try {
        throw new IOException();
    } catch (IOException e) {
        e.printStackTrace();
    }
};

Java exceptions are broadly classified into two main types: checked and unchecked exceptions.

Checked Exceptions

• Explanation: Checked exceptions are exceptions that must be either handled within a try-catch block or declared in the method signature using the throws keyword. They are checked at compile-time, which means if a method could throw a checked exception, the programmer is forced to handle it. If not handled or declared, the program will not compile.
• Examples: IOException, SQLException. These are typically external to the program and depend on the runtime environment.

Unchecked Exceptions:

• Explanation: Unchecked exceptions are not checked at compile time. It means if your code throws an unchecked exception, the compiler does not force you to handle it. These exceptions are checked at runtime.
• Examples: NullPointerException, ArrayIndexOutOfBoundsException. These are usually the result of bad programming.

The throw keyword in Java is used to explicitly throw an exception from a method or any block of code. When you use the throw keyword, you are essentially creating an instance of an exception and passing it to the runtime system to handle it.

Purpose: The main purpose of using throw is to let you handle errors or any other exceptional conditions in your code by throwing an exception when a specific error condition occurs.

How It Works:

1. Throwing an Exception: You can throw either a new instance of an exception or an existing instance that has been caught in a catch block.
2. Handling an Exception: Once an exception is thrown, it must be caught and handled by a catch block. If it is not caught within the current method, it propagates up the call stack to previous methods until it finds an appropriate handler. If no handler is found, the program terminates.

Example Usage:

Here is a simple example that shows how to use the throw keyword:

public class Main {
    public static void checkAge(int age) {
        if (age < 18) {
            // Throw an ArithmeticException if the age is below 18
            throw new ArithmeticException("Access denied - You must be at least 18 years old.");
        } else {
            System.out.println("Access granted - You are old enough!");
        }
    }

    public static void main(String[] args) {
        try {
            checkAge(15); // This will throw an exception
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
        System.out.println("Program continues after the catch block.");
    }
}

In this example:

• The checkAge method throws an ArithmeticException if the age parameter is less than 18.
• The exception is thrown using the throw keyword followed by the new keyword to create a new instance of ArithmeticException.
• The main method calls checkAge and catches the exception in a try-catch block. The program handles the exception by printing a message and then continues.

The throws keyword in Java is used in the method signature to indicate that the method might throw one or more exceptions during its execution. It effectively communicates to the callers of the method that they need to handle these exceptions.

Purpose: The purpose of using throws is to declare that a method will not handle certain exceptions itself, instead passing the responsibility to handle these exceptions up to the method that calls it. This is particularly useful when you want to maintain clean code separation and push error handling responsibilities to higher layers of an application.

How It Works:

• Declaring Exceptions: When a method could throw checked exceptions (exceptions that the compiler checks for during the compilation time, such as IOException), these exceptions must be declared using throws.
• Propagation: If a method that throws checked exceptions is called, the calling method must either handle these exceptions with a try-catch block or declare that it throws them as well, propagating them further up the call stack.

Example

public class DivisionCalculator {
    // Method to divide two numbers, declaring that it can throw ArithmeticException
    public static double divide(int numerator, int denominator) throws ArithmeticException {
        if (denominator == 0) {
            // Explicitly throw ArithmeticException if denominator is zero
            throw new ArithmeticException("Cannot divide by zero.");
        }
        return (double) numerator / denominator;
    }

    public static void main(String[] args) {
        try {
            // Calling divide method. It's necessary to handle the declared exception.
            double result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            // Catching the ArithmeticException
            System.out.println("Caught an exception: " + e.getMessage());
        }
    }
}

Explanation:

• Method Definition: The divide method is defined to take two integers as input: a numerator and a denominator. It returns a double type result of their division.
• Exception Handling: It declares that it can throw an ArithmeticException using the throws keyword. This is because dividing by zero is an illegal operation in arithmetic, which could lead to an exception.
• Throwing an Exception: Inside the method, there is a check to see if the denominator is zero. If it is, the method throws an ArithmeticException with a message “Cannot divide by zero.”
• Method Call: In the main method, divide is called. Since divide can throw an ArithmeticException, this call is wrapped in a try-catch block to handle the potential exception.
• Error Handling: If an ArithmeticException occurs, it is caught in the catch block, and an error message is printed.

Handling exceptions in a method that returns a value requires careful consideration to ensure that all possible execution paths are covered and that the method can handle exceptional circumstances gracefully. Here are the common strategies you can use:

1. Return a Special Value

One way to handle exceptions in methods that must return a value is to designate a special return value to indicate an error condition.

Example

public int divide(int numerator, int denominator) {
    try {
        return numerator / denominator;
    } catch (ArithmeticException e) {
        // Returning a special value to indicate an error
        return Integer.MIN_VALUE;
    }
}

Explanation: In this example, if an ArithmeticException occurs (e.g., division by zero), the method returns Integer.MIN_VALUE to indicate something went wrong. The caller must understand that this value signifies an error.

2. Throw a Custom Exception

If an error condition should not be masked by a special or default value, you might want to throw a custom exception that can be handled further up the call stack.

Example

public double divide(int numerator, int denominator) throws InvalidDivisionException {
    if (denominator == 0) {
        throw new InvalidDivisionException("Can't divide by zero.");
    }
    return (double) numerator / denominator;
}

Explanation: Instead of handling the exception within the method, this approach throws a custom exception. The method signature must declare this exception (unless it is a runtime exception), and the caller is responsible for handling it.

Some Common Compile-Time (Checked) Exceptions

1. ClassNotFoundException
2. IOException
3. FileNotFoundException
4. SQLException
5. NoSuchMethodException
6. InstantiationException
7. IllegalAccessException
8. ParseException

List of some common runtime exceptions in Java

1. NullPointerException
2. ArrayIndexOutOfBoundsException
3. ArithmeticException
4. IllegalArgumentException
5. NumberFormatException
6. UnsupportedOperationException
7. ConcurrentModificationException

In Java, an Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Errors are typically abnormalities that happen beyond the control of the user or programmer and are usually associated with the environment in which the application is running. Unlike exceptions, errors are often fatal and indicate a severe problem that a program cannot handle, such as system crash or a low-level system malfunction.

Common Types of Errors:

Here are some of the typical Error types you might encounter in Java:

1. OutOfMemoryError
   • Thrown when the Java Virtual Machine cannot allocate an object because it is out of memory, and no more memory could be made available by the garbage collector.
2. StackOverflowError
   • Thrown when a stack overflow occurs because an application recurses too deeply.
3. NoClassDefFoundError
   • Thrown if the Java Virtual Machine or a ClassLoader instance tries to load in the definition of a class (as part of a normal method call or as part of creating a new instance using the new expression) and no definition of the class could be found.
4. UnsatisfiedLinkError
   • Thrown if the Java Virtual Machine cannot find an appropriate native-language definition of a method declared native.
5. InternalError
   • Signals that an internal error occurred in the Java Virtual Machine but does not specify what the problem is.
6. AssertionError
   • Thrown to indicate that an assertion has failed. These are raised typically to catch attention during development and testing phases, after enabling assertions at runtime.

Example:

public class ExampleError {
    public static void generateError() {
        // Intentionally causing stack overflow
        generateError();
    }
    public static void main(String[] args) {
        try {
            generateError();
        } catch (StackOverflowError e) {
            System.out.println("Caught StackOverflowError. Error message: " + e.getMessage());
        }
    }
}

Explanation: In this example, the method generateError() recursively calls itself indefinitely, leading to a StackOverflowError. The error is caught in the main method, though typically, it’s not advisable to catch such serious problems as errors usually indicate something seriously wrong that should be corrected rather than handled at runtime.

Conclusion:

While you can catch errors just like exceptions, handling them usually involves corrective action related to configuration, or fixing underlying environmental issues or bugs. Generally, in production environments, the focus should be on identifying the cause of such serious issues and correcting them rather than attempting to recover from them programmatically.

In Java, Throwable is the superclass of all errors and exceptions in the Java language. It is the top class in the hierarchy of Java’s exception handling classes. All the classes that are used for exception handling are derived from the Throwable class, meaning that anything that can be thrown or caught as an exception or error in Java must be an instance of Throwable or one of its subclasses.

Main Subclasses of Throwable:

Throwable has two major direct subclasses:

1. Exception: Intended for conditions that a user’s program should catch. This class is the superclass of all exceptions that are meant to be recoverable.
2. Error: Intended for serious errors from which recovery is not usually possible, typically reflecting some abnormal condition in the JVM or underlying hardware.

In Java, Abstract class is a class that is started with abstract keyword. It is a class that cannot be instantiated. It can have abstract and concrete methods both. It works as a blueprint for other classes.

Key characteristics of abstract classes

1. Cannot be Instantiated: Abstract class cannot be instantiated using the new keyword. Attempting to do so will result in a compilation error.
2. May Contain Abstract Methods and Concrete Methods : Abstract class contains both abstract method (without body) and concrete method (with body).
3. All fields are automatically public, static, and final in abstract class.

Example of Abstract Class

abstract class Shape {
    // Fields
    protected String color;

    // Constructor
    public Shape(String color) {
        this.color = color;
    }

    // Abstract method to calculate area (to be implemented by subclasses)
    public abstract double calculateArea();

    // Concrete method
    public void displayColor() {
        System.out.println("Color: " + color);
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        Circle circle = new Circle("Yellow", 15.0);
        Rectangle rectangle = new Rectangle("Green", 3.0, 5.0);

        circle.displayColor();
        System.out.println("Area of Circle: " + circle.calculateArea());

        rectangle.displayColor();
        System.out.println("Area of Rectangle: " + rectangle.calculateArea());
    }
}

Output

Color: Yellow
Area of Circle: 706.8583470577034
Color: Green
Area of Rectangle: 15.0

No we can’t. Attempting to create an object (instance) of an abstract class using the new keyword will result in a compilation error.

abstract class MyAbstractClass {
    abstract void abstractMethod();
}

public class Main {
    public static void main(String[] args) {
        MyAbstractClass instance = new MyAbstractClass(); 
    }
}

Output

Main.java:7: error: MyAbstractClass is abstract; cannot be instantiated
        MyAbstractClass instance = new MyAbstractClass(); 

In an abstract class in Java, you can define constructors just like you would in a regular class.

Few Points to keep in mind

• Constructors in an abstract class can have access modifiers like public, protected, or private just like constructors in regular classes.
• Constructors in an abstract class can participate in constructor chaining. This means that you can call one constructor from another using this() or super() just as you would in a regular class.

Example:

abstract class Shape {
    // Fields
    protected String color;

    // Constructor
    public Shape(String color) {
        this.color = color;
    }

    // Abstract method to calculate area (to be implemented by subclasses)
    public abstract double calculateArea();

    // Concrete method
    public void displayColor() {
        System.out.println("Color: " + color);
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        Circle circle = new Circle("Yellow", 15.0);
        Rectangle rectangle = new Rectangle("Green", 3.0, 5.0);

        circle.displayColor();
        System.out.println("Area of Circle: " + circle.calculateArea());

        rectangle.displayColor();
        System.out.println("Area of Rectangle: " + rectangle.calculateArea());
    }
}

Output

Color: Yellow
Area of Circle: 706.8583470577034
Color: Green
Area of Rectangle: 15.0

Yes

Using an abstract class is appropriate in various scenarios where you want to provide a common base for a group of related classes while ensuring that certain methods are implemented by all subclasses.

Example

abstract class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    // Abstract method for calculating shipping cost
    public abstract double calculateShippingCost();

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

class ElectronicsProduct extends Product {
    private double weight;

    public ElectronicsProduct(String name, double price, double weight) {
        super(name, price);
        this.weight = weight;
    }

    @Override
    public double calculateShippingCost() {
        // Calculate shipping cost based on weight and price
        return 0.05 * weight + 0.02 * getPrice();
    }
}

class ClothingProduct extends Product {
    private String size;

    public ClothingProduct(String name, double price, String size) {
        super(name, price);
        this.size = size;
    }

    @Override
    public double calculateShippingCost() {
        // Calculate shipping cost based on clothing size and price
        if (size.equals("Small")) {
            return 0.03 * getPrice();
        } else {
            return 0.04 * getPrice();
        }
    }
}

class BookProduct extends Product {
    private int pageCount;

    public BookProduct(String name, double price, int pageCount) {
        super(name, price);
        this.pageCount = pageCount;
    }

    @Override
    public double calculateShippingCost() {
        // Calculate shipping cost based on page count
        if (pageCount <= 100) {
            return 2.0;
        } else {
            return 3.0;
        }
    }
}

public class ECommerceExample {
    public static void main(String[] args) {
        // Create instances of different product types
        ElectronicsProduct laptop = new ElectronicsProduct("Laptop", 799.99, 5.0);
        ClothingProduct shirt = new ClothingProduct("Shirt", 29.99, "Medium");
        BookProduct novel = new BookProduct("Novel", 12.99, 250);

        // Calculate and display shipping costs
        System.out.println("Shipping cost for " + laptop.getName() + ": $" + laptop.calculateShippingCost());
        System.out.println("Shipping cost for " + shirt.getName() + ": $" + shirt.calculateShippingCost());
        System.out.println("Shipping cost for " + novel.getName() + ": $" + novel.calculateShippingCost());
    }
}

Output

Shipping cost for Laptop: $16.2498
Shipping cost for Shirt: $1.1996
Shipping cost for Novel: $3.0

No, a concrete class (a class without the abstract keyword) cannot have abstract methods. Abstract methods are intended to be declared in abstract classes or interfaces, and they are meant to be implemented (i.e., given a body) by subclasses. Concrete classes are expected to provide implementations for all methods declared in their superclass or interface, including abstract methods.

In Java, an interface is a blueprint for a class. An interface defines a contract of methods that should must be implement by the class that is implementing that interface.

interface MyInterface {
    void abstractMethod();
}

class MyClass implements Interface1, Interface2 {
    // Implement methods from Interface1 and Interface2
}

In Java, interfaces cannot contain instance variables (also known as fields or member variables) like classes can. Interfaces are primarily meant to declare method contracts and constants (static final variables), but they do not support instance variables.

Interfaces allow you to declare constants (static final variables) that are implicitly public, static, and final. These constants can be used to define shared values that implementing classes can access.

interface Constants {
    int MAX_VALUE = 100; // Constant declaration
}

class MyClass implements Constants {
    void printMaxValue() {
        System.out.println(MAX_VALUE); // Accessing the constant from the interface
    }
}

Yes, After java 8 we can define the default implementation for interface methods.

Example:

interface MyInterface {
    void regularMethod();
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

class MyClass implements MyInterface {
    @Override
    public void regularMethod() {
        System.out.println("Implementation of regularMethod in MyClass.");
    }

    @Override
    public void defaultMethod() {
        System.out.println("Custom implementation of defaultMethod in MyClass.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myObj = new MyClass();
        myObj.regularMethod();
        myObj.defaultMethod();
    }
}

In Java 8, “default” and “static” methods in interfaces were introduced to enhance the flexibility and functionality of interfaces.

Default Methods:

• Default methods allow you to add new methods to existing interfaces without breaking backward compatibility with classes that already implement those interfaces. This is especially useful when evolving libraries and APIs.
• Default methods provide a default implementation for a method in an interface.

Example

interface Calculator {
    int add(int a, int b);

    default int subtract(int a, int b) {
        return a - b;
    }
}

class BasicCalculator implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new BasicCalculator();

        int sum = calculator.add(25, 18);
        System.out.println("Sum: " + sum);

        int difference = calculator.subtract(25, 18);
        System.out.println("Difference: " + difference);
    }
}

Static Methods:

• Static methods in interfaces allow you to define utility methods that are related to the interface but do not depend on instance-specific data. These methods are invoked on the interface itself, not on instances.
• Java’s collection framework uses static methods in interfaces to create instances of collections with initial values (e.g., List.of(...), Set.of(...), Map.of(...)).

Example

interface MathOperations {
    static double calculateRectangleArea(double length, double width) {
        return length * width;
    }

    static double calculateCircleArea(double radius) {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        double rectangleArea = MathOperations.calculateRectangleArea(7.0, 4.0);
        System.out.println("Rectangle Area: " + rectangleArea);

        double circleArea = MathOperations.calculateCircleArea(2.5);
        System.out.println("Circle Area: " + circleArea);
    }
}

In Java, a functional interface is an interface that contains only one abstract method. Functional interfaces are also known as Single Abstract Method (SAM) interfaces. The concept of functional interfaces is closely associated with the introduction of lambda expressions in Java 8, which allows you to represent functional interfaces more concisely.

But functional interface can have multiple default methods or static methods without violating the functional interface contract.

Example

@FunctionalInterface
interface MyFunctionalInterface {
    void doSomething();
}

Abstraction is one of the fundamental principles of object-oriented programming (OOP). It allows us to model complex systems by simplifying and focusing on essential features by hiding the complex unnecessary details.

Several ways to achieve abstraction in OOP:

1). Abstract Classes: An abstract class is a class that cannot be instantiated and is typically used as a base class for other classes. It may contain abstract methods (methods without a body) that must be implemented by subclasses. Abstract classes can also have concrete methods with implementations.

abstract class Shape {
    abstract void draw(); // Abstract method
    abstract void display(){
      System.out.println("display");
    }
}

class Circle extends Shape {
    void draw() {
        // Implementation for drawing a circle
    }
}

2). Interfaces: An interface contains only abstract methods without its implementation. It is also know as contract of methods. All the methods must be implemented by any class that implements the interface. Unlike abstract classes, interfaces can be implemented by multiple classes, allowing for multiple inheritances of behavior.

interface Drawable {
    void draw();
    void area();
}

class Circle implements Drawable {
    void draw() {
        // Implementation for drawing a circle
    }
    void area() {
        // Implementation for calculating area of circle
    }
}

There are many more ways like Encapsulation, Polymorphism, Enums etc.

Abstract classes in Java are used to provide a common base or blueprint for other classes.

It is useful in creating Base Class, Defining Abstract Methods, Forcing Common Behavior, Enforcing a Design Contract, API Design, Restricting Instantiation etc.

In Java, you can call the constructor of an abstract class using the super() keyword from the constructor of a concrete subclass that extends the abstract class. This allows you to initialize fields and perform common setup tasks defined in the abstract class’s constructor.

Example:

abstract class AbstractClass {
    private int someField;

    public AbstractClass(int initialValue) {
        this.someField = initialValue;
        // Other common initialization tasks, if any
    }

    // Other methods and fields, if any
}

class ConcreteClass extends AbstractClass {
    private String someOtherField;

    public ConcreteClass(int initialValue, String value) {
        super(initialValue); // Call the constructor of the abstract class
        this.someOtherField = value;
        // Additional initialization for the subclass
    }

    // Other methods and fields specific to the subclass
}

In Java, interfaces cannot have constructors. Interface members are limited to abstract methods, default methods (introduced in Java 8), static methods (introduced in Java 8), and constant fields (static final variables).

Multithreading in Java refers to the concurrent execution of multiple threads within a Java program. A thread is a lightweight, independent unit of execution. Multiple threads can run concurrently in the same process. Multithreading allows a Java application to perform multiple tasks or processes in parallel, which can lead to improved performance and responsiveness.

Multithreading and multitasking are related concepts. But both works at different levels.

Multithreading:

Multithreading means multiple threads are executing parallelly within a single process. Threads within the same process share the same memory space, allowing them to access shared data and communicate easily.

For Example: Multiple threads can be used to perform different tasks concurrently within the same process. Suppose one thread might handle user interface updates, while another performs background data processing.

Multitasking:

Multitasking means various process are running concurrently on a computer. Each process has its own isolated memory space, file handles, and system resources. Processes are isolated from each other, meaning they cannot directly access each other’s memory.

For Example: In a computer operating system, multitasking allows multiple independent applications or programs to run simultaneously. Suppose a word processor and a web browser can run as separate processes, each with its own memory space and resources.

In Java, threads can be created using either the Thread class or by implementing the Runnable interface.

1). Extending the Thread Class:

Thread can be created by extending the Thread class and overriding its run() method. After that you can create an instance of your custom thread class and call the start() method to initiate the execution of the thread.

class MyThread extends Thread {
    public void run() { 
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); 
    }
}

Output

Thread: 0
Thread: 1
Thread: 2
Thread: 3
Thread: 4
Thread: 5
Thread: 6
Thread: 7
Thread: 8
Thread: 9

2). Implementing the Runnable Interface:

Thread is also created by implementing the Runnable interface. This approach allows better flexibility because it separates the thread’s behavior from the thread itself. You create an instance of your custom class that implements Runnable and pass it to a Thread object. Then, you call the start() method on the Thread object.

class MyRunnable implements Runnable {
    public void run() {
        // This code will be executed by the thread
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // Start the thread
    }
}

Output

Thread: 0
Thread: 1
Thread: 2
Thread: 3
Thread: 4
Thread: 5
Thread: 6
Thread: 7
Thread: 8
Thread: 9

In Java, a thread goes through several states during its lifecycle. These states represent different stages in the execution of a thread.

Various State of thread lifecycle

New: When a thread is created but has not yet started executing. In this state, the Thread object has been instantiated, but the start() method has not been called to begin execution.

Runnable/Ready: After a thread is created and is ready to run, it enters the “Runnable” or “Ready” state. This means the thread is waiting to be scheduled by the operating system’s thread scheduler to run on a CPU core. It is not guaranteed to be running yet, as it depends on the scheduling algorithm.

Running: When a thread is selected by the thread scheduler and is executing on a CPU core, it is said to be in the “Running” state. At any given time, only one thread from a multi-threaded process can be in the running state on a single CPU core.

Blocked/Waiting: Threads can enter the “Blocked” or “Waiting” state for various reasons, such as when they are waiting for a resource, waiting for user input, or sleeping for a certain amount of time. In this state, the thread is not executing and is waiting for a specific condition to be met before it can become runnable again.

In Java, wait(), notify(), and sleep() are methods commonly used in thread synchronization and management.

1). wait():

• wait() is a method available in the Object class in Java.
• It is used to make a thread to give up its lock on an object and enter a waiting state.
• When a thread calls wait(), it releases the lock on the object so that other threads can acquire the lock and execute the synchronized methods or blocks on the same object.
• The calling thread remains in a waiting state until another thread notifies it using the notify() or notifyAll() method on the same object or until it is interrupted.
• wait() is often used for thread synchronization and communication between threads.

Example

synchronized (sharedObject) {
    while (!condition) {
        sharedObject.wait(); // Release the lock and wait
    }
    // Perform some action when the condition is met
}

2. notify() and notifyAll():

• notify() and notifyAll() are methods available in the Object class.
• They are used to wake up one or all waiting threads that are in blocked state.
• notify() wakes up a single waiting thread that is blocked.
• notifyAll() wakes up all waiting threads that is blocked.
• These methods are used with wait() for implementing more complex thread synchronization patterns.

synchronized (sharedObject) { 
    sharedObject.notifyAll(); // Wake up all waiting threads
}

3. sleep():

• sleep() is a method provided by the Thread class in Java.
• It is used to pause the execution of the current thread for a specified amount of time (in milliseconds) that is given in sleep method. If specified time passed execution start again.
• Unlike wait(), sleep() does not release the lock on any object. The thread holding the lock will continue to hold it while sleeping.
• sleep() is often used for introducing time delays in thread execution or for scheduling periodic tasks.

try {
    Thread.sleep(1000); // Sleep for 1 second
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

In summary, wait(), notify(), and sleep() are essential tools for managing and synchronizing threads in Java. wait() and notify() are used for communication and synchronization between threads, while sleep() is used for introducing time delays in thread execution.

In Java, thread priorities are a way to influence the scheduling of threads by indicating their relative importance or urgency to the Java Virtual Machine (JVM). Thread priorities help the JVM’s thread scheduler decide which thread should be executed next when multiple threads are ready to run. Thread priorities are represented as integers and defined as constants in the Thread class. The available thread priority levels in Java are:

1. MIN_PRIORITY (1): This is the lowest thread priority level. Threads with this priority are considered to be of minimal importance, and the JVM scheduler will give them less preference when deciding which thread to execute.
2. NORM_PRIORITY (5): This is the default thread priority level. Threads that are created without explicitly setting a priority will be assigned this priority. It represents a moderate level of importance.
3. MAX_PRIORITY (10): This is the highest thread priority level. Threads with this priority are considered to be of utmost importance, and the JVM scheduler will give them higher preference when selecting the next thread to run.

You can set a thread’s priority using the setPriority(int priority) method of the Thread class, where priority is an integer value representing the desired priority level.

For example:

Thread thread = new Thread(() -> {
    // Thread logic here
});

thread.setPriority(Thread.MAX_PRIORITY); // Set the thread's priority to the maximum

However, there are some important points to keep in mind regarding thread priorities in Java:

1. The exact behavior of thread priorities can vary between different Java Virtual Machine implementations and operating systems. While priorities provide a hint to the JVM scheduler, they do not guarantee a strict execution order.
2. Relying solely on thread priorities for critical synchronization or coordination between threads is not recommended. Proper synchronization mechanisms such as wait(), notify(), and synchronized blocks should be used to ensure thread safety and correct coordination.
3. Setting thread priorities to extreme values (MIN_PRIORITY or MAX_PRIORITY) should be done with caution, as it may disrupt the overall system’s fairness and performance.
4. In modern multi-core processors, thread priorities might have limited impact on performance, as other factors like thread affinity and context switching play a role in determining the execution order.

A deadlock is a common problem in multi-threading and concurrent programming. This is a situation where two or more threads are unable to proceed with their execution because they each are waiting for a resource that the other thread hold or control. In a deadlock situation, the threads effectively become stuck and the program cannot make any progress.

Example:

Thread A and Thread B are both running concurrently and need two resources: Resource X and Resource Y.

• Thread A acquires Resource X.
• Thread B acquires Resource Y.

Now, both threads are in a “Hold and Wait” state:

• Thread A is holding Resource X and waiting for Resource Y.
• Thread B is holding Resource Y and waiting for Resource X.

Neither thread can proceed because they are each waiting for a resource held by the other, creating a circular dependency. This is a deadlock.

The Java Concurrency API is a set of high-level, thread-safe utility classes and interfaces introduced in Java to simplify and enhance concurrent and parallel programming. It provides tools for managing threads, synchronizing access to shared resources, and coordinating the execution of concurrent tasks. The Java Concurrency API was introduced in Java 5 (Java 1.5) as part of the Java platform’s ongoing efforts to support multi-threading and concurrent programming.

A thread pool in computing is a collection of pre-initialized threads that stand ready to execute tasks. This pool manages a queue of tasks to be executed alongside a set of worker threads, which handle the tasks in the queue. When a new task is introduced, it’s enqueued, and a thread from the pool is assigned to execute it. Once the thread completes the task, it reports back to the pool and becomes available for the next task. This approach to thread management and task execution offers several advantages over spawning a new thread for each task in terms of resource management, performance, and system stability.

Implementing Thread Pools in Java:

Java provides built-in support for thread pools through the java.util.concurrent package, which includes several classes and interfaces for managing a set of threads, such as Executor, ExecutorService, and ThreadPoolExecutor. Developers can utilize these to easily implement efficient, scalable thread management in their applications without having to manually manage thread life cycles.

In Java, the volatile keyword is used as a modifier for instance variables to indicate that their values may be changed by multiple threads concurrently. It ensures that the variable is always read from and written to the main memory, rather than from thread-specific caches, ensuring visibility across threads.

Example:

class SharedResource {
    private volatile boolean flag = false;

    public void setFlagTrue() {
        flag = true;
    }

    public boolean isFlagTrue() {
        return flag;
    }
}

In the above example, the flag variable is declared as volatile to ensure that changes made to it by one thread are immediately visible to other threads. The setFlagTrue() method sets the flag to true, and the isFlagTrue() method checks its value.

Explanation with example

Imagine you have a flag (like a red flag) in a park, and many kids (threads) are playing in the park. When one kid puts up the red flag, it’s a signal for everyone else to stop playing and pay attention.

In Java, when you declare a variable as volatile, it’s like putting up a red flag. It means that if one part of your program changes the value of that variable, all the other parts of your program will see that change right away, even if they are running at the same time. So, it helps make sure that everyone is on the same page and knows the latest value of that variable.

In the context of concurrent programming, synchronization and locks are both mechanisms used to control access to shared resources by multiple threads, ensuring data consistency and preventing race conditions. While they aim to solve similar problems, they do so in different ways and offer different levels of control and flexibility.

Synchronization

Synchronization in Java is a built-in mechanism that restricts access to resources by ensuring that only one thread can access a synchronized block of code at a time. It can be applied to methods or blocks of code within methods.

Locks

Locks provide a more flexible way to achieve synchronization, allowing more detailed control over lock acquisition, release, and the conditions under which locks are held. Java’s java.util.concurrent.locks package provides several lock implementations, including ReentrantLock, which offers advanced capabilities for thread synchronization.

Synchronization vs Lock

volatile, synchronized, and transient are three different keywords in Java used to modify the behavior of variables and methods in the context of multi-threading, data storage, and object serialization.

1). volatile

• volatile keyword is used with a variable to declare it as “volatile,”. It means its value may be changed by multiple threads concurrently.
• When a variable is declared as volatile, it ensures that any read or write operation on that variable is guaranteed to be visible to all threads. Means read value from the main memory.
• volatile does not provide atomicity for compound operations or mutual exclusion, so it is typically used for simple variables or flags that are accessed by multiple threads without complex operations.

Example

private volatile int counter = 0;

2). synchronized

• synchronized is a keyword used to create synchronized blocks and methods. It helps to control access to critical sections of code by multiple threads that is written within synchronized blocks and methods.
• When a block of code or method is marked as synchronized, only one thread can execute that block or method at a time, ensuring mutual exclusion.
• It is used for protecting shared resources, achieving thread safety, and preventing race conditions.

Example

//synchronized method
public synchronized void synchronizedMethod() {
    // Thread-safe code
}

//synchronized Block example

public void increment() {
     synchronized (this) { // Start of synchronized block
            count++;
     } // End of synchronized block
}

3). transient

• transient is used to indicate that a variable should not be included when an object is serialized.
• When an object is serialized (converted to a byte stream), the values of its non-transient fields are saved. Transient fields are not included in the serialized form and are set to their default values upon deserialization.
• It is often used for variables that should not be serialized, such as temporary or derived values.

Example

private transient int tempValue;

In summary:

• volatile is used for variables that can be changed by multiple threads and ensures visibility but not atomicity or mutual exclusion.
• synchronized is used to create synchronized blocks or methods that provide mutual exclusion for thread-safe access to shared resources.
• transient is used to mark variables that should not be serialized when an object is converted to a byte stream.

In Java, both Runnable and Callable are interfaces that allow you to define tasks that can be executed by threads.

Runnable

• Runnable is a functional interface introduced in Java. It defines a single method: void run(), which represents the task to be executed.
• Runnable tasks do not return a result. The run() method has a void return type, which means it cannot return a value or throw checked exceptions.
• Runnable tasks are often used for simple, fire-and-forget tasks that do not need to return a result, such as performing background calculations, logging, or updating a shared data structure.

Callable

• Callable is also a functional interface introduced in Java. It defines a single method: V call() throws Exception, where V represents the type of the result to be returned, and it can throw checked exceptions.
• Callable tasks return a result, and you can specify the type of the result by parameterizing the Callable interface with a type (e.g., Callable<Integer>).
• Callable tasks are used when you need to perform a task that produces a result and may throw exceptions. Examples include performing computations, making network requests, or querying databases.
• Callable tasks are typically executed using an ExecutorService (e.g., ThreadPoolExecutor). They are also executed asynchronously, and you can obtain the result of a Callable task using a Future object, which allows you to retrieve the result once the task is complete.

Example Of Runnable and Callable

import java.util.concurrent.*;

public class RunnableVsCallableExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // Runnable example
        Runnable runnableTask = () -> {
            System.out.println("Runnable task is running.");
        };
        Thread runnableThread = new Thread(runnableTask);
        runnableThread.start();

        // Callable example
        Callable<Integer> callableTask = () -> {
            System.out.println("Callable task is running.");
            return 42;
        };
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(callableTask);
        int result = future.get();
        System.out.println("Callable task result: " + result);
        executor.shutdown();
    }
}

Both the synchronization and volatile keywords in Java are used in multi-threaded programming to address concurrency-related issues.

wait(): When a thread calls wait() on an object, it releases the lock associated with that object, allowing other threads to acquire the lock and execute synchronized methods or blocks on the same object.

Example

synchronized (sharedObject) {
    while (!condition) {
        sharedObject.wait(); // Release the lock and wait
    }
    // Perform some action when the condition is met
}

notify(): notify() method is used to wake up one waiting thread that is blocked by calling wait() method.

synchronized (sharedObject) {
    // Modify some shared state
    sharedObject.notify(); // Wake up one waiting thread
}

notifyAll(): notifyAll() method is used to wake up all waiting threads that are blocked.

synchronized (sharedObject) {
    // Modify some shared state
    sharedObject.notifyAll(); // Wake up all waiting threads
}

Garbage collection in Java is the process by which the Java Virtual Machine (JVM) automatically manages the memory used by a Java application. It involves identifying and reclaiming memory occupied by objects that are no longer reachable.

And this non reachable objects are no longer needed to Java programs. Garbage collection helps prevent memory leaks and ensures efficient memory utilization in Java programs.

Example

public class GarbageCollectionExample{  
    public void finalize(){
        System.out.println("Object is garbage collected");
    }  
    public static void main(String args[]){  
        GarbageCollectionExample s1=new GarbageCollectionExample();  
        GarbageCollectionExample s2=new GarbageCollectionExample();  
        s1=null;  
        s2=null;  
        System.gc();  
    }  
}  

Output

Object is garbage collected
Object is garbage collected

Garbage collection (GC) is an automatic memory management feature present in various programming languages, including Java, C#, Python, and others. Its primary purpose is to reclaim memory occupied by objects (or data structures) that are no longer in use by a program, thus preventing memory leaks and ensuring the efficient utilization of available memory resources. Garbage collection plays a crucial role in managing the lifecycle of objects dynamically, freeing developers from the manual task of memory allocation and deallocation.

Key Purposes of Garbage Collection in Memory Management:

• Automatic Memory Reclamation: GC automates the process of identifying and freeing unused memory, reducing the risk of memory leaks that can occur in manual memory management and potentially lead to application crashes or performance degradation over time.
• Optimization of Available Memory: By reclaiming memory from objects that are no longer needed, GC optimizes the use of available memory, ensuring that applications can continue to allocate memory for new objects and operate efficiently.
• Enhancing Program Stability and Safety: Automatic garbage collection minimizes errors related to memory management, such as double frees, dangling pointers, and incorrect deallocation, which can lead to undefined behavior, security vulnerabilities, and program instability.
• Simplification of Programming: GC abstracts away the complexity of manual memory management, allowing developers to focus more on the business logic of their applications rather than on the intricacies of allocating and freeing memory. This simplification can lead to more readable and maintainable code.
• Enabling Complex Data Structures: With automatic memory management, programmers can create and use complex, dynamic data structures without worrying about the lifecycles of the memory that those structures occupy. This freedom can encourage the development of more sophisticated algorithms and applications.

The Java Virtual Machine (JVM) determines that an object is eligible for garbage collection primarily based on its reachability — specifically, whether there are any live references to that object from the application’s roots. The roots include static variables, local variables, active threads, and other special references within the JVM. An object becomes eligible for garbage collection when it cannot be reached through any reference chain starting from these roots.

In addition to reachability, the JVM also considers other factors for garbage collection eligibility, like whether an object’s finalize() method has been invoked (if it overrides Object.finalize()). After finalization, if no references to the object are created, it becomes eligible for reclamation.

Garbage collection in Java can be categorized into three main types based on the scope and purpose of the collection:

Minor Garbage Collection (Young Generation):

• Scope: Focuses on the youngest generation (also known as the “young” or “eden” generation) of objects in the Java heap.
• Purpose: Identifies and collects short-lived objects that are likely to become garbage quickly, leaving behind longer-lived objects in the older generation.
• Algorithm: Typically uses fast, low-pause-time algorithms like the “copying” or “semi-space” collector.
• Frequency: Occurs more frequently because young objects tend to have shorter lifespans.

Major Garbage Collection (Old Generation):

• Scope: Targets the older generation of objects in the heap, which includes objects that have survived one or more minor garbage collections.
• Purpose: Reclaims memory occupied by objects that have been in memory for a longer time and are less likely to become garbage.
• Algorithm: Employs more comprehensive and potentially slower algorithms like the “mark-sweep-compact” collector.
• Frequency: Occurs less frequently compared to minor garbage collection.

Full Garbage Collection:

• Scope: Involves the entire heap, including both young and old generations.
• Purpose: Reclaims memory across the entire heap, including the young and old generations, by identifying and collecting all unreachable objects.
• Algorithm: Utilizes comprehensive garbage collection algorithms to reclaim memory globally.
• Frequency: Occurs infrequently and usually when the JVM determines that there is a shortage of memory or after multiple attempts at minor and major garbage collection have not freed enough memory.

The Java Virtual Machine (JVM) offers several garbage collectors (GCs) designed to cater to different types of applications, from small applications running on single-threaded environments to large, server-side applications requiring high throughput and low latency. Each garbage collector has its own approach to managing memory and reclaiming unused space.

Types of Garbage collection

1. Serial Garbage Collector

• Type: It’s a single-threaded garbage collector, using just one CPU or thread for GC activities.
• Operation Mode: It performs the garbage collection for the Young Generation and the Old Generation (Tenured Generation) serially.
• Use Case: It’s best suited for single-threaded environments and applications with small data sets where pause time is not a critical concern, such as standalone desktop applications or simple tools.
• Pros: Simplicity and minimal CPU overhead, making it efficient for small applications.
• Cons: Not suitable for multi-threaded applications or servers as it can cause noticeable pauses during garbage collection.

2. Parallel Garbage Collector (Throughput Collector)

• Type: A multi-threaded garbage collector that uses multiple threads for Young Generation garbage collection.
• Operation Mode: Garbage collection is performed in parallel to improve throughput. However, it still stops all application threads during garbage collection phases (Stop-The-World events).
• Use Case: Optimized for throughput and performance, making it suitable for multi-threaded applications, such as backend services, where short GC pause times are acceptable but overall throughput is critical.
• Pros: Higher throughput and better CPU utilization than the serial collector.
• Cons: Can still experience significant pause times for Old Generation garbage collection.

3. Concurrent Mark Sweep (CMS) Garbage Collector

• Type: Targets shorter garbage collection pauses by doing most of its work concurrently with the application threads.
• Operation Mode: It marks live objects and sweeps up the unreferenced objects without stopping the application threads (concurrently). However, it still requires occasional pauses, especially during the initial and final mark phases.
• Use Case: Designed for applications that require low pause times, such as interactive web applications.
• Pros: Reduces pause times compared to serial and parallel collectors.
• Cons: Can lead to more CPU overhead and might encounter fragmentation issues.

4. Garbage First (G1) Garbage Collector

• Type: A server-style garbage collector aimed at multi-processor machines with large memory space.
• Operation Mode: Divides the heap into regions and manages them based on set performance goals. It performs garbage collection in a way that prioritizes regions with the most garbage first, hence the name.
• Use Case: Suitable for applications running on multi-core machines with large heaps, where predictable pause times are necessary.
• Pros: Offers more predictable pause times than CMS and can efficiently manage larger heaps. It aims to provide a good balance between throughput and pause times.
• Cons: Might require tuning to achieve optimal performance. It’s more complex than the other collectors.

The Young Generation (also known as the “nursery”) in the Java Virtual Machine (JVM) refers to the part of the heap where newly created objects are allocated. Garbage collection in the Young Generation is crucial because most objects are short-lived, and frequent collection helps reclaim memory quickly and efficiently. The process of garbage collection in the Young Generation is designed to take advantage of this “weak generational hypothesis,” which posits that most objects die young.

The Process of Young Generation Garbage Collection:

1. Allocation: New objects are allocated in the Young Generation, which is typically divided into three parts: one Eden space and two Survivor spaces (S0 and S1).
2. Minor GC (Garbage Collection): When the Eden space becomes full, a Minor GC is triggered. Objects that are still alive are moved to one of the Survivor spaces (S0 or S1), assuming they don’t already reside in a Survivor space. If an object is already in a Survivor space and survives garbage collection, it may be moved to the other Survivor space or, based on its age, promoted to the Old Generation.
3. Age Threshold: Objects in the Young Generation have an age associated with them, which is incremented every time they survive a Minor GC. Once an object reaches a certain age threshold, it is promoted to the Old Generation to avoid the cost of being copied between Survivor spaces. The age threshold is adjustable and can be tuned based on the application’s behavior.
4. Copying Algorithm: The garbage collection process in the Young Generation is typically implemented using a copying algorithm. Live objects are copied from Eden to a Survivor space, or from one Survivor space to the other. Because only live objects are copied and because most objects die young, the copying process is efficient as it doesn’t have to deal with the entire set of objects in the Young Generation.
5. Efficiency: The efficiency of the Young Generation garbage collection comes from the fact that it deals with a relatively small portion of the heap and that it can quickly clear out space by moving the relatively few surviving objects. This process is much faster than scanning the entire heap, which includes the Old Generation.

The Old Generation (also known as the Tenured Generation) in the Java Virtual Machine (JVM) is the part of the heap that holds objects that have survived multiple garbage collection cycles in the Young Generation. Because objects in the Old Generation are expected to live longer, garbage collection in this area (also known as a Major GC or Full GC) is handled differently and less frequently than in the Young Generation. The goal is to efficiently reclaim space from objects that are no longer in use without excessively impacting application performance.

The Process of Old Generation Garbage Collection:

1. Triggering Conditions: Major GC is typically triggered when the Old Generation becomes full or when certain thresholds are met. It can also be triggered by explicit calls to System.gc(), though this is generally discouraged due to its unpredictable impact on performance.
2. Marking Phase: The garbage collector starts by identifying which objects are still reachable. It begins from a set of root references (like static fields, thread stacks, etc.) and marks all objects that can be transitively reached from these roots. Unreachable objects are considered eligible for garbage collection.
3. Sweeping/Deleting Phase: After marking live objects, the collector sweeps through the Old Generation, deallocating memory occupied by unmarked (unreachable) objects. This phase effectively cleans up memory used by dead objects.
4. Compaction Phase (Optional but common in many collectors): To combat memory fragmentation, some garbage collectors will compact the remaining objects, moving them so they occupy a contiguous block of memory. This makes future allocations more efficient but adds overhead to the garbage collection process.

A memory leak is a situation in computer programming where a program fails to release memory (RAM) that it has allocated but is no longer in use. As a result, the program consumes increasing amounts of memory over time, eventually leading to performance degradation or even a program crash.

Memory leaks can occur in languages that do not have automatic memory management (e.g., C and C++) and in languages with garbage collection (e.g., Java and C#) when references to objects are unintentionally retained, preventing the garbage collector from reclaiming the memory.

Some common scenarios

• Failure to Release Allocated Memory: If a program allocates memory using functions like malloc() but forgets to call free() to release that memory, a memory leak occurs.
• Unclosed Resources: Memory leaks can occur when resources other than memory, such as file handles, database connections, or network sockets, are not properly closed or released after use.

Lambda expression allow us to define and use anonymous functions in a more concise and expressive way. Lambda expressions make it easier to represent instances of single-method interfaces (functional interfaces) using a shorter and more readable syntax.

Lambda expressions have a compact syntax, consisting of parameter list, an arrow (->), and a body. The body can be an expression or a block of statements.

Syntax

(parameters) -> expression
(parameters) -> { statements }

Functional interfaces play a crucial role in Java when using lambda expressions. They are closely tied to lambda expressions and are a fundamental concept in the context of functional programming in Java.

The primary role of functional interfaces is to serve as a target type for lambda expressions. Lambda expressions provide a way to create instances of functional interfaces by implementing the single abstract method defined by the interface. This enables the use of lambda expressions to define concise and expressive code for specific behaviors.

Here’s how functional interfaces and lambda expressions work together:

Functional Interface Declaration:

@FunctionalInterface
interface MyFunctionalInterface {
    void doSomething(); // The single abstract method
}

Using Lambda Expressions:

MyFunctionalInterface myLambda = () -> {
    // Implementation of the doSomething method
    System.out.println("Doing something...");
};

Invoking Lambda Expressions:

myLambda.doSomething(); // Invoking the lambda expression

Built-in functional interfaces like Consumer, Supplier, and Predicate are part of the java.util.function package in Java. These functional interfaces are widely used in Java for various functional programming tasks, especially when working with collections, streams, and lambdas.

Overview of these built-in functional interfaces:

Consumer

• Purpose: The Consumer interface represents an operation that accepts an input value, performs an action with that value, and returns no result.
• Method: It has a single abstract method void accept(T t) that takes an argument of type T and performs some action on it.
• Available in import java.util.function.*;
• Example: You can use Consumer to iterate over a collection and apply an action to each element.

import java.util.function.Consumer;
public class Main {
    public static void main(String[] args) {
        Consumer<String> printUpperCase = str -> System.out.println(str.toUpperCase());
        printUpperCase.accept("interview Expert");
    }
}

Output

INTERVIEW EXPERT

Supplier

• Purpose: The Supplier interface represents a supplier of results, or in other words, a factory for creating objects. It does not accept any arguments but produces a value.
• Method: It has a single abstract method T get() that returns a result of type T.
• Example: You can use Supplier to generate values lazily.

import java.util.function.Supplier;
public class Main {
    public static void main(String[] args) {
        Supplier<Integer> randomNumberSupplier = () -> (int) (Math.random()*100);
        int randomValue = randomNumberSupplier.get();
        System.out.println(randomValue);
    }
}

Output

84

Predicate

• Purpose: The Predicate interface represents a boolean-valued function that tests a condition on an input and returns true or false.
• Method: It has a single abstract method boolean test(T t) that takes an argument of type T and returns a boolean result.
• Example: You can use Predicate to filter elements in a collection based on a condition.

import java.util.function.Predicate;
public class Main {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        boolean result = isEven.test(8);
        System.out.println(result);
    }
}

Output

true

Streams enable you to perform various data processing operations on collections of data, such as lists, arrays, or even I/O channels, using functional-style programming.

Streams offer a wide range of operations, including filtering, mapping, reducing, sorting, and more. These operations simplify common data manipulation tasks.

Characteristics and benefits of the Stream API

• Functional Programming
• Declarative Style
• Lazy Evaluation
• Pipelining
• Parallelism

Example of How to use the Stream API

import java.util.*;
public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
        names.stream()
                .filter(name -> name.startsWith("A"))
                .map(String::toUpperCase)
                .forEach(System.out::println);
    }
}

Output

ALICE

Streams in Java are designed to make data manipulation and processing more efficient and expressive. Three common operations you can perform on streams are filtering, mapping, and reducing data.

1). Filtering Data:

The filter operation allows you to select elements from a stream that match a given condition. It’s used to eliminate unwanted elements, leaving only those that satisfy the specified criteria.

Example

find the even number

import java.util.*;
import java.util.stream.*;
public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // Filter the even numbers
        List<Integer> evenNumbers = numbers.stream()
                                   .filter(n -> n % 2 == 0)
                                   .collect(Collectors.toList());
        evenNumbers.forEach(System.out::println);                       
    }
}

Output

2
4
6
8
10

2). Mapping Data:

The map operation transforms each element in a stream into another value. It’s useful when you want to apply a function to each element in a stream and create a new stream of transformed values.

Example

Find the length of each string in a list.

import java.util.*;
import java.util.stream.*;
public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());
        nameLengths.forEach(System.out::println);                       
    }
}

Output

5
3
7

3). Reducing Data:

The reduce operation is used to combine the elements of a stream into a single result. It allows you to perform aggregation operations like summing, finding the maximum, or concatenating strings.

Example

import java.util.*;
public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream()
                .reduce(0, (a, b) -> a + b); 
        System.out.println("sum = "+ sum);
    }
}

Output

sum = 15

Default methods, also known as defender methods, are a feature introduced in Java 8 to allow interfaces to have method implementations.

Prior to Java 8, interfaces could only declare abstract methods, which meant that any class implementing an interface had to provide concrete implementations for all of its methods. Default methods provide a way to add new methods to existing interfaces without breaking backward compatibility with classes that implement those interfaces.

Example

import java.util.*;
interface DefaultImplementation{
    int data = 5;
    default int defaultData(){
        return data;
    }
}
public class Main implements DefaultImplementation{
    public static void main(String[] args) {
        Main main = new Main();
        System.out.println("sum = "+ main.defaultData());
    }
}

Output

sum = 5

The Optional class in Java is a container class introduced in Java 8 that represents an optional value, meaning it may or may not contain a non-null value.

It’s designed to help avoid NullPointerExceptions by providing a way to handle cases where a value may be absent.

1. Creating Optional Objects:

You can create an Optional object using the factory methods of, ofNullable, or by using empty.

Optional<String> emptyOptional = Optional.empty(); // Represents an empty optional.
Optional<String> nonEmptyOptional = Optional.of("Hello"); // Represents a non-null value.
Optional<String> nullableOptional = Optional.ofNullable(null); // Represents a potentially null value.

2. Accessing Values:

You can use get() method to retrieve the value if it exists, but be cautious because it can throw a NoSuchElementException if the value is absent.

Optional<String> optional = Optional.of("Hello");
String value = optional.get(); // Gets the value if present

3. Checking for Value Presence:

You can use methods like isPresent() to check if a value is present in the Optional.

Optional<String> optional = Optional.of("Hello");
boolean isPresent = optional.isPresent(); // Checks if a value is present

4. Handling Absent Values:

To handle cases where a value is absent, you can use methods like orElse or orElseGet to provide a default value or a value from a supplier.

Optional<String> optional = Optional.empty();
String result = optional.orElse("Default Value"); // Provides a default value

Optional<String> optional = Optional.empty();
String result = optional.orElseGet(() -> generateDefaultValue()); // Provides a default value using a supplier

5. Conditional Execution:

You can use methods like ifPresent to execute a specific action when a value is present.

Optional<String> optional = Optional.of("Hello");
optional.ifPresent(value -> System.out.println("Value is present: " + value));

6. Transforming Values:

You can apply transformations to the contained value using methods like map.

Optional<String> optional = Optional.of("Hello");
Optional<Integer> lengthOptional = optional.map(String::length); // Transforms the value

7. Chaining Operations:

You can chain multiple Optional operations together to perform a series of actions.

Optional<String> optional = Optional.of("Hello");
int result = optional.map(String::length)
                    .filter(len -> len > 5)
                    .orElse(0); // Chained operations

8. Avoiding NullPointerExceptions:

Using Optional can help avoid NullPointerExceptions when dealing with potentially null values.

String potentiallyNullValue = null;
Optional<String> optional = Optional.ofNullable(potentiallyNullValue);

9. Using ifPresentOrElse (Java 9 and later):