Top 25 Intermediate Java Interview Questions and Answers | Ace Your Java Interview! Part 1

1. What is the difference between JDK, JRE, and JVM?

Answer: JDK (Java Development Kit) is a software development kit used to develop Java applications. JRE (Java Runtime Environment) provides the libraries, Java Virtual Machine (JVM), and other components to run applications written in Java. JVM is an abstract machine that enables your computer to run a Java program.

2. How does Java achieve memory management?

Answer: Java achieves memory management through the use of the garbage collector, which automatically identifies and disposes of objects that are no longer in use, thereby freeing up memory. Additionally, Java uses a managed heap for dynamic memory allocation.

3. What are Java Collections, and can you explain some commonly used collections?

Answer: Java Collections is a framework that provides a set of classes and interfaces to handle collections of objects. Commonly used collections include ArrayList, LinkedList, HashSet, TreeSet, HashMap, and TreeMap.

4. Explain method overloading and method overriding with examples.

Answer: Method overloading occurs when multiple methods in a class have the same name but different parameters. For example:
```java
void display(int a) {}
void display(int a, int b) {}
```
Method overriding occurs when a subclass provides a specific implementation of a method already defined in its superclass. For example:
```java
class Parent {
void show() {}
}

class Child extends Parent {
@Override
void show() {}
}
```

5. Write a Java program to implement a binary search algorithm.

Answer:
```java
public class BinarySearch {
public int binarySearch(int[] arr, int key) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (arr[mid] == key) {
return mid;
} else if (arr[mid] < key) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

public static void main(String[] args) {
BinarySearch bs = new BinarySearch();
int[] arr = {1, 3, 5, 7, 9, 11};
int result = bs.binarySearch(arr, 7);
System.out.println("Element found at index: " + result);
}
}
```

6. Describe how a HashMap works in Java.

Answer: A HashMap in Java works by storing key-value pairs. It uses a hash function to compute an index for the array (bucket) where the key-value pair is stored. If multiple keys map to the same bucket (collision), the HashMap uses a linked list or a balanced tree to store multiple entries.

7. What are functional interfaces in Java 8?

Answer: Functional interfaces are interfaces with a single abstract method. They are used as the basis for lambda expressions and method references. Examples include `Runnable`, `Callable`, `Comparator`, and custom interfaces annotated with `@FunctionalInterface`.

8. How do Streams work in Java 8?

Answer: Streams in Java 8 provide a way to process sequences of elements. They allow for functional-style operations on collections of objects. Streams support operations such as `map`, `filter`, `reduce`, `collect`, and more, enabling efficient and readable data manipulation.

9. What are the differences between synchronized and volatile keywords in Java?

Answer: The `synchronized` keyword ensures that only one thread can execute a block of code at a time, providing mutual exclusion and memory visibility. The `volatile` keyword ensures that changes to a variable are always visible to all threads, providing a lightweight synchronization mechanism without mutual exclusion.

10. What is the Spring Bean lifecycle?

Answer: The Spring Bean lifecycle includes instantiation, dependency injection, initialization, and destruction. Spring manages these phases using various callbacks such as `InitializingBean`, `DisposableBean`, custom init and destroy methods, and annotations like `@PostConstruct` and `@PreDestroy`.

11. Explain how Hibernate handles the first and second level caches.

Answer: Hibernate's first-level cache is associated with the session and is enabled by default. It caches entities within the session. The second-level cache is associated with the session factory and can be configured to cache entities, collections, and queries across multiple sessions, improving performance by reducing database access.

12. What is the Factory pattern, and where would you use it?

Answer: The Factory pattern is a creational design pattern that provides an interface for creating objects without specifying the exact class of object that will be created. It's used when a class cannot anticipate the class of objects it must create or to simplify object creation logic.

13. How does Java handle exceptions? Describe the difference between checked and unchecked exceptions.

Answer: Java handles exceptions using try-catch blocks, where the `try` block contains the code that might throw an exception, and the `catch` block handles the exception. Checked exceptions are checked at compile-time, while unchecked exceptions (runtime exceptions) are checked at runtime.

