Java 8 Features

Java 8 introduced several significant features that marked a major shift in Java programming paradigms, including:

Lambda Expressions: These provide a clear and concise way to represent one method interface using an expression. They facilitate functional programming by allowing code to be more concise and readable.
Stream API: Introduced for bulk data operations on collections, the Stream API supports functional-style operations on streams of elements, such as map-reduce transformations.
New Date-Time API: Offers a comprehensive model for date and time that fixes the flaws of the old java.util.Date and java.util.Calendar.
Default Methods in Interfaces: Enable the addition of new methods to interfaces without breaking the classes that implement these interfaces.
Optional Class: Helps in avoiding null pointer exceptions and improves code quality by providing a more functional style of dealing with null values.

Changes in Java 17

Java 17, being an LTS release, brought several important features and enhancements:

Sealed Classes: Limit the classes that can extend or implement them, thus providing a way to control inheritance more strictly.
Pattern Matching for instanceof: Simplifies conditional extraction of components from objects, making the code more readable and less error-prone.
Strong Encapsulation of JDK Internals: Restricts access to internal APIs to improve security and maintainability, encouraging the use of standard APIs.

Can Java Abstract Class Have a Constructor?

Yes, an abstract class in Java can have a constructor. While you cannot instantiate an abstract class directly, its constructor can be invoked when a concrete subclass is created, allowing for the proper initialization of fields in the abstract class.

What is a Static Initializer?

A static initializer is a block of code in a Java class that is executed when the class is first loaded into the JVM. It is typically used to perform static variable initialization or static setup operations. Defined with the static keyword, it runs only once per class, regardless of how many objects of that class are created.

How Static Variables Are Stored in Memory

Static variables are stored in the heap memory but within the class section of the heap. They are created when the class is loaded by the JVM and destroyed when the program ends or the class is unloaded. These variables are shared among all instances of the class.

How `get()` Works in `HashMap`

The get() method in HashMap retrieves the value associated with a specific key. It calculates the hash code of the key and finds the bucket where the key-value pair is stored. If multiple entries are in the same bucket (due to hash collisions), it iterates through the list of entries to find the matching key based on equals() method comparison.

How Custom Object Works in `HashMap`

For custom objects to be used as keys in a HashMap, you must override both hashCode() and equals() methods. The hashCode() method determines the bucket location for storing the key-value pair. The equals() method ensures that keys are uniquely identified, even if they are stored in the same bucket.

Difference Between Stack Memory and Heap Memory

Stack Memory: This is used for static memory allocation and the execution of threads. It stores primitive values and references to heap objects. Each thread has its own stack that is created when the thread is started. The stack is LIFO (Last In First Out) structured.
Heap Memory: This is used for dynamic memory allocation for Java objects and JRE classes. Objects are created on the heap, and heap memory is shared among all threads. Garbage Collection operates primarily on the heap to free up memory used by objects that are no longer reachable.

Can We Call a Constructor from Another Constructor

Yes, in Java, you can call one constructor from another in the same class using this() reference. This is known as constructor chaining and helps to reduce code duplication.

What Happens If We Override `hashCode` Method and Return 100

If you override the hashCode() method in a class and make it always return 100, then all instances of that class will have the same hash code. Consequently, when these instances are added as keys in a HashMap, they will be placed in the same bucket, leading to a linked list in that bucket. This can degrade the performance of the HashMap from constant time (O(1)) to linear time (O(n)) for operations like get() and put(), especially if there are many entries.

Overriding the `equals` Method in `HashMap`

In Java, the HashMap uses the equals() method to determine if two keys are the same. When you put a key into a HashMap, it checks if the same key already exists using the equals() method. If you override this method, it changes how keys are compared. For example, if you override equals() to compare only a part of an object, only that part will be considered when checking for existing keys in the map.

Use of `volatile` and `Atomic`

volatile: The volatile keyword in Java is used to indicate that a variable's value will be modified by different threads. Declaring a variable volatile ensures that its value is read from and written to main memory, thus avoiding caching of the value in individual threads' caches.
Atomic: Classes in the java.util.concurrent.atomic package support lock-free thread-safe programming on single variables. Atomic classes like AtomicInteger or AtomicReference provide methods for performing atomic operations on a variable, which are useful in high-concurrency applications to maintain consistency without using synchronization.

How `HashMap` Works Internally

HashMap in Java works on the principle of hashing. It stores key-value pairs in an array-based structure. Each key-value pair is stored as an entry in a "bucket" determined by hashing the key. If two keys have the same hashcode, they are stored in the same bucket as a linked list (or in a balanced tree if there are too many items in the same bucket in Java 8 and later). This mechanism allows for constant-time performance for the basic operations (get and put), assuming the hash function disperses the elements properly among the buckets.

Lambda Function

A lambda function is a short block of code that takes in parameters and returns a value. Lambda functions are similar to methods, but they do not need a name and can be implemented right in the body of a method. They are often used to implement simple event-listeners/callbacks, or in any place where a function needs to be implemented quickly. The interviewer may ask follow-up questions on Callable and Runnable

Root Class of Exception

