Top 100 Java Interview Questions and Answers

Q17) Explain static variable in Java?

Ans-

Mostly the static keyword is used to make the variable or method of a given class available / accessible for other Classes and Objects.

Static variables are the variables that once declared then a single copy of that variable is created and shared among all objects at the class level.

When we declare a field static, exactly a single copy of that field is created and shared among all instances of that class.

It doesn’t matter how many times we instantiate a class. There will always be only one copy of static field belonging to it. The value of this static field is shared across all objects of either the same class.

From the memory perspective, static variables are stored in the heap memory area.

Q18) Can the main method be Overloaded in Java?

Ans-

Yes. It is possible to overload the main method. We can create as many overloaded main methods we want. However, JVM has a predefined calling method that JVM will only call the main method with the definition of – 

public static void main(string[] args)

Q19) How to Read and Write Text File in Java?

Ans-

Q20) Explain final, finally and finalize in Java.

Ans-

The similarity among final, finally, and finalize is – all are reserved keywords. Which means, we cannot create variable with such names.

Now, let’s understand that, what are the usage of final, finally, and finalize –

final keyword :

final (lowercase) is a reserved keyword in Java. We can’t use it as an identifier, as it is reserved.

We can use final keyword with variables, methods, and also with classes. The final keyword in Java has a different meaning in different scenarios. Based upon whether we are using final keyword with variable, class, or methods.

Using final with Variables:
The value of the variable cannot be changed once initialized. If we declare any variable as final, we can’t modify its contents since it is final, and if we modify it then we get Compile Time Error.

Using final with Class:
The class cannot be subclassed. Whenever we declare any class as final, it means that we can’t extend that class or that class can’t be extended, or we can’t make a subclass of that class.

If a class is declared as final then by default all of the methods present in that class are automatically becomes final, But variables are not. 

Using final with Method:
The method cannot be overridden by a subclass. Whenever we declare any method as final, then it means that we can’t override that method. 

// An example of final keyword - 

class FirstLogicalClass {

	final void log() {}

	public static void main(String[] args)
	{
		// ...
	}
}

class SecondLogicalClass extends FirstLogicalClass {

	// Here we get compile time error
	// since can't extend log() since it is final.
	void log() {}

}

finally keyword :

Just as final is a reserved keyword, so in the same way finally is also a reserved keyword in Java i.e, we can’t use it as an identifier. The finally keyword is used in association with a try/catch block

The finally keyword guarantees that a section of code will be executed at any cost, even if an exception is thrown.

The finally block will be executed after the try-catch blocks, but before control transfers back to its origin. finally is executed even if try block has return statement.

class LogicalExample {

	public static void main(String[] args) {
 
        PrintWriter out = null;
        try {
            System.out.println("Entered try statement");
 
            // PrintWriter, FileWriter are classes in io package
            out = new PrintWriter(new FileWriter("OutFile.txt"));
        }
        catch (IOException e) {
            // Since the FileWriter in try block can throw IOException
        }
 
        // Following finally block cleans up and then closes the PrintWriter
        finally
        {
            if (out != null) {
                System.out.println("Closing PrintWriter");
                out.close();
            } else {
                System.out.println("PrintWriter not open");
            }
        }
    }
}

Q21) Explain the below Java program. What is the output of the program.?

Ans-

The Java program given by the interviewer –

import java.io.*; 

class LogicalDuniyaJavaInterview { 

	static int wish; 
    static boolean boolWish; 

	public static void main(String[] args) { 

            System.out.println("******** Output ********");

        if (wish==null)
            System.out.println("Good Morning!!");
        if (wish==0)
            System.out.println("Good Afternoon!!");
    
        if(boolWish==null)
            System.out.println("Happy New Year!!"); 
        if(boolWish==false)
            System.out.println("Marry Christmas!!"); 
	} 
}

Q22) What is transient keyword in Java?

Ans-

The transient keyword is primarily meant for ignoring fields during Java object serialization.

Serialization is the conversion of the state of an object into a byte stream. Serialization is the conversion of a Java object into a static stream (sequence) of bytes, which we can then save to a database or transfer over a network.

So, if we don’t want to save the value of a particular variable in database or in file, then the transient keyword can be used. When JVM comes across a transient keyword, it ignores the original value of the variable and saves the default value of that variable data type.

Example : Use of transient

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    static String country = "INDIA";
    private int age;
    private String name;
    transient int height;         // Using transient, to ignore it's value during Person object serialization process.

    // getters and setters
}

Q23) Explain the difference between the methods sleep() and wait() in Java?

Ans-

There are multiple difference between sleep() and wait() methods –

Q24) What are the differences between String and StringBuffer in Java?

Ans-

There are multiple difference between String and StringBuffer –

Q25) What are the differences between StringBuffer and StringBuilder in Java?

Ans-

There are multiple difference between StringBuffer and StringBuilder –

Q26) Explain : When to user String, StringBuffer, and StringBuilder?

Ans-

1. If the content is fixed and won’t change frequently then we should go for String.
2. If the content is not fixed and keep on changing but Thread Safety is required,
   then we should go for StringBuffer.
3. If the content is not fixed and keep on changing and Thread safety is not required,
   then we should go for StringBuilder.

Q27) What are differences between Shallow Copy, Deep Copy and Lazy Copy?

Ans-

A quick answer –

• In Shallow Copy, only fields of primitive data type are copied while the objects references are not copied.
• Deep copy involves the copy of primitive data type as well as object references. There is no hard and fast rule as to when to do shallow copy and when to do a deep copy.
• Lazy copy is a combination of both of these approaches.

An illustration –

An example with Code –

// Code illustrating shallow copy - 
public class LogicalEx { 

	private int[] array1; 

	// makes a shallow copy of values 
	public Ex(int[] array2) { 
		array2 = array1; 
	} 

	public void showData() { 
		System.out.println( Arrays.toString(array1) ); 
	} 
} 



public class LogicalUsesEx{ 

	public static void main(String[] args) { 
		int[] vals = {4,2,6}; 
		Ex e = new Ex(vals); 
		e.showData(); // prints out [4,2,6] 
		vals[0] = 14; 
		e.showData(); // prints out [14,2,6] 

		// Very confusing, because we didn't 
		// intentionally change anything about 
		// the object e refers to. 
	} 
} 

Now, let’s see an example of Deep copy –

// Code explaining deep copy 
public class LogicalEx { 
	
	private int[] array1; 

	// altered to make a deep copy of values 
	public Ex(int[] array2) { 
		data = new int[array2.length]; 
		for (int i = 0; i < array1.length; i++) { 
			array1[i] = array2[i]; 
		} 
	} 

	public void showData() { 
		System.out.println(Arrays.toString(data)); 
	} 
} 

public class LogicalUsesEx{ 

	public static void main(String[] args) { 
		int[] vals = {4,2,6}; 
		Ex e = new Ex(vals); 
		e.showData(); // prints out [4,2,6] 
		vals[0] = 14; 
		e.showData(); // prints out [4,2,6] 

	// changes in array values will not be 
	// shown in data values. 
	} 
} 

Q28) What is Stack memory vs Heap memory?

Ans-

JVM divides memory into stack and heap memory. Whenever we declare new variables and objects, call a new method, declare a String, or perform similar operations, JVM assigns memory to these operations from either Stack Memory area or Heap Space area.

Stack Memory :

• Access to Stack memory is in Last-In-First-Out (LIFO) order. Whenever we call a new method, a new block is created on top of the stack which contains values specific to that method, like primitive variables and references to objects.
• Variables inside the stack exist only as long as the method that created them is running.
• It’s automatically allocated and deallocated when the method finishes execution.
• If this memory is full, Java throws java.lang.StackOverFlowError.
• Access to this memory is fast when compared to heap memory.
• This memory is threadsafe, as each thread operates in its own stack.