14. Write a Java program to reverse a string.

Answer:
```java
public class ReverseString {
public static String reverse(String str) {
StringBuilder sb = new StringBuilder(str);
return sb.reverse().toString();
}

public static void main(String[] args) {
String original = "Hello, World!";
String reversed = reverse(original);
System.out.println("Reversed string: " + reversed);
}
}
```

15. What is the difference between a HashSet and a TreeSet?

Answer: A `HashSet` is an unordered collection that uses a hash table for storage, providing constant-time performance for basic operations. A `TreeSet` is an ordered collection that uses a red-black tree structure, providing log-time performance for basic operations and maintaining elements in ascending order.

16. Explain the concept of inheritance in Java with an example.

Answer: Inheritance allows a class to inherit properties and behavior (methods) from another class. It promotes code reuse and establishes a parent-child relationship. For example:
```java
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}

class Dog extends Animal {
void bark() {
System.out.println("This dog barks.");
}
}
```

17. What is polymorphism in Java? Provide an example.

Answer: Polymorphism allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to represent different underlying forms (data types). For example:
```java
class Animal {
void makeSound() {
System.out.println("Animal makes a sound.");
}
}

class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Dog barks.");
}
}

class Cat extends Animal {
@Override
void makeSound() {
System.out.println("Cat meows.");
}
}

public class TestPolymorphism {
public static void main(String[] args) {
Animal a1 = new Dog();
Animal a2 = new Cat();
a1.makeSound();
a2.makeSound();
}
}
```

18. Write a Java program to find the factorial of a number using recursion.

Answer:
```java
public class Factorial {
public static int factorial(int n) {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}

public static void main(String[] args) {
int num = 5;
int result = factorial(num);
System.out.println("Factorial of " + num + " is: " + result);
}
}
```

19. What is the difference between `String`, `StringBuilder`, and `StringBuffer`?

Answer: `String` is immutable, meaning once created, its value cannot be changed. `StringBuilder` and `StringBuffer` are mutable classes used for string manipulation. `StringBuilder` is not synchronized and is faster, whereas `StringBuffer` is synchronized and thread-safe.

20. Explain the concept of interfaces in Java.

Answer: Interfaces in Java define a contract that classes can implement. They contain abstract methods (without implementation) that the implementing classes must define. Interfaces support multiple inheritance in Java.

21. Write a Java program to check if a number is a prime number.

Answer:
```java
public class PrimeCheck {
public static boolean isPrime(int num) {
if (num <= 1) return false;
for (int i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) return false;
}
return true;
}

public static void main(String[] args) {
int num = 29;
System.out.println(num + " is prime: " + isPrime(num));
}
}
```

22. What is the difference between `==` and `equals()` in Java?

Answer: The `==` operator compares object references to check if they refer to the same instance. The `equals()` method compares the values within the objects for logical equality. For example:
```java
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true
```

23. Describe how you would implement a singleton pattern in Java.

Answer: A singleton pattern ensures a class has only one instance and provides a global point of access to it. It can be implemented as follows:
```java
public class Singleton {
private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
```

24. Write a Java program to find the largest element in an array.

Answer:
```java
public class LargestElement {
public static int findLargest(int[] arr) {
int largest = arr[0];
for (int num : arr) {
if (num > largest) {
largest = num;
}
}
return largest;
}

public static void main(String[] args) {
int[] arr = {1, 5, 3, 9, 2};
int largest = findLargest(arr);
System.out.println("The largest element is: " + largest);
}
}
```

25. Explain the concept of a thread in Java. How do you create a thread?

Answer: A thread in Java is a lightweight process that allows concurrent execution of code. Threads can be created by extending the `Thread` class or implementing the `Runnable` interface. For example:
```java
// Extending Thread class
class MyThread extends Thread {
public void run() {
System.out.println("Thread is running.");
}
}

// Implementing Runnable interface
class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable is running.");
}
}

public class ThreadExample {
public static void main(String[] args) {
MyThread t1 = new MyThread();
t1.start();

Thread t2 = new Thread(new MyRunnable());
t2.start();
}
}
```