In Java, the root class for exceptions is Throwable. It is the superclass of all errors and exceptions in the Java language. Exception and Error are direct subclasses of Throwable.

Final and Abstract Methods and Classes

Final Class: A final class cannot be subclassed. This is done to prevent any inheritance from the class.
Abstract Class: An abstract class cannot be instantiated on its own and must be subclassed to be used. Abstract classes are designed to be base classes.
Final Method: A final method cannot be overridden by subclasses. This is used to prevent a specific method from being changed.
Abstract Method: An abstract method has no implementation in the class that declares it and must be implemented by subclasses.

Default Values of Class and Function Members

Class Member int: If an int variable is a member of a class and not explicitly initialized, it gets a default value of 0.
Function Member int: If an int variable is declared inside a method, it must be explicitly initialized before use; it has no default value and will result in a compile-time error if used uninitialized.

9. How Garbage Collector Works in Java

Java’s Garbage Collector (GC) works by identifying and disposing of objects that are no longer needed by a program. It primarily uses the “mark-and-sweep” algorithm, where it first “marks” objects that are reachable through a set of active references, and then “sweeps” away objects that are not marked (i.e., unreachable), freeing up memory.

Shallow Copy and Deep Copy

Shallow Copy: A shallow copy of an object copies the values of the object’s properties as they are, including references to other objects. If the object contains references to other objects, the references are copied but the actual objects are not, meaning multiple references to the same object can exist.
Deep Copy: A deep copy of an object will duplicate everything. This means creating new instances for each element that the object references, thus no two references point to the same object.

Association in Java

Association is a fundamental concept in object-oriented programming (OOP) that represents a relationship between objects. It establishes a connection between objects without creating a strong dependency (inheritance). Here are common ways to create associations in Java:

Has-A Relationship: One object holds a reference to another object. This can be implemented using instance variables that store references to other objects.

public class Library {
    private List<Book> books;

    public Library(List<Book> books) {
        this.books = books;
    }

    // ... methods to access and manage books
}

public class Book {
    // ... book properties
}

Advantages of Stream API

The Java Stream API, introduced in Java 8, provides several advantages:

Functional-style operations: Streams support various operations and expressions that can be pipelined to produce the desired result. This functional style of programming leads to more readable, compact, and less error-prone code.
Parallel execution support: Streams can be processed in parallel easily using the parallelStream() method which can lead to significant performance improvements in multi-core environments.
Improved code maintenance: Stream operations help in keeping the code clean and concise, thereby improving code readability and maintenance.
Less boilerplate: Stream API reduces the need for verbose constructs like loops and conditional logic when performing operations on collections.

How Stream API Works Internally

Internally, the Stream API works based on a few core components:

Source: A Stream is created from data sources like collections, arrays, or generators.
Intermediate Operations: These operations (e.g., filter, map) transform the data elements without necessarily consuming the entire stream.
Terminal Operation: This operation (e.g., count, collect) triggers the processing and returns a result or performs a side effect.
Lazy Evaluation: Intermediate operations aren’t executed until a terminal operation is called, promoting efficiency.
Stateful vs. Stateless: Some intermediate operations can impact the stream state (e.g., distinct), while others like map are stateless.

Streams use internal iteration: the iteration is abstracted away through operations that you define with lambda expressions. In case of parallel streams, the operations are split into multiple segments to be executed in parallel, then the results are combined accordingly.

Merging Two Lists Using Streams

Yes, you can merge two lists using Java Streams. Here is a simple way to do it using the Stream.concat() method:


List<String> list1 = List.of("a", "b");
List<String> list2 = List.of("c", "d");
List<String> mergedList = Stream.concat(list1.stream(), list2.stream())
                                .collect(Collectors.toList());

This code snippet will merge list1 and list2 into mergedList.

Creating a Thread Pool in Java

In Java, thread pools can be created using the Executors framework. Here’s how you can create a fixed thread pool:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // Creating a fixed thread pool with 5 threads
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}
class WorkerThread implements Runnable {
    private String command;
    public WorkerThread(String s) {
        this.command = s;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Command = " + command);
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End.");
    }
    private void processCommand() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

This example shows how to create a thread pool with 5 threads and submit 10 tasks to it. Each task is an instance of WorkerThread which simply prints out its ID, simulates doing work by sleeping, and then terminates.

Different Ways to Create Threads in Java

In Java, there are primarily two ways to create a thread:

Extending the Thread class: You create a new class that extends Thread and overrides the run() method. You then create an instance of this class and call the start() method to run the new thread.

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running");
    }
}

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

Implementing the Runnable interface: This involves implementing the Runnable interface and defining the run() method. You then pass an instance of the class implementing Runnable to a Thread object and start the thread.

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread running");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

Using Runnable is more flexible as it allows you to extend another class as well.

How Multithreading Works in Java

Multithreading in Java allows multiple threads to run concurrently, providing a means of improving application performance through parallelism. Each thread in Java is an independent path of execution within a program. Each thread has its own stack but shares the same memory space (heap) and resources with other threads. The JVM and the underlying operating system manage how threads are scheduled and executed.