Q29) What is the difference between the ‘throw’ and ‘throws’ keyword in Java?

Ans-

throw keyword:

The throw keyword in Java is used to explicitly throw an exception from a method or any block of code. We can throw either checked or unchecked exception.

The throw keyword is mainly used to throw custom exceptions. 

Example :

Here in below example, we are explicitly throwing an exception, due to which the statement with “main: Last Line” String, will not get printed.

// Java program that demonstrates the use of throw
class LogicalDuniyaThrowExample {

	// Java program to demonstrate working of throws
    public static void main(String args[])
    {
        try {
            System.out.println("First Line");

            if(true)
                throw new NullPointerException("Just for fun - Throwing Exception ");

            System.out.println("main : Last Line ");
        }
        catch (NullPointerException e) {
            System.out.println("Caught in main.");
            System.out.println("try-catch: Last Line");
        }
    }
}

Output :

First Line
Caught in main.
try-catch: Last Line

throws keyword:

The ‘throws’ keyword is used to tell the compiler that a method can throw some exception and I’m not handling that exception.

Q30) How to create a multi-dimensional array in Java?

Ans-

Multidimensional Arrays can be defined in simple words as array of arrays. Data in multidimensional arrays are stored in tabular form (in row major order). 

To create a multidimensional Array, follow the below syntax :

data_type[1st dimension][2nd dimension][]..[Nth dimension] array_name = new data_type[size1][size2]….[sizeN];

To create multidimensional Array, follow the below example :

Two dimensional array:
int[][] twoD_arr = new int[10][20];

Three dimensional array:
int[][][] threeD_arr = new int[10][20][30];

Q32) How to Throw and Catch Exceptions?

Ans-

This is one of the super important Java Interview Questions, and can be asked as – How to handle exceptions in Java?

Java creates an exception object putting some useful information inside it, whenever any error occurs while executing a code statement. The exception object contains a lot of debugging information such as method hierarchy, variable values, line number where the exception occurred, type of exception with some other information.

If an exception occurs in a method, the process of creating the exception object and handing it over to the runtime environment is called “throwing the exception”.

As the exception is thrown, the normal flow of the program gets stop and the Java Runtime Environment (JRE) tries to find the handler for the exception. Exception Handler is the block of code that can process the exception object.

• The logic to find the exception handler begins with searching in the method where the error occurred.
• If no appropriate handler is found, then it will move to the caller method.
• And so on.

Useful keywords to handle Exceptions –

Java by default verifies checked exceptions at compile-time. It’s the duty of Java compiler before compiling code and duty of a developer to fix them before executing. So, to handle Un-Checked Exceptions, we have try-catch mechanism. With try-catch mechanism, we have to work with some keywords –

Java provides specific keywords for exception handling purposes.

1. throw –
We know that if an error occurs, an exception object is getting created and then Java runtime starts processing to handle them.

Sometimes we might want to generate exceptions explicitly in our code. For example, in a Calculator program, we should throw exceptions to screen if the denominator is Zero, because dividing a number by Zero will throw ArithmeticException. Here, the throw keyword is used to throw exceptions to the runtime to handle it.

2. throws –
When we want to throw an exception in a method and NOT want to handle it, then we have to use the throws keyword in the method signature to let the caller program know the exceptions that might be thrown by the method.

The throws clause can be used with the main() method also.

3. try-catch :–
We use the try-catch block for exception handling in our code. try is the start of the block and catch is at the end of the try block to handle the exceptions. We can have multiple catch blocks after a try block.

The try-catch block can be nested too. The catch block requires a parameter that should be of type Exception or it’s sub-classes.

4. finally –
The finally block is optional and can be used only with a try-catch block. As we know, when an exception occurs, it halts the process of execution. But, we might have some resources open (Files / Databases) that will not closed during the exception raised, so we can use the finally block.

The finally block ALWAYS gets executed, whether an exception occurred or not.

Example :

The try-catch block is used to handle exceptions in Java. Here’s the syntax of try...catch block:

Syntax :

try {
  // code
}
catch(Exception e) {
  // code
}

Let’s say, we want to handle ArithmeticException, then we have to write try-catch like this –

class LogicalDuniyaMain {

  public static void main(String[] args) {

    try {

      // Code that generate exception
      int divideByZero = 5 / 0;
      System.out.println("Execution Completed");
    }
      // Code that catches ArithmeticException
    catch (ArithmeticException ex) {
      System.out.println("Catching ArithmeticException => " + ex.getMessage());
    }
  }
}

Output :

Catching ArithmeticException => / by zero

Q33) Will the finally block get executed when the return statement is written at the end of try block and catch block as shown below?

public int someMethod(int i){
   try{
       //some statement
       return 1;             // Return statement before finally block..
   }catch(Exception e){
       //some statement
       return 999;
   }finally{
       //finally block statements
   }
}

Ans-

finally block will be executed in this case as well. No matter, what exception is occurring, any return statement is mentioned or not, the finally block will be executed.

The only case where finally block is not executed is when it encounters ‘System.exit(..)’ method anywhere in try..catch block.

Q34) What is Constructor Chaining?

Ans-

Calling a constructor of a class from another constructor of same Class, is known as Constructor Chaining.

The concept of Constructor Chaining can be achieved using this keyword –

Example – with Illustration :

Q35) What is Multi-Threading in Java? How to create Thread in Java?

Ans-

Java support Multithreading. It is a feature that allows executing two or more parts of a program parallelly for maximum utilization of CPU. Each part of such program is called a Thread.

So, threads are light-weight processes within a process.

Threads can be created by using two mechanisms : 

1. Extending the Thread class 
2. Implementing the Runnable Interface

1. Thread creation by extending the Thread class :

To create a Thread, first option is to create a class that extends the java.lang.Thread class. This class overrides the run() method available in the Thread class.

All threads begins thier life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. The start() method invokes the run() method on the Thread object.

Example :

package com.logicalduniya.java.interview;

// ************************* A program to show - How does Multi-Threading works ?? ************************* //

// Java code for thread creation by extending the Thread class -
class MultiThreadingExample extends Thread {

	// Override the run() method of Thread class -
	public void run()
	{
		try {
			// Displaying the thread that is running
			System.out.println(
				"Currently, Thread " + Thread.currentThread().getId() + " is executing..");
		}
		catch (Exception e) {
			// Throwing an exception
			System.out.println("Exception happened..");
		}
	}
}

// Main Class
public class MainMultithread {
	public static void main(String[] args)
	{
		int n = 6; // Number of threads

		for (int i = 0; i < n; i++) {
			MultiThreadingExample threadObject= new MultiThreadingExample();

			// Start method will internally call the run() method, which we have overridden above..
			threadObject.start();     
		}
	}
}

Output:

Currently, Thread  22 is executing..
Currently, Thread  21 is executing..
Currently, Thread  20 is executing..
Currently, Thread  20 is executing..
Currently, Thread  22 is executing..
Currently, Thread  21 is executing..

Thread creation by implementing the Runnable Interface

Another way to create Threads is to create a new class which implements java.lang.Runnable interface and override run() method. Then we instantiate a Thread object and call start() method on this object. 

The benefit of this technique to create Threads is that – we can still extend some other class, as multiple inheritance is not allowed in Java.

package com.logicalduniya.java.interview;

// ************** A program to show - How does Multi-Threading works ?? ************** //

// Java code for thread creation by implementing the Runnable Interface -
class MultiThreadingExample implements Runnable {

