2000+ Java Developer Interview Questions and Answers

The function sorts an integer array containing only 0s and 1s in linear time complexity.

• Use two pointers, one starting from the beginning and the other from the end of the array.

• Swap the elements at the pointers if the element at the beginning pointer is 1 and the element at the end pointer is 0.

• Continue moving the pointers towards each other until they meet in the middle of the array.

The order of execution will be: parent's run() -> child's run() -> parent's walk()

• When p.run() is called, it will first execute the run() method of the parent class

• Inside the parent's run() method, it will call the walk() method of the parent class

• Since the child class overrides the parent class, the child's run() method will be executed next

• Inside the child's run() method, it will call the run() method of the parent class using super.run()

• Finally, the walk() method of the pa...read more

String should be preferred for frequent updates due to its immutability.

• String is immutable, so every update creates a new instance, leading to memory overhead.

• StringBuffer is mutable and allows for efficient updates without creating new instances.

• Use StringBuffer when frequent updates are required to avoid unnecessary memory allocation.

• Example: StringBuffer is preferred for building dynamic strings in loops.

To sort a list of students based on their first name, use the Collections.sort() method with a custom Comparator.

• Create a custom Comparator that compares the first names of the students.

• Implement the compare() method in the Comparator to compare the first names.

• Use the Collections.sort() method to sort the list using the custom Comparator.

The task is to convert a Binary Search Tree into a Greater Sum Tree.

• Traverse the BST in reverse inorder (right, root, left) to visit nodes in descending order.

• Keep track of the sum of all greater nodes encountered so far.

• Update the value of each node by adding the sum of greater nodes and update the sum.

• Continue this process until all nodes have been visited.

• Return the modified BST.

Remove duplicates from a sorted array in-place and return the length of the modified array.

• Use two pointers approach to track unique elements and duplicates.

• Modify the input array in-place without using extra space.

• Return the length of the modified array.

Explaining differences between abstract class and interface, throw and throws, and why we use throws. Also, why String is immutable.

• Abstract class can have both abstract and non-abstract methods, while interface can only have abstract methods.

• A class can implement multiple interfaces, but can only extend one abstract class.

• Throw is used to explicitly throw an exception, while throws is used to declare the exceptions that a method may throw.

• We use throws to inform the caller o...read more

The interview questions cover various topics related to Java development, including Singleton pattern, memory management, exception handling, Spring framework, and design patterns.

• Singleton pattern ensures a class has only one instance and provides a global point of access to it.

• Auto Configuration in Spring Boot automatically configures the Spring application based on dependencies present in the classpath.

• @Primary annotation is used to give higher preference to a bean when mu...read more

Find the longest harmonious subsequence in an array where the difference between max and min elements is 1.

• Iterate through the array and count the frequency of each element.

• For each element, check if the count of element+1 is greater than 0, if so, update the length of the harmonious subsequence.

• Return the maximum length found.

Find the maximum element in an array after performing a series of increment operations on specified ranges.

• Initialize an array of size N with all zeros

• Iterate through the operations and increment elements within specified ranges

• Return the maximum element in the array after all operations

Java interview questions on OOPS concepts, polymorphism, exceptions, data structures, and threading.

• OOPS concepts include encapsulation, inheritance, and polymorphism.

• Polymorphism refers to the ability of an object to take on multiple forms.

• Singleton class is a class that can only have one instance, while factory method is a method that creates objects.

• Exception is an error that occurs during program execution, with a hierarchy of exceptions.

• Volatile keyword is used to indica...read more

Java OOPS concepts include inheritance, polymorphism, encapsulation, and abstraction.

• Inheritance allows a class to inherit properties and methods from another class.

• Polymorphism allows objects to take on multiple forms and behave differently based on their context.

• Encapsulation hides the implementation details of a class and only exposes necessary information.

• Abstraction allows for the creation of abstract classes and interfaces that can be implemented by other classes.

• Exampl...read more

Count the frequency of each word in a given string.

• Split the string by spaces to get individual words.

• Use a hashmap to store each word and its frequency.

• Iterate through the words and update the hashmap accordingly.

• Print out the words and their frequencies in any order.

This program returns the length of the longest word from a string whose length is even.

• Split the string into an array of words using a space as the delimiter.

• Initialize a variable to store the length of the longest even word.

• Iterate through each word in the array and check if its length is even.

• If the length is even and greater than the current longest even word length, update the variable.