What is a Race Condition and How to Handle It

A race condition occurs when two or more threads in a multithreaded application access a shared resource simultaneously and at least one thread modifies the resource. If the timing of the threads’ scheduling causes incorrect results, this is known as a race condition.

To handle race conditions, Java provides several mechanisms:

Synchronization: You can synchronize methods or blocks of code, ensuring that only one thread at a time can execute the synchronized code.

public synchronized void increment() {
    count++;
}

Locks: Java provides explicit lock objects in the java.util.concurrent.locks package, which can offer more sophisticated thread synchronization.

Lock lock = new ReentrantLock();
lock.lock();
try {
    count++;
} finally {
    lock.unlock();
}

Atomic Variables: For simple atomic operations on single variables, you can use classes from the java.util.concurrent.atomic package like AtomicInteger.

AtomicInteger count = new AtomicInteger();
count.incrementAndGet();

How Many Garbage Collectors Are There in Java

Java has several types of garbage collectors, which vary based on different algorithms and are optimized for various kinds of applications and hardware. Some of the notable garbage collectors in the JVM include:

Serial Garbage Collector: Uses a single thread for garbage collection. Suitable for applications with small data sets.
Parallel Garbage Collector (Throughput Collector): Uses multiple threads to manage young generation memory, designed for multi-threaded systems.
Concurrent Mark Sweep (CMS) Collector: Minimizes pauses by doing most of the garbage collection work concurrently with the application threads.
G1 Garbage Collector: Designed for large heap sizes, it divides the heap into regions and manages them individually, aiming to systematically reduce pause times.
Z Garbage Collector (ZGC): A scalable low-latency garbage collector.
Shenandoah: Focuses on reducing garbage collection pause times by performing more evacuation work concurrently with the running Java threads.

Different JVM implementations might support different garbage collectors, and new ones can be added or old ones deprecated over time, so it’s useful to refer to the latest JVM documentation or runtime options to see which collectors are available and suitable for your application’s needs.

JVM Warm-up

The JVM warm-up refers to a process where the Java Virtual Machine (JVM) optimizes the performance of a Java application by compiling frequently executed (“hot”) code paths into native machine code using a Just-In-Time (JIT) compiler. Over time, this allows the JVM to run the application more efficiently as more optimizations are applied based on actual runtime behavior.

Optimizing Java Code

Optimizing Java code involves several strategies:

Code Profiling and Hotspot Analysis: Use profiling tools to identify bottlenecks and optimize these critical sections.
Algorithm Optimization: Use more efficient algorithms or data structures where applicable.
Avoiding Excessive Object Creation: Reuse objects where possible, and avoid unnecessary object creation within loops.
Concurrency and Multithreading: Use concurrent programming to leverage multi-core processors.
Reducing Memory Usage: Manage memory wisely to avoid excessive garbage collection, which can halt application performance.
Optimizing Loops: Minimize the work inside loops and avoid calling methods repeatedly within loop iterations.
Using Native Libraries: For critical sections of code, consider using native implementations.

Difference Between Callable and Runnable

Runnable: An interface that is intended to be executed by a thread, defined with a single method run(), which does not return a result and cannot throw checked exceptions.
Callable: An interface similar to Runnable but with enhancements. It defines a single method call() which can return a result and throw checked exceptions. The Callable interface is useful when you want a task to return a result after execution, and it is often used with ExecutorService which can return a future representing the pending results.

AVL Tree and Its Use Cases

An AVL tree is a type of self-balancing binary search tree where the height of the two child subtrees of any node differ by no more than one. If at any time they differ by more than one, rebalancing is done to restore this property. AVL trees are used in situations where frequent insertions and deletions are involved, and you need to maintain a sorted order for quick lookups, deletions, and insertions. They are widely used in memory-bound applications where data must remain sorted, and extensive tree reorganization is costly.

Best Case and Worst Case Scenario of Linear Search

Best Case: The best case occurs when the target element is the first element of the array. The complexity in this scenario is O(1).
Worst Case: The worst case occurs when the target element is not in the array or happens to be the last element. In these cases, the complexity is O(n), where n is the number of elements in the array.

Pre-order and Post-order in Data Structures

In the context of tree data structures, these terms refer to types of depth-first traversal:

Pre-order Traversal: In this traversal method, the nodes are recursively visited in the following order: root, left subtree, right subtree. This is useful for creating a copy of the tree.
Post-order Traversal: In this method, the nodes are recursively visited in the following order: left subtree, right subtree, root. This is useful for deleting or freeing nodes and space of the tree.

Executor Thread and the Submit Method

The Executor framework (specifically the ExecutorService interface) in Java is a framework that simplifies the execution of tasks in asynchronous mode. It abstracts away the details of thread management and task scheduling. The submit() method:

Takes a Callable or Runnable object, executing it asynchronously.
Returns a Future object, which can be used to check the status of the task and retrieve the result (for Callable tasks).

The ExecutorService provides a way to manage a pool of threads and assign them tasks that implement Runnable or Callable, improving resource management and application performance.

If you have any more questions or need further explanations on any of these topics, feel free to ask!