	public void run() {
		try {
			// Displaying the thread that is running
			System.out.println(
				"Currently, Thread " + Thread.currentThread().getId() + " is executing..");
		}
		catch (Exception e) {
			// Throwing an exception-
			System.out.println("Exception raised..");
		}
	}
}

// Main Class
class MainMultithread {
	public static void main(String[] args)
	{
		int n = 6; // Number of threads
		for (int i = 0; i < n; i++) {
			Thread object = new Thread(new MultiThreadingExample());
			object.start();
		}
	}
}

Output:

Currently, Thread  20 is executing..
Currently, Thread  21 is executing..
Currently, Thread  20 is executing..
Currently, Thread  22 is executing..
Currently, Thread  20 is executing..
Currently, Thread  22 is executing..

Q36) Explain Object Oriented Programming (OOPs) Concept in Java?

Ans-

Object-Oriented Programming aims to implement real-world entities like inheritance, hiding, polymorphism etc. in programming. The main aim of OOP is to bind together the data and the functions that operate on them so that no other part of the code can access this data except that function.

The basic concept of OOPs is to create objects, re-use them throughout the program, and manipulate these objects to get results.

OOPs Concepts in Java with Examples

The following are general OOPs concepts in Java:

1) Class

The class is one of the basic concepts of OOPs which is a group of similar entities. It is only a logical component and not the physical entity. We can understand more about Class concept with example.

Let’s say you had a class called “Expensive Cars”, then it could have objects like Mercedes, BMW, Toyota, etc. Its properties(data fields) can be ‘price’ and ‘speed’ of these cars. While the methods may be performed with these cars are driving(), doReverse(), applyBrakes() etc.

2) Object

An object can be defined as an instance of a class, and there can be multiple instances of a class in a program. It’s a real physical entity, which consumes memory in our RAM.

An Object is one of the Java OOPs concepts which contains both the data and the function, which operates on the data. For example – chair, bike, marker, pen, table, car, etc.

3) Inheritance

Inheritance is one of the Basic Concepts of OOPs in which one object acquires the properties and behaviours of the parent object. It’s creating a parent-child relationship between two classes. It offers robust and natural mechanism for organizing and structure of any software. Java only supports Single-Level and Multi-Level Inheritance with help of extends keyword.

4) Polymorphism

Polymorphism is the ability of a variable, object or function to take on multiple forms. As an example, Let’s say, there is a Shape class with multiple methods with same name area(...) but all methods take different parameters.

Class – Shape.java :

One area(..) method is taking one int parameter named as radius, and calculates the area of Circle –

public void area (int radius) {
    System.out.println("Circle area = " + 3.14 * radius * radius);
}

Another area(..) method is taking two double type parameters, and calculates area of a Triangle –

public void area (double b, double h) {
    System.out.println("Triangle area=" + 0.5 * b * h);
}

Here we are implementing Polymorphism in Shape class, with help of Method Overloading feature.

5) Abstraction

Abstraction is another key concept of OOPs in Java, which is an act of representing essential features without including background details. It is a technique of creating a new data type that is suited for a specific application.

Let’s understand this one of the OOPs Concepts with example, while driving a car, you do not have to be concerned with its internal working. Here you just need to concern about parts like steering wheel, Gears, accelerator, etc.

6) Encapsulation

Encapsulation is one of the core concepts of OOPs principals. Encapsulation helps in binding the data and code together inside the class.To allow outside access to the instance variables, public methods called getters and setters are defined, which are used to retrieve and modify the values of the instance variables, respectively. By using getters and setters, the class can enforce its own data validation rules and ensure that its internal state remains consistent.

7) Association

Association defines relationship between two objects. It is another important OOP Concepts in Java which defines the diversity between objects. In this OOP concept, all objects have their separate lifecycle, and there is no owner.

For example, many students can associate with one teacher, while one student can also associate with multiple teachers.

8) Aggregation

In this technique, all objects have their separate lifecycle. However, there is ownership such that child object can’t belong to another parent object.

For example, consider class and objects – department and teacher. Here, a single teacher can’t belong to multiple departments, but even if we delete the department, the teacher object will never be destroyed.

9) Composition

Composition is a specialized form of Aggregation. It is also called “death” relationship. As per this concept, all Child objects do not have their lifecycle so when parent object gets deleted, all of it’s child object will also get deleted automatically.

For that, let’s take an example of House and rooms. Any house can have several rooms. One room can’t become part of two different houses. So, if you delete the house, all of it’s room will also be deleted.

Q37) Is Java “pass-by-reference” or “pass-by-value”?

Ans-

The terms “pass-by-value” and “pass-by-reference” are talking about variables.

Pass-by-value means that the value of a variable is passed to a function/method.

Pass-by-reference means that a reference to that variable is passed to the function. This technique gives the function a way to change the contents of the variable.

So, we can conclude by saying – Java is always pass-by-value.

Example – Pass by value VS Pass by Reference

package com.logicalduniya.java.interview;

// ************** A program on - Call by Value and Call by Reference ************** //

public class LogicalDuniyaExample {

    public static void main(String[] args) {
        Dog aDog = new Dog("Max");
        Dog oldDog = aDog;

        // we pass the object to logicalFun()
        logicalFun(aDog);

        // aDog variable is still pointing to the "Max" dog when logicalFun(...) returns
        aDog.getName().equals("Max"); // true
        aDog.getName().equals("Fifi"); // false
        aDog == oldDog; // true
    }

    public static void logicalFun(Dog d) {
        d.getName().equals("Max"); // true

        // change d inside of logicalFun() to point to a new Dog instance "Fifi"
        d = new Dog("Fifi");

        d.getName().equals("Fifi"); // true
    }
}

In the example above aDog.getName() will still return "Max". The value aDog within main is not changed in the function logicalFun() with the Dog "Fifi" as the object reference is passed by value. If it were passed by reference, then the aDog.getName() in main would return "Fifi" after the call to logicalFun().

Q38) What will be the output of this Java Program?

package com.logicalduniya.java.interview;

public class LogicalDuniyaMain {

    public static void main(String[] args) {
        System.out.println("Hello LogicalDuniya.com - This is Main Method1.");
    }

    public static void main(int[] args) {
        System.out.println("Hello LogicalDuniya.com - This is Main Method2.");
    }
}

Ans-

First, let me share the output, then we will discuss why and how it happened?

Hello LogicalDuniya.com - This is Main Method1.

The reason for above output –

The output of the above program will be Hello. Main Method. This is because JVM will always call the main method based on the definition it already has. Doesn’t matter how many main methods we overload, it will only execute one main method based on its declaration in JVM.

Q39) What are the differences between Instance Variable and a Class Variable.

Ans-

Instance Variable :
These variables can have different values among different objects. A class variable WITHOUT a static modifier known as an instance variable.

It is typically shared by all instances of the class. The contents of an instance variable are completely independent of one object instance from another because they are related to a specific object instance of the class.

Example – Usage of Instance Variable :

// Java Program to Demonstrate Instance Variable -

class LogicalDuniyaExample { 

	private String name;             // Created the Instance Variable - 'name'

	public void setName(String name) { this.name = name; } 

	public String getName() { return name; } 

	public static void main(String[] args) 
	{ 
		LogicalDuniyaExample objOne = new LogicalDuniyaExample(); 
		LogicalDuniyaExample objTwo = new LogicalDuniyaExample(); 

		objOne.setName("This is our LogicalDuniya !!!");        // Setting value for objOne -
		objTwo.setName("We Learn Programming concepts here.");  // Setting value for objTwo -

		System.out.println("Hi. " + objOne.getName());          // Setting value from objOne -
		System.out.println("And, " + objTwo.getName());         // Getting value from objTwo -
	}
}