• Finally, return the length of the longest even word.

Code to filter out loans with incomplete status using Java 8 features.

• Use stream() method to convert the list of loans into a stream

• Use filter() method to filter out loans with incomplete status

• Use collect() method to collect the filtered loans into a new list

Query to find authors who have written more than 10 books

• Use the GROUP BY clause to group the records by author

• Use the HAVING clause to filter the groups with a count greater than 10

• Join the Bookauthor table with the Author table to get the author names

Synchronized methods ensure that only one thread can execute the method at a time per object.

• Synchronized methods lock the object instance, preventing concurrent access.

• When Ob1.M1() is called, it locks the instance of the object Ob1.

• If Ob2.M1() is called on a different instance, it does not block Ob1's execution.

• Both threads will execute M1() one after the other, but independently for each object.

• Example: If Ob1 calls M1() and sleeps, Ob2 can still call M1() without waiting.

This interview question covers various topics including programming, design patterns, data structures, and exception handling in Java.

• Write a program to generate the Fibonacci series

• Write a program using boolean variables

• Explain the ClassCastException and how to handle it

• Discuss the Singleton design pattern and its implementation with different JDK versions

• Explain abstract classes and interfaces in your current project

• Explain hashing in HashMap and the number of buckets

• Differ...read more

Yes, we can keep an object of a Class as a key in HashMap.

• The key in a HashMap can be any non-null object.

• The key's class must override the equals() and hashCode() methods for proper functioning.

• If two objects have the same hashCode(), they are stored in the same bucket and equals() is used to find the correct key-value pair.

• If the key is mutable, its state should not be modified in a way that affects its hashCode() or equals() methods after it is added to the HashMap.

To handle a mutable object inside an immutable class, make the object private and provide only read-only access methods.

• Make the mutable object private to prevent direct modification

• Provide read-only access methods to retrieve the object's state

• If necessary, create defensive copies of the object to ensure immutability

• Avoid exposing any mutator methods that modify the object's state

Not overriding equals method can lead to incorrect comparison of objects. Not overriding hashCode method can lead to incorrect behavior in hash-based data structures.

• If equals method is not overridden, the default implementation from Object class will be used which compares object references.

• This can lead to incorrect comparison of objects where two different objects with same content are considered unequal.

• If hashCode method is not overridden, the default implementation from...read more

Private variables provide encapsulation and data hiding.

• Private variables can only be accessed within the class they are declared in, providing encapsulation and preventing direct modification from outside the class.

• Getters and setters provide controlled access to private variables, allowing for validation and manipulation of the data before it is accessed or modified.

• For example, a class may have a private variable for a person's age, but the getter can return a calculated a...read more

Java is platform independent because it can run on any system with JVM, which is platform dependent due to its need to interact with the underlying hardware.

• Java code is compiled into bytecode, which can be executed on any system with a JVM installed.

• JVM acts as an intermediary between the Java code and the underlying hardware of the system.

• JVM is platform dependent because it needs to interact with the specific hardware and operating system of the system it is running on.

• Exa...read more

Yes, Java is platform-independent because of its 'write once, run anywhere' principle.

• Java programs are compiled into bytecode, which can be executed on any platform with a Java Virtual Machine (JVM).

• The JVM acts as an interpreter, translating the bytecode into machine code specific to the underlying platform.

• This allows Java programs to run on different operating systems and hardware architectures without modification.

• For example, a Java program developed on a Windows machin...read more

JDK is a development kit, JRE is a runtime environment, and JVM is a virtual machine for executing Java code.

• JDK includes JRE and development tools like javac and java

• JRE includes JVM and necessary libraries to run Java applications

• JVM is responsible for interpreting Java bytecode and executing it

• Example: JDK 8 includes JRE 8 and development tools like javac and java

• Example: JRE 8 includes JVM 8 and necessary libraries to run Java applications

The interview questions cover a wide range of topics including design patterns, exception handling, Hibernate, MongoDB, Java collections, Spring framework, and microservices.

• Design patterns like markers interface, functional interface, and Singleton pattern are important in Java development.

• Understanding exception handling with try-catch-finally blocks is crucial for handling errors in Java applications.

• Knowing the differences between load and get in Hibernate, as well as the...read more

Static variables and methods belong to the class rather than instances of the class.

• Static variables are shared among all instances of a class.

• Static methods can be called without creating an instance of the class.

• Example: public static int count = 0; public static void incrementCount() { count++; }