PRODUCTS
Payroll Suite
HR Suite
Talent Suite
Project Services Suite
Meet the platform tailored to your business
Core system of record
One platform for the entire employee journey
BY INDUSTRY
BY COMPANY SIZE
LEARN
EXPLORE KEKA
Java is one of the most widely used programming languages and is frequently used in job interviews for software development roles. During a Java interview, you can expect a range of questions that assess your knowledge and understanding of the language’s concepts, features, and best practices.
The main difference between ArrayList and LinkedList is their underlying data structure. ArrayList uses a dynamic array to store elements, while LinkedList uses a doubly-linked list. ArrayList provides faster access to elements using indexes, but LinkedList performs better when adding or removing elements from the middle of the collection.
The Map interface in Java Collections is used to store key-value pairs. It provides methods to add, remove, and retrieve values based on their associated keys. Some commonly used implementations of Map interface are HashMap, TreeMap, and Linked HashMap.
HashMap and Hash Table are both implementations of the Map interface, but there are a few differences between them. HashMap is not synchronized and allows null keys and values, whereas Hash Table is synchronized and doesn’t allow null keys or values. Additionally, HashMap is generally considered more efficient in terms of performance.
HashSet and TreeSet are both implementations of the Set interface, but they have some differences. HashSet doesn’t maintain any order of elements and allows null values, while TreeSet stores elements in sorted order (according to their natural ordering or a custom Comparator) and doesn’t allow null values.
ArrayList and Vector are both dynamic array implementations, but Vector is synchronized, whereas ArrayList is not. This means that Vector is thread-safe, but it may have a performance impact in single-threaded scenarios. In most cases, ArrayList is preferred over Vector.
The Comparable interface is used to define the natural ordering of objects. It provides a method called compareTo that is used to compare two objects and determine their relative order. Classes that implement Comparable can be sorted using methods like Collections. sort().
Fail-fast and fail-safe iterators are two different approaches to handling concurrent modifications during iteration.
The Comparator interface is used to define custom comparison logic for objects. It provides a method called “compare” that takes two objects and returns an integer value indicating their relative order. Comparator allows sorting objects based on different criteria without modifying their original implementation.
HashSet and LinkedHashSet are both implementations of the Set interface, but they differ in how they maintain the order of elements:
The Collections class in Java provides various utility methods for working with collections. It contains static methods that operate on or return collections, including sorting, searching, and modifying collections.
A class is a blueprint or template that defines the properties and behaviors of an object. An object is an instance of a class that represents a real-world entity. In simpler terms, a class is like a blueprint, and an object is the actual building created from that blueprint.
The four principles of object-oriented programming are:
Encapsulation: The bundling of data and methods together within a class.
Inheritance: The ability to create new classes based on existing classes.
Polymorphism: The ability to use a single interface to represent different types of objects.
Abstraction: The process of hiding unnecessary details and exposing only essential features.
Method overloading occurs when multiple methods in the same class have the same name but different parameters. Method overriding, on the other hand, happens when a subclass provides its implementation of a method that is already defined in its superclass.
A constructor is a special method that is used to initialize objects of a class. It has the same name as the class and is called automatically when an object is created. Constructors can be used to set initial values for object attributes or perform any other necessary setup tasks.
Static variables/methods belong to the class itself and are shared among all instances of the class. Non-static variables/methods are specific to each instance of the class. Static variables/methods can be accessed without creating an instance of the class, whereas non-static variables/methods require an object to be created first.
The “final” keyword can be used in three different contexts:
Composition and inheritance are two ways to achieve code reuse. Inheritance allows a class to inherit the properties and methods of another class, promoting an “is-a” relationship. Composition, on the other hand, involves creating an instance of another class within a class, promoting a “has-a” relationship.
The “this” keyword is a reference to the current object. It is often used to differentiate between instance variables and method parameters that have the same name. It can also be used to invoke other constructors in the same class.
Method overloading is the ability to define multiple methods with the same name but different parameters within a class. Java determines which method to call based on the number, type, and order of the arguments passed during method invocation.
An abstract class is a class that cannot be instantiated but can be extended by other classes. It serves as a blueprint for its subclasses, defining common properties and methods. Abstract classes may contain abstract methods, which are declared without implementation and must be implemented by the concrete subclasses.
A string in Java is an object that represents a sequence of characters. It is used to store and manipulate textual data.
You can create a string object in Java by using the new keyword and the String class constructor, or by directly assigning a value to a string variable using double quotes.
Example:
String str1=new String(“Hello”);
String str2= “World”;
String objects are immutable, meaning their values cannot be changed after they are created. Each modification to a string results in creation of a new string object.
StringBuilder and StringBuffer are mutable classes that can be used to modify strings. They provide methods for appending, inserting, and deleting characters in a string. The main difference between them is that StringBuffer is thread-safe (synchronized) while StringBuilder is not.
In Java, you can concatenate strings using the + operator or the concat() method.
Example using the + operator:
String str1=”Hello”;
String str2= “World”;
String result= str1+ ” “+str2; // Concatenation using +
Example using the concat() method:
String str1=”Hello”;
String str2= “World”;
String result = str1.concat(” “) concat(str2);// Concatenation using concat( )
No, you cannot directly modify a string in Java because strings are immutable. However, you can perform operations on strings to create a new modified string.
The equals() method is used to compare the contents of two string objects for equality. It checks if the characters in the strings are the same. The == operator, on the other hand, checks if two string references point to the same object in memory.
String str1 = “Hello”;
String str2 = “Hello”;
String str3 = new String(“Hello”);
System.out.println(str1.equals(str2)); // true
System.out.println(str1 == str2); // true
System.out.println(str1.equals(str3)); // true
System.out.println(str1 == str3); // false
You can convert a string to uppercase or lowercase in Java using the toUpperCase() and toLowerCase() methods, respectively.
Example:
String str = “Hello World”; String uppercase = str.toUpperCase(); // Converts to uppercase String lowercase = str.toLowerCase(); // Converts to lowercase
In Java, the length() method is used to get the number of characters in a string, while the size() method is not a valid method for strings. The size() method is commonly used with collections such as lists or sets to get the number of elements.
You can check if a string contains a specific substring in Java using the contains() method or by using the indexOf() method to find the position of the substring.
Example using contains() method:
String str = “Hello World”;
boolean containsSubstring = str.contains(“World”); // true
Example using indexOf() method:String str = “Hello World”;
int index = str.indexOf(“World”);
boolean containsSubstring = index != -1; // true if the substring is found
You can reverse a string in Java by converting it to a StringBuilder or StringBuffer object and then using the reverse() method.
String str = “Hello”; StringBuilder reversed = new StringBuilder(str).reverse(); String result = reversed.toString();
Multithreading in Java refers to the concurrent execution of two or more parts of a program, where each part is known as a thread. Threads allow programs to perform multiple tasks simultaneously.
There are two ways to create a thread in Java:
The Thread class represents an actual thread, while the Runnable interface defines the task that a thread will execute. By implementing Runnable, you can achieve better separation of concerns and improve code reusability.
You can start a thread by calling its start() method. This method internally calls the run() method of the thread, which contains the code to be executed concurrently.
The start() method is used to start a new thread and internally calls the run() method. The run() method contains the code to be executed by the thread and should not be called directly if you want to achieve concurrent execution.
Thread synchronization can be achieved using:
These methods are used for inter-thread communication in Java.
Deadlock occurs when two or more threads are blocked forever, waiting for each other to release resources. Deadlock can be avoided by using proper synchronization, avoiding nested locks, and implementing timeouts.
The volatile keyword is used to indicate that a variable’s value may be modified by multiple threads. It ensures that changes made to the variable by one thread are immediately visible to other threads.
Multithreading in Java offers several benefits, including:
Subscribe to keep up with the latest strategic finance content.
Request a demo
Login