Output :

Hi. This is our LogicalDuniya !!!
We Learn Programming concepts here.

Class Variable :
Class Variable can be declared anywhere at the class level using the keyword static.

The static variables or Class level variables values are not different for multiple variables. These variables can be shared by all class members since they are not connected to any specific object of the class.

Example – Usage of Class Variables :

// Java Program to demonstrate Class Variable 

class LogicalDuniyaExample { 

	// class variable 
	private static final double PI = 3.14159; 

	private double radius; 

	public LogicalDuniyaExample(double radius) { this.radius = radius; } 

	public double getArea() { return PI * radius * radius; } 

	public static void main(String[] args) 
	{ 
		LogicalDuniyaExample obj = new LogicalDuniyaExample(5.0); 
		System.out.println("Area of circle: "
						   + obj.getArea()); 
	} 
}

Q40) What do you understand by an IO Stream?

Ans-

Java 8 and other future releases have Streams with its Input / Output package that helps the user to perform all the input-output operations. These streams support all types of objects, files, data types, characters etc to fully execute the I/O operations.

Java class InputStream is an abstract class. This serves as the superclass for all classes representing an input stream of bytes.

Some useful Input Stream classes –

• FileInputStream
• ByteArrayInputStream
• ObjectInputStream

Java class OutputStream is an abstract class. This serves as the superclass for all classes representing an output stream of bytes.

Some useful Output Stream classes –

• FileOutputStream
• ByteArray<code>OutputStream
• Object<code>OutputStream

Q41) What is an Array in Java? How many types of Array we can create in Java?

Ans-

Arrays in Java –

An Array in Java is a data structure that is used to store a fixed-size sequence of elements of the same type. Elements of an array can be accessed by their index, which starts from 0 and goes up to array’s length minus 1. Array declaration in Java is done with the help of square brackets and size is also specified during the declaration. Here are how arrays get initialized in Java –

Declaration and Initialization of Array –

// One-Dimensional Array declaration -
int[] the_Array = new int[5];

// Two Dimensional array declaration -
int[][] twoD_Array = new int[10][20];

// Three Dimensional array:
int[][][] threeD_Arr = new int[10][20][30];


// One-Dimensional Array initialization -
the_Array[0] = 102;
the_Array[1] = 1023;

// Two Dimensional array initialization -
twoD_Array[0][0] = 103
twoD_Array[0][1] = 1034

// Three Dimensional array initialization -
threeD_Array[0][0][0] = 104;
threeD_Array[0][0][1] = 1045;

Q42) Why is processing a sorted array faster than processing an unsorted array?

Ans-

The answer is – Because of branch prediction failure.

The reason, why program’s performance improves drastically, when the data is sorted, is that – the branch prediction penalty is removed, as explained beautifully in Mysticial’s answer on Branch Prediction and performance comparison on Sorted Array vs Unsorted Array.

If we have a sorted array, the condition data[c] >= 128 is first false for a streak of values, then becomes true for all later values. That become super easy to predict. With an unsorted array, you pay for the branching cost. Check the above linked answer for more details.

Let’s see a Quick Demonstration of it’s prediction –

T = branch taken
N = branch not taken

data[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ...
branch = N  N  N  N  N  ...   N    N    T    T    T  ...   T    T    T  ...

       = NNNNNNNNNNNN   ... NNNNNNNTTTTTTTTTTT       ... TTTTTTTTTTTTTTTT  (easy to predict)

Q43) Is Java “pass-by-reference” or “pass-by-value”?

Ans-

First of all, Java is always PASS BY VALUE. The confusion generally occurs when we deal with variables holding objects. These variables are (also known as Reference Variables, and they) internally deal with object-handles (well known as- ‘References’), which are passed-by-value as well.

The phrases Java “pass-by-value” and “pass-by-reference” are basically talking about variables. Let’s first understand them only –

• Pass-by-value :
  It simply means that the value of a variable is passed to a function/method.
• Pass-by-reference:
  It simply means that a reference to that variable is passed to the function. Which later gives the function an opportunity to change the contents of the variable.

public static void main(String[] args) {
  Cat aCat = new Cat("Toni");
  Cat oldCat = aCat;

  // We pass the object to foo
  foo(aCat);
  
  // aCat variable is still pointing to the "Toni" cat when foo(...) returns
  aCat.getName().equals("Toni");     // Output = true
  aCat.getName().equals("Fifi");     // Output = false
  aCat == oldCat; // Output = true
}

public static void foo(Cat d) {
  d.getName().equals("Toni");        // Output = true
  
  // change d inside of foo() to point to a new Cat instance "Fifi"
  d = new Cat("Fifi");
  d.getName().equals("Fifi");        // Output = true
}

Q44) What is Collection in Java?

Ans-

Collection in Java :
Any group of “individual objects” that are defined or represented as a single unit is known as a Java Collection of Objects. In Java, there is a separate framework named as “Collection Framework”. This ‘Collection Framework’ is available from Java JDK 1.2 which contains all the various Java Collection Classes and Interfaces that help a developer to manage group of objects with so much ease.

Key Points of Java Collections Framework –

• In Java, the Collection interface (java.util.Collection) and Map interface (java.util.Map) are the two main “root” interfaces of Java collection classes.
• The Collection Framework has a basic set of interfaces like Collection, Set, List, or Map, all the classes (ArrayList, LinkedList, Vector, etc) that implement these interfaces have some common set of methods.
• As a programmer, we do not need to worry about the design of the Collection but we only need to focus on – How can we use this pre-defined Collection classes and Methods.
• The Collection Framework helps us to increase performance by utilizing various data-structures and algorithms which are already present in the framework.
• This framework helps us to drastically upgrade our software development process as the major part ‘The Skeleton’ is already given to us in the form of classes (ArrayList, LinkedList, Vector, etc) and Interfaces.

Q45) What is the difference between static method and instance method?

Ans-

Overall, Java Static methods are methods that belong to a class rather than to instances of the class, while the Java Instance methods are functions defined within a class that operate on instances (objects) of that class.

Q46) What do you understand with Error java.lang.OutOfMemoryError: GC overhead limit exceeded ?

Ans-

This error message means that for some reason the garbage collector is taking an excessive amount of time (by default 98% of all CPU time of the process) and recovers very little memory in each run (by default 2% of the heap).

This error tells that our program stops doing any progress and is busy running only the garbage collection at all time.

To prevent our application from soaking up CPU time without getting anything done, the JVM throws this Error so that you have a chance of diagnosing the problem –

Error java.lang.OutOfMemoryError: GC overhead limit exceeded.

This error also occurs where some code was creating tons of temporary objects and tons of weakly-referenced objects in an already very memory-constrained environment.

Q47) What are the Differences Between HashMap and Hashtable in Java?

Ans-

There are a few similarities between HashMap and Hashtable classes –

• Hashtable and HashMap are collections that implement the Map interface.
• Also, the put(), get(), remove() and a few other methods provide constant-time performance O(1).

But, these are different in various factors –

Q48) What is the difference between Set and Map in Java?

Ans-

There are so many differences between Set and Map. Here are a few examples –

Q49) What is the difference between this() and super() in Java?

Ans-

Q50) Do we have get() method in any Set implementation class of Java Collection?

Ans-

This is a very popular Java Interview Questions and Answers. Let’s understand this with examples –

Set or any of its implementation classes (HashSet / LinkedHashSet / TreeSet) do not provide any get() method.

However to work with values stored in Set object, we have a few other methods –

Q51) What should you choose between Map.clear() vs new Map() ? Which one will be better?

