Programs
Updated on February 18, 2025
Among the most commonly used programming languages in the world, Java holds a significant importance in developing software applications. Unlike other complex language methods like C++, Java is known for its simplicity and robust performance. Moreover, many businesses look for Java developers to design and manage their programs. Nevertheless, being prepared for core Java interviews can be difficult though having knowledge of common questions can make a big difference.
This blog will discuss the core Java interview questions for different experience levels. We will begin with freshers’ questions and then go on to intermediate coding issues and finally advanced concepts for experts. This guide will help you to prepare thoroughly and boost your confidence for your next Java interview.
Java is a high-level class-based object-oriented programming language, specially designed to reduce the number of dependencies while program implementation. Java was developed by Sun Microsystems in 1995 and is currently owned by Oracle.
Using the Java Virtual Machine (JVM), Java applications can be easily compiled into bytecode that can run on any computer architecture. Hence, portability can be said to be one of the most important key strengths of Java.
| Feature | Instance Variable | Class Variable |
| Declaration | Inside a class but outside any method | Inside a class, using the static keyword |
| Scope | Specific to an instance of the class | Shared among all instances of the class |
| Memory Allocation | Allocated when an instance is created | Allocated once when the class is loaded |
| Access | Accessed using an instance of the class | Accessed using the class name |
Object class in Java serves as the superclass for all other classes. Unless explicitly stated otherwise, every class in Java implicitly inherits from the Object class.
Constructors are special methods in Java that are used in instantiating objects which refers to creating an instance or occurrence of anything such as a class or struct., It has no return type and must have the same name as the class itself i.e., the constructor name should be the same as its class name including case letter sensitivity. There exist two types of constructors:
| Access Specifier | Visibility | Class | Package | Subclass | Global |
| private | Only within the same class | Yes | No | No | No |
| default | (no modifier) | Within the same package | Yes | Yes | No |
| protected | Within the same package and subclasses | Yes | Yes | Yes | No |
| public | Anywhere | Yes | Yes | Yes | Yes |
Java is platform-independent due to the fact that it is compiled into bytecode, a kind of intermediate code. Java compiler transforms Java source code into JVM instructions which can then be executed directly by JVM just in time or saved as machine code before execution. Because there are many operating systems with JVMs, the same bytecode would run on any OS that has a compatible JVM. This ability to “write once and run anywhere” is one of the key features of Java.
| Feature | FileInputStream | FileOutputStream |
| Purpose | Reads raw byte data from a file | Writes raw byte data to a file |
| Usage | Suitable for reading binary data like images | Suitable for writing binary data like images |
| Methods | read(), read(byte[] b), close() | write(int b), write(byte[] b), close() |
| Constructor | FileInputStream(String name) | FileOutputStream(String name) |
| Example Usage | FileInputStream fis = new FileInputStream(“file.txt”); | FileOutputStream fos = new FileOutputStream(“file.txt”); |
This is the method used as the entry point of any Java application, written as a whole command line and we can break down each part as:
Method refers to a specific block of code that performs any specific tasks, commonly used to execute code to avoid any redundancy and to make the code more modular. It can be also called an instance of that class because a method can be defined within a class. Methods can accept parameters and return values. The syntax for defining a method is:
returnType methodName(parameters) {
// method body
}
| Feature | equals() | == |
| Purpose | Checks the logical equality of two objects | Checks reference equality (if two references point to the same object) |
| Method Type | The method from Object class can be overridden | Operator |
| Usage | obj1.equals(obj2) | obj1 == obj2 |
Java does not support any type of destructors, unlike the destructors in C++, because Java primarily relies on automatic garbage collection to handle memory leaks and the efficiency of the program. The memory which is no longer in use is directly collected by an automatic garbage collector and deallocated.
| Feature | this() | super() |
| Usage | Calls another constructor in the same class | Calls a constructor in the parent class |
| Position | It must be the first statement in a constructor | It must be the first statement in a constructor |
| Use Case | Used to initialise the current class’s constructor | Used to initialise the parent class’s constructor |
Program:
public class Main {
public static void main(String[] args) {
int a = 5;
int b = 10;
System.out.println(a + b);
}
}
Answer: 15
There are several ways to create objects in Java:
Example obj = new Example();
Example obj = (Example) Class.forName(“Example”).newInstance();
Example obj1 = new Example();
Example obj2 = (Example) obj1.clone();
Example obj = Example.createInstance();
ObjectInputStream in = new ObjectInputStream(new FileInputStream(“file.ser”));
Example obj = (Example) in.readObject();
Rather than any particular instance of a class, the static methods and variables can be directly associated with the class. They can be accessed directly with the help of a class name and do not create any instance of that class.
| Feature | Instance Variables | Local Variables |
| Declaration | Inside a class, outside any method | Inside a method, constructor, or block |
| Scope | Belongs to an instance of the class | Belongs to the method, constructor, or block |
| Default Value | Initialised to default value if not set | Must be explicitly initialised before use |
| Lifespan | Exists as long as the object exists | Exists only during method execution |
| Access Modifiers | Can use access modifiers | Cannot use access modifiers |
Classes in Java define a code block using methods, attributes, variables, and different data types that work on one single unit of logic. Hence classes are considered as blueprints in Java programming language and hold information to define the behaviour of the objects.
Syntax of a class:
public class ClassName {
// fields
int number;
String name;
// methods
void display() {
System.out.println(“Number: ” + number + “, Name: ” + name);
}
}
Static classes do not have permission to access instance variables and methods of any outer class. Rather, static classes are nested classes which can access the static member of the outer class.
Syntax of a static class:
public class OuterClass {
static class StaticNestedClass {
void display() {
System.out.println(“This is a static nested class.”);
}
}
}
An object can be considered as an instance of a class, which is created from classes, representing different entities that have the behaviour patterns defined by that class. Here each object can have its own set of values for the variables and methods defined in the class.
ClassName obj = new ClassName();
In Java, there are four types of scopes:
One of the important parts of java.util package is the collection module which can provide many different classes and interfaces for manipulation of objects, ArrayList, HashSet, HashMap, LinkedList, etc.
| Feature | Array | ArrayList |
| Size | Fixed-size | Dynamic size (can grow and shrink) |
| Type | Can hold primitive types and objects | Can hold only objects |
| Performance | Faster due to fixed size | Slower due to dynamic resizing |
| Methods | Does not provide built-in methods for manipulation | Provides methods like add(), remove(), get() |
| Syntax | int[] arr = new int[10]; | ArrayList<Integer> list = new ArrayList<>(); |
Program:
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[2]);
}
}
Answer: 3
Program:
public class Main {
public static void main(String[] args) {
String greeting = “Hello”;
String name = “World”;
System.out.println(greeting + “, ” + name + “!”);
}
}
Answer: Hello, World!
JVM(Java Virtual Machine): The abstract machine that enables Python applications to run on any device or operating system; this reads and interprets Python bytecode instructions
JRE (Java Runtime Environment): JRE can provide many different libraries by executing Python programs, but the compilers and debuggers do not exist as they only support Python interpreters.
JDK (Java Development Kit): JDK is the complete kit for software development that includes JRE, a loader/interpreter (Java), a compiler (javac), an archiver (jar), a documentation generator (Javadoc) and many other different tools.
| Feature | HashMap | HashTable |
| Synchronisation | Not synchronised (thread-unsafe) | Synchronized (thread-safe) |
| Null keys/values | Allows one null key and multiple null values | Does not allow null keys or values |
| Performance | Faster due to lack of synchronisation | Slower due to synchronisation |
| Iteration | Uses fail-fast iterator | Uses fail-safe iterator |
| Legacy | Part of Java Collections Framework | Legacy class, part of earlier versions |
Program:
public class Main {
public static void main(String[] args) {
int x = 10;
if (x > 5) {
System.out.println(“x is greater than 5”);
} else {
System.out.println(“x is not greater than 5”);
}
}
}
Answer: x is greater than 5
The JVM divides memory into several distinct areas for efficient management:
| Type | Data Type | Size (bits) | Default Value |
| Primitive | byte | 8 | 0 |
| short | 16 | 0 | |
| int | 32 | 0 | |
| long | 64 | 0L | |
| float | 32 | 0.0f | |
| double | 64 | 0.0d | |
| char | 16 | ‘u0000’ | |
| boolean | 1 | false | |
| Non-primitive | String, Arrays, Classes, Interfaces | – | null |
Byte data is generally used to save memory in data types like large arrays. Also, this can help when you work with different streams of data from a network or I/O file. A byte data represents 8-bit signed integers, ranging from -128 to 127.
A class variable is declared outside any method or constructor and also declared as a static variable using a static keyword. The class variable is shared among all the instances of that class, making it only one copy of the static variable per class.
Example:
public class Example {
static int classVariable = 10;
}
Local variables do not have a default value. Local variables can only be explicitly initialised before they can be used.
Program:
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
System.out.println(i);
}
}
}
Answer:
0
1
2
| Feature | System.out | System.err | System.in |
| Purpose | Standard output stream | Standard error stream | Standard input stream |
| Usage | Used to display output to the console | Used to display error messages to the console | Used to read input from the console |
| Stream Type | PrintStream | PrintStream | InputStream |
| Buffering | Buffered | Buffered | Buffered |
| Typical Use | Normal program output | Error messages and diagnostics | Reading user input |
To perform the input and output operations in Java, the IO stream library is used because it can represent the input source or the output destination, which can be a disk file, current device or another program.
Java supports a wide range of operators:
Program:
public class Main {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
}
System.out.println(sum);
}
}
Answer: 15
| Feature | >> (Signed Right Shift) | >>> (Unsigned Right Shift) |
| Usage | Shifts bits to the right, preserving the sign bit (sign-extended) | Shifts bits to the right, zero-filling the leftmost bits (zero-filled) |
| Behaviour with Negative Numbers | Preserves the sign bit (negative numbers remain negative) | Does not preserve the sign bit (negative numbers become positive) |
| Example | -8 >> 2 results in -2 | -8 >>> 2 results in 1073741822 |
Array in Java helps to store, manage, rearrange and sort data elements in a single variable as a list. You can store the same data type elements in one array which will act as a whole one variable, mainly helping in data handling and data manipulating. We do not have to assign each element as a new variable, as it would be a very unprofessional method of pruning errors.
Example:
int[] numbers = new int[5];
numbers[0] = 10;
numbers[1] = 20;
A sequence of characters put together can be represented whole as a string. In Java, the strings are immutable, hence once a String object is created, its value cannot be changed again.
Example:
String message = “Hello, World!”;
Java supports two types of comments:
There are several ways to copy an array in Java:
Hare, Java cannot be called a purely object-oriented language because it supports primitive data types such as int, char, and byte which cannot be called class objects. Everything must be treated as an object in any purely object-oriented learning language.
Constructors are special methods used to initialise objects. There are two main types of constructors in Java:
| Constructor Type | Description | Syntax Example |
| Default Constructor | No arguments are provided by the compiler if no other constructors are defined. | public Example() {} |
| parameterised Constructor | Takes arguments to initialise fields with specific values. | public Example(int value) { this.value = value; } |
If no other constructors are created by us, a default constructor is created by the compiler automatically in Java, which helps to provide a default initialisation to an object. Default constructors do not require any parameters and automatically set the fields to their default values.
Program:
public class Main {
public static void main(String[] args) {
String str = “Java”;
System.out.println(str.length());
}
}
Answer: 4
| Feature | Array | Collection |
| Type | Fixed-size holds elements of a single type | It can be dynamically resized and can hold different types |
| Data Structures | Only linear data structures | Includes List, Set, Queue, Map |
| Methods | Limited methods for manipulation | Rich API for manipulation (add, remove, iterate) |
| Syntax | int[] arr = new int[10]; | Collection<Integer> collection = new ArrayList<>(); |
The super keyword in Java is used to refer to the immediate parent class object. It is commonly used to:
Program:
public class Main {
public static void main(String[] args) {
String str = “Hello”;
char ch = str.charAt(1);
System.out.println(ch);
}
}
Answer: e
| Feature | HashSet | TreeSet |
| Order | Does not guarantee any order of elements | Maintains elements in ascending order |
| Performance | Offers constant time performance for basic operations like add, remove, and contains | Offers log(n) time performance for basic operations |
| Null Elements | Allows one null element | Does not allow null elements |
| Backed By | Backed by a HashMap | Backed by a TreeMap |
| Usage | Use it when you don’t need a sorted order | Use when you need elements in sorted order |
Program:
public class ReverseString {
public static void main(String[] args) {
String original = “Hello, World!”;
String reversed = reverseString(original);
System.out.println(“Reversed: ” + reversed);
}
public static String reverseString(String str) {
StringBuilder sb = new StringBuilder(str);
return sb.reverse().toString();
}
}
The final keyword in Java is used to restrict the modification of variables, methods, and classes. It can be applied in three contexts:
| Feature | break | continue |
| Usage | Exits the loop or switch statement immediately | Skips the current iteration and proceeds to the next iteration |
| Control Flow | Transfers control outside the loop | Transfers control to the beginning of the loop |
| Use Case | Use to terminate a loop or switch statement early | Use to skip certain iterations within a loop |
Program:
public class Main {
public static void main(String[] args) {
int a = 5;
int b = 2;
System.out.println(a / b);
}
}
Answer: 2
| Feature | Static Methods | Non-static Methods |
| Access | It can be called without creating an instance | Requires an instance of the class to be called |
| Usage | Used for operations that don’t require data from an instance | Used for operations that work on the instance data |
| Memory Allocation | Allocated memory only once when the class is loaded | Allocated memory every time an instance is created |
| Access to Members | Can access static variables and other static methods directly | Can access all variables and methods (including static) |
Packages in Java provide several advantages:
Program:
public class Main {
public static void main(String[] args) {
double a = 5.0;
double b = 2.0;
System.out.println(a / b);
}
}
Answer: 2.5
Program:
public class Main {
public static void main(String[] args) {
String text = “Java Programming”;
System.out.println(text.substring(5, 16));
}
}
Answer: Programming
| Feature | C++ | Java |
| Platform Dependency | Platform-dependent (compiled to machine code) | Platform-independent (compiled to bytecode) |
| Memory Management | Manual (using pointers) | Automatic (using garbage collection) |
| Multiple Inheritance | Supported (using classes) | Not supported (achieved using interfaces) |
| Operator Overloading | Supported | Not supported |
| Pointers | Supported | Not supported |
| Global Variables | Supported | Not supported |
| Templates/Generics | Templates | Generics |
A ClassLoader in Java is a part of the Java Runtime Environment that dynamically loads Java classes into the Java Virtual Machine. It is a subsystem used to load class files. Java provides three built-in class loaders:
| Feature | Heap Memory | Stack Memory |
| Storage | Stores objects and instance variables | Stores method frames and local variables |
| Memory Management | Managed by the Garbage Collector | Managed by the Java Virtual Machine (JVM) |
| Lifespan | Exists as long as the application runs | Exists only for the duration of a method call |
| Memory Allocation | Dynamic (size can grow or shrink) | Static (fixed size) |
| Access Speed | Slower access | Faster access |
Java has several types of memory allocations:
| Feature | Constructors | Destructors |
| Purpose | Initialise new objects | Clean up resources before an object is destroyed (not present in Java) |
| Invocation | Called automatically when an object is created | Called when an object is destroyed (not applicable in Java) |
| Parameters | Can have parameters (parameterised Constructors) | N/A (Java uses finalize() for cleanup, but it is not recommended) |
| Overloading | Can be overloaded (multiple constructors) | N/A |
| Example Language | Java, C++ | C++ (Java does not have destructors) |
Program:
public class Main {
public static void main(String[] args) {
String s1 = “Hello”;
String s2 = “Hello”;
String s3 = new String(“Hello”);
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s3));
}
}
Answer:
true
false
true
Program:
public class Main {
public static void main(String[] args) {
int x = 10;
int y = 0;
try {
int z = x / y;
} catch (ArithmeticException e) {
System.out.println(“Cannot divide by zero”);
} finally {
System.out.println(“This is the finally block”);
}
}
}
Answer:
Cannot divide by zero
This is the finally block
Program:
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
for (int i = 0; i < list.size(); i++) {
list.remove(i);
}
System.out.println(list);
}
}
Answer:
[2]
| Feature | Set | List |
| Order | Does not maintain any order | Maintains the insertion order |
| Duplicates | Does not allow duplicate elements | Allows duplicate elements |
| Access Methods | No methods to access elements by index | Allows access to elements by index |
| Common Implementations | HashSet, TreeSet, LinkedHashSet | ArrayList, LinkedList |
| Usage | Ideal for unique elements | Ideal for an ordered collection of elements |
If you do not use the static modifier with the main method, the Java Virtual Machine (JVM) will not be able to invoke it as the entry point for the program. When you are using the main method, it must be public, static, and void for the JVM to start the execution of the program. Without using the static keyword, the main method would require an instance of the class to be created before it can be called. This will hinder the purpose of having a standard entry point to start the program execution, resulting in a runtime error.
public class Main {
public static void main(String[] args) {
String s1 = “Java”;
String s2 = “Programming”;
String s3 = s1.concat(s2);
System.out.println(s3);
}
}
Answer:
JavaProgramming
Yes, we can overload the main() method in Java. However, as the entry point of the program will be the public static void main(String[] args), the JVM will only call this main method with this exact signature. Any other overloaded versions of the main can be called from within the program using any other method but it will not be called by JVM.
| Feature | Python | Java |
| Typing | Dynamically typed | Statically typed |
| Syntax | Easier and more concise | More verbose |
| Memory Management | Automatic (Garbage Collection) | Automatic (Garbage Collection) |
| Use Cases | Web development, scripting, data science | Enterprise applications, Android development |
| Inheritance | Supports multiple inheritance directly | Supports multiple inheritance via interfaces |
Packages can be defined as a set of different but related classes and interfaces that can provide any access protection in Java. It can also handle namespace management, making it an overall way to manage large codebases and their internal conflicting names.
Program:
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put(“A”, 1);
map.put(“B”, 2);
map.put(“A”, 3);
System.out.println(map.size());
System.out.println(map.get(“A”));
}
}
Answer:
2
3
The Wrapper class in Java provides a way to use primitive data types (int, char, etc.) as objects. Each primitive type has a corresponding wrapper class:
Wrapper classes are used in collections, where only objects are allowed, and to utilise utility methods provided by these classes.
There are several ways to take input from the console in Java:
| Method | Description | Example Usage |
| Prints the text without a newline at the end | System.out.print(“Hello”); | |
| println | Prints the text with a newline at the end | System.out.println(“Hello”); |
| printf | Prints formatted text using format specifiers | System.out.printf(“Hello, %s!”, “World”); |
The main concepts of Object-Oriented Programming (OOP) in Java are:
| Feature | Constructors | Methods |
| Purpose | Initialise new objects | Define the behaviour and operations of objects |
| Name | Same as the class name | Can have any name |
| Return Type | No return type | Must have a return type (void or other) |
| Invocation | Called automatically when an object is created | Called explicitly using the object |
| Overloading | Can be overloaded | Can be overloaded |
An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance fields or constructors. They are used to specify a set of methods that one or more classes must implement, promoting a form of multiple inheritance and providing a way to achieve abstraction.
Example:
public interface Animal {
void eat();
void sleep();
}
Wrapping the data or variables and the code that is acting upon the data methods together to form a single unit is called encapsulation in Java. The main advantage of encapsulation is to protect the data from any unauthorised access.
So that no one can modify the data without permission, which is a very important part of the project, it can be achieved through declaring variables as private using private keywords and also providing public getter and setter methods to access and update the values of those variables.
This can be understood as a form of association where there is a class reference to any other class, but both classes can exist without depending on each other. It represents a “has-a” relationship. For example, a Library has Books, but Books can exist independently of the Library.
Pointers are not used in Java to maintain simplicity and security. One of the primary reasons for this is that most of the time, pointers can lead to complex code which is difficult for error handling. Situations like memory leaks and pointer arithmetic errors can occur due to pointers. Hence by eliminating pointers, Java provides a safer programming environment.
This is the mechanism which has shared control access according to resources to better manage the permission. It allows only one thread to access a synchronised block of code or any synchronised method block while executing a program, providing mutual exclusion.
Multi-threading in Java is a feature that allows concurrent execution of two or more threads for maximum utilisation of the CPU. Each thread runs parallel to others, enabling multiple tasks to be performed simultaneously within a single program. Multi-threading is commonly used in applications where tasks are independent and can run simultaneously, such as web servers, GUI applications, and real-time systems.
| Feature | Pros | Cons |
| Thread Safety | Ensures data consistency and prevents corruption | This can lead to contention, reducing performance |
| Predictability | Provides controlled access to shared resources | Increases complexity in code |
| Consistency | Guarantees that critical sections are executed in a controlled manner | It can cause deadlocks if not handled properly |
| Simplified Access | Simplifies reasoning about concurrent code | Can reduce scalability in highly concurrent systems |
The covariant return type allows a method in a subclass to override a method in its superclass and return a type that is a subclass of the return type declared in the superclass method. This enhances flexibility and reusability in method overriding.
Example:
class Animal {
Animal get() {
return this;
}
}
class Dog extends Animal {
@Override
Dog get() {
return this;
}
}
To showcase if the field should not be serialised, the transient keyword is used. When any object is serialised, transient fields are skipped and then they will not be a part of the object’s persistent state. This is useful for fields that contain sensitive information or are not needed after deserialization.
Example:
class User implements Serializable {
private String username;
private transient String password; // This field will not be serialised
}
| Feature | sleep() | wait() |
| Class | Thread class | Object class |
| Purpose | Pauses the current thread for a specified time | Causes the current thread to wait until another thread invokes notify() or notifyAll() |
| Synchronisation | Do not release the lock | Releases the lock on the object |
| Usage | Thread.sleep(milliseconds) | object.wait() |
| Exception | Throws InterruptedException | Throws InterruptedException |
Association in Java is a relationship between two classes that enables one class to use functionalities provided by another class. It represents a “uses-a” relationship. Association can be one-to-one, one-to-many, many-to-one, or many-to-many. It describes how objects of different classes interact with each other.
Program:
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> list = Arrays.asList(“abc”, “bcd”, “cde”);
List<String> result = list.stream()
.filter(s -> s.startsWith(“b”))
.collect(Collectors.toList());
System.out.println(result);
}
}
Answer:
[bcd]
Polymorphism refers to the ability of object-oriented programming to represent any object in many forms. It allows one interface to be used for a general class of actions and its types are:
| Feature | Composition | Aggregation |
| Relationship Type | Strong ownership and lifecycle dependency | Weak ownership and an independent life cycle |
| Lifespan | The contained object’s lifespan depends on the container object | Contained objects can exist independently |
| Example | A Car has an Engine (composition) | A Library has Books (aggregation) |
| Implementation | Contained object created within the container | Contained object passed to the container |
| Use Case | Use when contained objects should not exist independently | Use when contained objects can exist independently |
The main interfaces of the Java Collection framework are:
Program:
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
Stream.of(“apple”, “banana”, “cherry”)
.filter(s -> s.contains(“a”))
.map(String::toUpperCase)
.forEach(System.out::println);
}
}
Answer:
APPLE
BANANA
A vector can be a dynamic array that does not have any fixed size, i.e. it can grow or shrink in size according to the data input. Vectors are generally synchronised and thread-safe, hence they can be applied safely in multi-threaded environments. However one of the drawbacks of this is slow performance speed because of synchronisation.
Features of Vector:
Here you should use the Collections.unmodifiableList to make a Java ArrayList read-only. This method helps prevent any unnecessary modifications by returning an unmodified view of the specified list.
Example:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add(“A”);
list.add(“B”);
list.add(“C”);
List<String> readOnlyList = Collections.unmodifiableList(list);
System.out.println(readOnlyList); // Output: [A, B, C]
// The following line will throw UnsupportedOperationException
// readOnlyList.add(“D”);
}
}
This is a type of queue where you can put each element with a certain order or criteria, natural ordering or also by a comparator ordering at the time of queue construction. In the queue, the last element will be the head according to the specified ordering and elements are dequeued in the same order.
Features of PriorityQueue:
| Feature | Iterator | ListIterator |
| Applicable Collections | All Collection types | Only List types |
| Traversal Direction | One-way traversal (forward) | Two-way traversal (forward and backwards) |
| Add Elements | Cannot add elements | Can add elements |
| Modify Elements | Can remove elements | Can remove and set elements |
| Methods | hasNext(), next(), remove() | hasNext(), next(), hasPrevious(), previous(), add(), set(), remove() |
In conclusion, exercising these concepts is very essential for you to prepare for a Java interview. Starting from all the basic concepts like data types, and loops and taking it further to more advanced topics such as concurrency, stream API collections, etc. are very crucial for your preparation for the Java developer role.
Hope this extensive post for providing different Java interview questions helped you prepare for your next Java interview. Keep practising and stay updated regarding new technologies and advancements in Java like new tools or frameworks, updates in Java version and focus on clean code writing which is efficient.
Accelerator Program in Business Analytics, Data Science & Data Engineering
Integrated Program in Data Science, AI and ML
Accelerator Program in AI and Machine Learning
Advanced Certification Program in Data Science & Analytics
Certificate Program in Full Stack Development with Specialization for Web and Mobile
Certificate Program in DevOps and Cloud Engineering
Certificate Program in Application Development
Certificate Program in Cybersecurity Essentials & Risk Assessment
Postgraduate Program in Cloud Computing & DevOps Engineering
Integrated Program in Finance and Financial Technologies
Certificate Program in Equity Research and Trading
Certificate Program in Financial Analysis, Valuation and Risk Management
© 2024 Hero Vired. All rights reserved