Ans-

Java Interviewers ask such popular Java Interview Questions and Answers to know whether you are aware about the best practices or not. So, let’s understand this with an example –

There are 2 ways to get a fresh and blank Map object –

Way 1 – Map<String, String> myNewMap = new HashMap<String, String>();.

Way 2 – oldMap.clear();

In above 2 ways, when You choose the way 1 to instantiate a new instance, which is backed with new array. Then, garbage collector should clear all the key and values from the previous map, and clear the reference to itself. So O(n) algorithm is executed anyway, but in the garbage collector thread. For 1000 records you won’t see any difference. BUT. The android developer performance guide tells you that it is always better not to create new objects, if you can.

So, you should go with clear() method.

Q52) What do you understand about Java Multi-threading? Explain its different terminologies.

Ans-

Multi-threading in Java allows concurrent execution of multiple threads within the same program. It enables developers to write programs that can perform multiple tasks simultaneously, enhancing performance and responsiveness.

Here are some key concepts and features of Java multi-threading:

1. Thread:
   A thread is the smallest unit of execution within a process. Java provides built-in support for creating and managing threads using the Thread class or implementing the Runnable interface.
2. Thread Lifecycle:
   Threads in Java go through several states in their lifecycle, including new, runnable, blocked, waiting, timed waiting, and terminated.
3. Thread Synchronization:
   When multiple threads access shared resources concurrently, synchronization mechanisms such as locks, synchronized blocks, and semaphores are used to ensure data consistency and prevent race conditions.
4. Concurrency Utilities:
   Java provides a rich set of concurrency utilities in the java.util.concurrent package, including ExecutorService, ThreadPoolExecutor, Future, Semaphore, CountDownLatch, and more, to simplify multi-threaded programming.
5. Thread Safety:
   Thread safety is a critical consideration when writing multi-threaded code to ensure that shared data structures and resources are accessed safely by multiple threads.
6. Thread Communication:
   Threads can communicate and synchronize with each other using techniques such as wait and notify, condition variables, and message passing.
7. Thread Pools:
   Thread pools manage a pool of worker threads, allowing for efficient reuse of threads and better resource management.
8. Atomic Operations:
   Java provides atomic data types and classes in the java.util.concurrent.atomic package, such as AtomicInteger, AtomicLong, and AtomicReference, to perform atomic operations without the need for explicit synchronization.
9. Fork/Join Framework:
   Introduced in Java 7, the Fork/Join framework provides a high-level abstraction for parallelizing recursive algorithms by dividing tasks into smaller subtasks and merging their results.

Q53) Why, String is immutable in Java?

Ans-

In Java, String objects are immutable for several reasons:

1. Caching and Reusability:
   Immutable strings can be cached and reused, which can lead to performance improvements and reduced memory usage. For example, the JVM can reuse existing string literals instead of creating new ones when the same literal is encountered again.
2. Thread Safety:
   String immutability ensures that strings are inherently thread-safe. Since strings cannot be modified after creation, they can be safely shared between multiple threads without the risk of concurrency issues like race conditions.
3. Security:
   Immutable strings are inherently more secure because they cannot be modified once created. This prevents malicious code from tampering with string values and helps prevent certain types of attacks, such as buffer overflow attacks.
4. Hash code Consistency:
   As we know, string objects are immutable, their hash codes remain constant throughout their lifetime. This ensures that strings can be reliably used as keys in hash-based data structures like HashMap.
5. Simplifies Memory Management:
   Immutable strings simplify memory management because they can be safely shared and reused across different parts of an application without worrying about unintended side effects due to modification.

Q54) Explain Enumeration in Java? What is ‘enum’ in Java?

Ans-

In Java, an enumeration (enum) is a special data type that represents a group of constants (enumerated values). Enumerations are defined using the enum keyword and are useful when you have a fixed set of related constants that belong together.

Here’s an example of how you can define and use an enumeration in Java:

// Define an enumeration called DayOfWeek
enum DayOfWeek {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
}

public class LogicalDuniyaEnumExample {

    public static void main(String[] args) {

        // Access individual values of the DayOfWeek enumeration
        DayOfWeek today = DayOfWeek.WEDNESDAY;
        System.out.println("Today is: " + today);

        // Use switch statement with enum
        switch (today) {
            case MONDAY:
                System.out.println("It's Monday!");
                break;
            case TUESDAY:
                System.out.println("It's Tuesday!");
                break;
            case WEDNESDAY:
                System.out.println("It's Wednesday!");
                break;
            // Handle other cases as needed
            default:
                System.out.println("It's another day of the week!");
        }

        // Iterate over all values of the DayOfWeek enumeration
        System.out.println("All days of the week:");
        for (DayOfWeek day : DayOfWeek.values()) {
            System.out.println(day);
        }
    }
}

Explanation Step-by-Step :

In this example:

• We define an enumeration called DayOfWeek, which represents the days of the week.
• We declare a variable today of type DayOfWeek and assign it the value DayOfWeek.WEDNESDAY.
• We use a switch statement to perform different actions based on the value of today.
• We iterate over all values of the DayOfWeek enumeration using the values() method.

Enumerations provide a type-safe way to work with predefined constants and can improve the readability and maintainability of your code by providing meaningful names to groups of related constants.

Q55) Can you execute any commented statement in Java?

Ans-

Yes. Hare is an example code snippet –

public class LogicalDuniyaTesting 
{ 
	public static void main(String[] args) 
	{ 
		// the line below this gives an output 
		// \u000d System.out.println("Hello LogicalDuniya. I'm a Comment..."); 
	} 
} 

Output :

Hello LogicalDuniya. I'm a Comment...

Q56) What are named loops in Java?

Ans-

In Java, named loops (also known as labelled loops) allow you to assign a label to a loop or a block of code. This label can then be used with certain control flow statements like break and continue to specify which loop to break out of or continue to. This is particularly useful when you have nested loops and want to break or continue a specific loop rather than just the innermost one.

Syntax :

A named loop is created by placing an identifier followed by a colon (:) before the loop statement. Here’s an example of the syntax:

labelName: for (initialization; condition; update) {
    // loop body
}

Example :

public class LogicalDuniyaNamedLoopsExample {

    public static void main(String[] args) {

        // Named loop 'outer'
        outer: for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 5; j++) {
                if (i * j == 12) {
                    System.out.println("Breaking out of outer loop when i*j equals 12");
                    break outer;  // Breaks out of the 'outer' loop
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
        System.out.println("Loop terminated.");
    }
}

Output :

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 1, j = 4
i = 1, j = 5
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
i = 2, j = 4
i = 2, j = 5
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3
Breaking out of outer loop when i*j equals 12
Loop terminated.

Explanation :

• Label Definition: The outer loop is labelled outer.

• Using the Label with break: When i * j == 12 is true, the program breaks out of the loop labelled outer, which terminates both the inner and outer loops.

Q57) How to Find and Remove Duplicate Elements from List in Java?

Ans-

Below is Java program to Find and Remove Duplicate Elements from List –

File name = LogicalDuniyaRemoveDuplicatesFromList.java :

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Iterator;

public class LogicalDuniyaRemoveDuplicatesFromList {
    public static void main(String[] args) {
        // Create a LinkedList and add some elements (including duplicates)
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(2);
        list.add(4);
        list.add(1);
        list.add(5);
        
        System.out.println("Original LinkedList: " + list);
        
        // Remove duplicates
        removeDuplicates(list);
        
        System.out.println("LinkedList after removing duplicates: " + list);
    }
    
    public static void removeDuplicates(LinkedList<Integer> list) {
        // Create a HashSet to track seen elements
        HashSet<Integer> seen = new HashSet<>();
        
        // Use an iterator to traverse the LinkedList
        Iterator<Integer> iterator = list.iterator();
        
        while (iterator.hasNext()) {
            Integer current = iterator.next();
            
            // If the element is already in the HashSet, it's a duplicate; remove it
            if (!seen.add(current)) {
                iterator.remove();
            }
        }
    }
}

Explanation:

1. LinkedList Creation:

• A LinkedList of integers is created and populated with elements. Some of these elements are duplicates (e.g., 1 and 2 appear more than once).

2. Printing the Original LinkedList:

• The original LinkedList is printed to the console to show the elements before removing duplicates.

3. removeDuplicates Method:

• This method takes a LinkedList as input and removes any duplicate elements.

• A HashSet named seen is used to keep track of elements that have already been encountered. Since a HashSet only allows unique elements, it helps in identifying duplicates.

• An Iterator is used to traverse through the LinkedList. The iterator provides a safe way to remove elements while iterating.

• The iterator.next() method retrieves the next element from the LinkedList.

• The HashSet.add(current) method tries to add the current element to the HashSet. If the element is already present in the HashSet, add() returns false, indicating it’s a duplicate.

• If the element is a duplicate (i.e., seen.add(current) returns false), the iterator.remove() method removes it from the LinkedList.

4. Printing the LinkedList After Removing Duplicates:

• Finally, the modified LinkedList, now free of duplicates, is printed.

Output:

When you run this program, the output will be:

Original LinkedList: [1, 2, 3, 2, 4, 1, 5]
LinkedList after removing duplicates: [1, 2, 3, 4, 5]

Q58) What are lambda expressions in Java 8, and how do they improve code readability and conciseness?

Ans-

Lambda expressions were introduced in Java 8 as a key feature to support functional programming. They allow you to write more concise, readable, and flexible code, especially when working with collections or functional interfaces.

What are Lambda Expressions?

A lambda expression in Java is essentially an anonymous function (a function without a name) that can be treated as an instance of a functional interface. A functional interface is an interface with exactly one abstract method, like Runnable, Callable, Comparator, or the custom functional interfaces you might define.

The syntax of a lambda expression is as follows:

(parameters) -> expression

Or, if you need a block of statements:

(parameters) -> { statements; }

Example of a Lambda Expression

Consider a simple example where you want to sort a list of strings by their lengths. Before Java 8, you would do this using an anonymous inner class:

List<String> strings = Arrays.asList("abc", "abcd", "ab");
Collections.sort(strings, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
});

With lambda expressions in Java 8, you can achieve the same result in a much more concise way:

List<String> strings = Arrays.asList("abc", "abcd", "ab");
strings.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));

Or even more concisely using method references:

List<String> strings = Arrays.asList("abc", "abcd", "ab");
strings.sort(Comparator.comparingInt(String::length));

How Lambda Expressions Improve Code Readability and Conciseness

1. Eliminates Boilerplate Code:

• Lambda expressions reduce the need for boilerplate code, like anonymous inner classes. In the example above, the lambda expression (s1, s2) -> Integer.compare(s1.length(), s2.length()) replaces the entire Comparator anonymous class.

2. Focus on What Instead of How:

• With lambda expressions, you can focus more on the logic of what you want to achieve rather than the details of how to implement an interface. This shifts the focus from how the sorting is done to what the criteria for sorting are.

3. Improves Readability:

• Shorter, more declarative code is generally easier to read and understand. This can lead to fewer bugs and easier maintenance. For example, the lambda expression is straightforward and tells you directly that the list is being sorted by string length.

4. Facilitates Functional Programming:

• Lambda expressions are the foundation of functional programming in Java. They allow you to pass behavior (like a comparison function) as data, making it easier to write flexible and reusable code.

More Examples of Lambda Expressions

Example 2: Runnable with Lambda

Before Java 8:

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in a thread");
    }
};
new Thread(r).start();

With Java 8 Lambda:

Runnable r = () -> System.out.println("Running in a thread");
new Thread(r).start();

In Java 8, Lambda expressions enable more concise and readable code by reducing the verbosity associated with anonymous classes and by allowing you to focus on expressing what you want the code to do rather than how it should do it. They are a key feature that supports functional programming and allows for more flexible and reusable code.

Q59) Explain key terminologies of Multi-Threading in Java.

Ans-

Here are the key concepts regarding multi-threading in Java –

1. Thread Creation –

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

A. By Extending the Thread Class:

• You can create a new thread by extending the Thread class and overriding its run() method.

B. By Implementing the Runnable Interface:

• Another way to create a thread is by implementing the Runnable interface and passing an instance of it to a Thread object.

2. Thread Lifecycle –

The lifecycle of a thread in Java includes several states:

• New: When a thread is created, it is in the “New” state. It hasn’t started running yet.
• Runnable: When the thread’s start() method is called, it goes into the “Runnable” state. The thread is ready to run but may not be running immediately (it is waiting for CPU time).
• Running: The thread is in the “Running” state when the CPU starts executing its code.
• Blocked/Waiting: A thread enters this state when it is waiting for a resource, such as I/O or another thread. It remains in this state until the resource becomes available.
• Terminated: A thread enters the “Terminated” state when its run() method has finished executing, either naturally or due to an unhandled exception.

3. Thread Synchronization –

Synchronization is a mechanism that ensures that two or more concurrent threads do not simultaneously execute some particular program segment known as a critical section. In Java, this is done using the synchronized keyword.

• Synchronized Methods: To synchronize an entire method, you can declare it with the synchronized keyword.

• Synchronized Blocks: You can synchronize a specific block of code instead of the entire method.

Example syntax :

// Sync. Methods - 
public synchronized void syncMethod() {
    // synchronized code
}

// Sync. Blocks - 
public void someMethod() {
    synchronized(this) {
        // synchronized code
    }
}

4. Thread Communication –

Thread communication in Java is achieved using methods like wait(), notify(), and notifyAll():

• wait(): A thread that calls wait() goes into a waiting state until another thread calls notify() or notifyAll() on the same object.
• notify(): Wakes up a single thread that is waiting on the object’s monitor.
• notifyAll(): Wakes up all the threads that are waiting on the object’s monitor.

5. Thread Interruption –

Thread interruption is a way to signal a thread to stop its current task. This is often used for managing long-running tasks.

• interrupt() method: You can interrupt a thread by calling interrupt() on the Thread object.
• Handling Interruptions: A thread can check if it has been interrupted by calling Thread.interrupted() or isInterrupted().

6. Thread Priorities –

Java allows you to set the priority of a thread using the setPriority(int priority) method. Thread priorities determine the relative importance of threads; however, they don’t guarantee the order of thread execution, as this is dependent on the operating system’s thread scheduler.

• The priority is set using integer values ranging from Thread.MIN_PRIORITY (1) to Thread.MAX_PRIORITY (10). The default priority is Thread.NORM_PRIORITY (5).

Example Code :

class MyLogicalDuniyaThread extends Thread {
    public void run() {
        System.out.println("Thread running with priority: " + getPriority());
    }
}

public class Main {
    public static void main(String[] args) {
        MyLogicalDuniyaThread t1 = new MyLogicalDuniyaThread();
        MyLogicalDuniyaThread t2 = new MyLogicalDuniyaThread();
        
        t1.setPriority(Thread.MIN_PRIORITY); // Set priority to 1
        t2.setPriority(Thread.MAX_PRIORITY); // Set priority to 10
        
        t1.start();
        t2.start();
    }
}

Q60) What will be the output of below program?

public class LogicalDuniyaCode { 

	public static void main(String[] args) { 
		if (true) 
			break; 
	} 
} 

Ans –

The code, which is provided will not compile and throw a compile-time error. Here’s why:

Explanation :

1. break Statement:
   • The break statement in Java is used to exit a loop (like for, while, or do-while) or to exit a switch statement.
   • The break statement cannot be used outside of a loop or a switch statement. It must be inside a loop or switch to indicate which control flow structure it should break out of.
2. In Given Code:
   • The break statement is used within an if block, but it’s not inside a loop or a switch statement. This is not allowed in Java, so the compiler will throw an error.

Q61) What will be the Output of the below code?

public class LogicalDuniyaCode { 
    public static void main(String[] args) 
    { 
        int $_ = 1; 
        System.out.println("LogicalDuniya Platform is Number " + $_ );
    } 
}

Ans-

The code you provided will compile and run successfully, producing the following output:

LogicalDuniya Platform is Number 1

Explanation:

1. Variable Naming:
   • As mentioned earlier, the variable name $_ is valid in Java because it starts with a dollar sign ($) and ends with an underscore (_). Java allows variable names to start with a letter, dollar sign ($), or underscore (_), and they can contain digits after the first character.
2. Variable Initialization:
   • The variable $_ is declared and initialized with the value 1.
3. Output Statement:
   • The System.out.println statement prints the string "LogicalDuniya Platform is Number " followed by the value of $_, which is 1.
4. Output:
   • The program outputs the concatenated string "LogicalDuniya Platform is Number 1" to the console.

Q62) Give examples of overloading and overriding in Java.

Ans-

When a class has more than one method with same name with different arguments, they are called overloaded methods. The following example code shows as overloaded method called print:

Q63) How do you create a functional interface?

Ans-

@FunctionalInterface
interface MyFunctionalInterface {
    void execute(); // Single abstract method

    // You can also have default methods
    default void show() {
        System.out.println("This is a default method in a functional interface.");
    }

    // And static methods
    static void staticMethod() {
        System.out.println("This is a static method in a functional interface.");
    }
}

public class Main {
    public static void main(String[] args) {
        // Using a lambda expression to implement the functional interface
        MyFunctionalInterface func = () -> System.out.println("Executing the functional interface's abstract method!");

        // Call the method
        func.execute(); // Output: Executing the functional interface's abstract method!

        // You can also call the default method
        func.show(); // Output: This is a default method in a functional interface.

        // Static methods are called on the interface itself
        MyFunctionalInterface.staticMethod(); // Output: This is a static method in a functional interface.
    }
}

Q64) What are the differences between List and Set in Java?

Ans-

There are various differences between List and Set –

Q65) Explain the difference between Iterator and ListIterator.

Ans-

In Java, both Iterator and ListIterator are interfaces used to iterate over collections like lists. They are primarily used to fetch objects / values from the List, but they also have some differences in terms of features and capabilities –

Q66) Why is synchronization necessary? How will you implement synchronization in Java?

Ans-

Synchronization is necessary in multithreaded programming to ensure that multiple threads operate correctly and safely when accessing shared resources or critical sections of code. Without synchronization, concurrent access to shared resources can lead to data corruption, race conditions, and other unexpected behaviours.

Java provides several mechanisms to address synchronization:

1. Synchronized Methods:
   In Java, you can declare methods as synchronized to ensure that only one thread can execute the method at a time. When a thread enters a synchronized method, it acquires the intrinsic lock associated with the method’s object, preventing other threads from executing synchronized methods of the same object concurrently.
2. Synchronized Blocks:
   Java allows you to create synchronized blocks of code using the synchronized keyword. This allows for finer-grained control over synchronization compared to synchronized methods. Threads must acquire the lock associated with the specified object before entering the synchronized block.
3. Volatile Keyword:
   The volatile keyword is used to indicate that a variable’s value may be modified by multiple threads. It ensures that changes made by one thread to the variable’s value are visible to other threads immediately. However, it does not provide atomicity or mutual exclusion like synchronized methods or blocks.
4. Locks:
   Java provides explicit lock objects through classes such as ReentrantLock and ReadWriteLock in the java.util.concurrent.locks package. These locks offer more flexibility and functionality compared to intrinsic locks obtained by synchronized methods and blocks.
5. Atomic Variables:
   The java.util.concurrent.atomic package provides classes such as AtomicInteger, AtomicBoolean, and AtomicReference, which offer atomic operations on their values. These classes can be used to perform thread-safe operations without the need for explicit synchronization.

So, Java’s synchronization mechanisms help developers create robust multithreaded applications by ensuring thread safety and preventing data corruption or inconsistencies caused by concurrent access to shared resources.

Q67) What is the difference between public, protected, package-private and private in Java?

Ans-

Let’s understand this with an example illustration –

• A private member (i) – is only accessible within the same class as it is declared.
• A member with no access modifier (j) – is only accessible within classes in the same package.
• A protected member (k) – is accessible within all classes in the same package and within subclasses in other packages.
• A public member (l) – is accessible to all classes (unless it resides in a module that does not export the package it is declared in).

Q68) When to use LinkedList over ArrayList in Java?

Ans-

ArrayList with ArrayDeque are preferable in many more use-cases than LinkedList.

Most of the times, ArrayList accessing an element takes constant time [O(1)] and adding an element takes O(n) time [worst case]. In LinkedList inserting an element takes O(n) time and accessing also takes O(n) time but LinkedList uses more memory than ArrayList.

LinkedList and ArrayList are two different implementations of the List interface. LinkedList implements it with a doubly-linked list. ArrayList implements it with a dynamically re-sizing array.

Overall, depending on the operations we intend to do, we should choose the implementations accordingly.

• Iterating over either kind of List is practically equally cheap.
• Iterating over an ArrayList is technically faster, but unless we’re doing something really performance-sensitive, we shouldn’t worry about this.

Q69) What is the difference between Comparable and Comparator?

Ans-

Both

Q70) How to convert an Array to a Set in Java

Ans-

To create a Set object from Array, we can follow multiple approaches –

Set<T> mySet = new HashSet<>(Arrays.asList(someArray));

In Java 9+ :

Set<T> mySet = Set.of(someArray);

Note💡
Set.of throws IllegalArgumentException – if there are any duplicate elements in someArray. See more details: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html#of(E…)

Q71) How many types of exceptions can occur in a Java program?

Ans-

There are 2 types of Exceptions in Java –

Q72) Explain Runtime Exceptions in Java.

Ans-

Runtime exceptions, also known as unchecked exceptions, are a type of exception in Java that occur at runtime and are not checked by the compiler at compile time. Unlike checked exceptions, which must be declared or handled by the calling method, runtime exceptions do not need to be declared or caught explicitly.

Here are some key points about runtime exceptions in Java:

1. Inheritance:
   Runtime exceptions are subclasses of the RuntimeException class or one of its subclasses. They are part of the java.lang package.
2. Unchecked:
   Runtime exceptions are unchecked exceptions, which means the compiler does not enforce handling or declaration of these exceptions. This makes them convenient for handling programming errors or exceptional conditions that may not be anticipated by the programmer.
3. Causes:
   Runtime exceptions often arise due to errors in program logic, such as null pointer dereferences, division by zero, array index out of bounds, or invalid type casting. They may also occur due to environmental factors such as resource exhaustion.
4. Handling:
   While it’s not required to catch or declare runtime exceptions, it’s still a good practice to handle them if appropriate. Handling runtime exceptions can help improve the robustness and reliability of the application by gracefully recovering from unexpected errors.
5. Examples:
   Common examples of runtime exceptions in Java include NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException, ClassCastException, and IllegalArgumentException, among others.

Here’s an example demonstrating a runtime exception:

public class LogicalDuniyaExample 
{
    public static void main(String[] args) 
    {
        // Attempting to divide by zero
        int result = 10 / 0; // This line will throw an ArithmeticException at runtime
    }
}

In this example, the division by zero operation will throw an ArithmeticException at runtime because it is not allowed in Java. Since ArithmeticException is a subclass of RuntimeException, it is a runtime exception, and the compiler does not enforce handling or declaration of this exception.

Q73) What is difference between Arrays.asList(array) and new ArrayList(Arrays.asList(array))?

Ans-

Let’s first understand Arrays.asList(arr) –

It takes an array <code>arr and creates a wrapper that implements List<Integer>, which makes the original array available as a list.

Nothing is copied and all, only a single wrapper object is created. Operations on the list wrapper are propagated to the original array. This means that if you shuffle the list wrapper, the original array is shuffled as well, if you overwrite an element, it gets overwritten in the original array, etc.

Of course, some List operations aren’t allowed on the wrapper, like adding or removing elements from the list, you can only read or overwrite the elements.

Also note that the list wrapper doesn’t extend ArrayList – it’s a different kind of object. ArrayLists have their own, internal array, in which they store their elements, and are able to resize the internal arrays etc. The wrapper doesn’t have its own internal array, it only propagates operations to the array given to it.

Now, let’s understand the other side –

<code>new ArrayList<Integer>(Arrays.asList(arr))

Here if you subsequently create a new array as above, then you create new ArrayList, which is a full, independent copy of the original one.

Although here you create the wrapper using Arrays.asList as well, it is used only during the construction of the new ArrayList and is garbage-collected afterwards. The structure of this new ArrayList is completely independent of the original array.

It contains the same elements (both the original array and this new ArrayList reference the same integers in memory), but it creates a new, internal array, that holds the references. So when you shuffle it, add, remove elements etc., the original array is unchanged.

Q74) When do you understand with singletonMap() method of Java Collection Framework?

Ans-

In Java, the singletonMap() method is a utility method provided by the Collections class in the java.util package. It is used to create an immutable map (a key-value pair collection) that contains only one mapping.

Here’s a brief explanation of the singletonMap() method:

• Purpose:
  The singletonMap() method is used to create a map with a single entry (key-value pair) where both the key and the value are specified.
• Immutable Map:
  The map returned by singletonMap() is immutable, meaning that once created, its contents cannot be modified. Attempts to add, remove, or update elements in the map will result in an UnsupportedOperationException.
• Memory Efficiency:
  Since the map contains only one entry, it is memory-efficient for cases where you need to represent a single key-value mapping without creating a larger data structure.
• Syntax:

static <K,V> Map<K,V> singletonMap(K key, V value)

• Parameters:
  key: The key with which the specified value is to be associated in the map.
  value: The value to be associated with the specified key in the map.
• Return Value:
  The singletonMap() method returns an immutable map containing the specified key-value mapping.

Example :

import java.util.Collections;
import java.util.Map;

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

        // Creating a singleton map with key="name" and value="John"
        Map<String, String> singleton = Collections.singletonMap("name", "John");

        // Printing the contents of the map
        System.out.println("Singleton Map: " + singleton);
    }
}

Output :

Singleton Map: {name=John}

So, the singletonMap() is a convenient way to create a simple, immutable map with a single key-value pair. It is particularly useful in scenarios where you need to represent a constant mapping or pass a single key-value pair to a method that expects a map.

Q75) What are the advantages of Multi-threading in Java?

Ans-

Multithreading in Java allows multiple tasks or processes to run concurrently within a single program. Here are some advantages of multithreading –

Multithreading in Java provides several benefits, including improved performance, increased responsiveness, better resource utilization, simplified design, and concurrency, making it a valuable tool for developing efficient and scalable applications.

Q76) Explain the difference between process and thread in Java.

Ans-

There are many differences between the process and thread –

Q77) How do you write an interface with default and static method?

Ans-

Java 8 introduced default and static methods in interfaces. This bridged the gap between interfaces and abstract classes. The following example code shows one way to write an interface with the default and static method –

public interface LogicalDuniyaInterface1 {
	
	// regular abstract method
	void method1(String str);
	
	default void log(String str) {
		System.out.println("I1 logging::" + str);
	}
	
	static boolean isNull(String str) {
		System.out.println("Interface Null Check");

		return str == null ? true : "".equals(str) ? true : false;
	}

}

Q78) What is the difference between Queue and Deque?

Ans-

Here are a few basic differences between Queue and Deque –

Q79) How do you use the forEach() method in Java?

Ans-

The forEach() method provides a shortcut to perform an action on all the elements of an iterable. The following example code shows how to iterate over the list elements and print them:

List<String> list = new ArrayList<>();

list.forEach(System.out::print);

Q80) How do you create an enum in Java?

Ans-

In Java, an enum (short for “enumeration”) is a special data type that represents a group of constants (unchangeable variables, like final variables). An enum in Java is a type used to define a collection of constants, which can be accessed in a type-safe manner.

How to Create an Enum? :

Here’s a step-by-step guide on how to create an enum in Java:

1. Define an Enum:
   • Use the enum keyword to define a new enum type. This is similar to defining a class, but instead of the class keyword, you use enum.
2. Add Constants:
   • Inside the enum, define the constants, which are usually written in uppercase letters and separated by commas.
3. (Optional) Add Fields, Constructors, and Methods:
   • Enums can have fields, constructors, and methods, just like regular classes. The constructor is private by default because enum types are implicitly final.

enum Day {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
}

public class LogicalDuniyaMain {

    public static void main(String[] args) {

        Day today = Day.WEDNESDAY;
        
        // Print the enum constant
        System.out.println("Today is: " + today); // Output: Today is: WEDNESDAY
        
        // Use enum in a switch statement
        switch (today) {
            case MONDAY:
                System.out.println("Mondays are tough.");
                break;
            case FRIDAY:
                System.out.println("Fridays are fun!");
                break;
            case SATURDAY: case SUNDAY:
                System.out.println("Weekends are the best!");
                break;
            default:
                System.out.println("Midweek days are okay.");
                break;
        }
    }
}

Q81) What are the Differences between HashSet and TreeSet?

Ans-

Here are basic differences between HashSet and TreeSet –

Q82) How do you create text blocks in Java?

Ans-

Text blocks in Java were introduced in Java 13 as a preview feature and became a standard feature in Java 15. They provide a way to write multi-line string literals in Java without needing to manage escape sequences for newlines and other special characters. This makes code more readable and easier to maintain.

Syntax of Text Blocks :

A text block is defined using three double-quote characters (""") as delimiters. The content of the text block can span multiple lines, and the formatting of the text block will be preserved when it is compiled and run.

Here’s the basic syntax:

String logicalDuniyaTextBlock = """
    Hey there. This is a text block.
    It can span multiple lines.
    Newlines are preserved, and "quotes" don't need escaping.
    """;

Q83) How do you create a record in Java?

Ans-

In Java, a record is a special kind of class introduced in Java 14 as a preview feature and became a standard feature in Java 16. Records are designed to be a concise way to create classes that are primarily used to store data. A record automatically provides implementations for several methods, including the constructor, equals(), hashCode(), and toString().

To create a record in Java, you use the record keyword followed by the name of the record and a list of its components (fields) inside parentheses. Here’s a basic example:

public record Person(String name, int age) {
}

Explanation :

• record: This keyword declares a new record class.
• Person: The name of the record.
• String name, int age: These are the components (fields) of the record. They are implicitly private and final.