Explore topic-wise InterviewSolutions in .

Order of specifiers doesn’t MATTER in Java. The static public VOID will work for sure and the program WOULD COMPILE and run correctly.

Yes, we can declare the main method as FINAL LIKE:

The garbage collector is run using the System.gc() METHOD in Java. The use of this method is an indicator to the JVM to recycle the unused objects so that the memory can be freed and available for quick reuse as required. The System.gc() method does not return any values.

A program that DEMONSTRATES this method is given as follows:

The output of the above program is as follows:

Collections in Java is BASICALLY a framework that allows the storage and manipulation of a group of objects by providing an architecture. All the possible operations in Java such as searching, sorting, deletion, insertion etc. can be performed using the Java Collections.

Some of the best practices related to the Collections Framework in Java are given as follows:

• Using Arrays and Collections utility classes

The Arrays and Collections utility classes provided by the Java Collections Framework should be used as required as they PROVIDE many useful methods to search, sort and MODIFY ELEMENTS in a collection

• Do not use the classic for loop

Instead of using a classic for loop to iterate a list collection, use an iterator. This is because if the for loop variable is altered inside the loop, it can lead to bugs.

• Choosing the right collections

Before using collections, the right collection needs to be chosen according to the problem that needs to be solved.

• Using the Stream API on collections

There is a stream method in every collection in Java 8 that returns a stream of elements. This MEANS that the aggregate functions can be easily performed using the Stream API.

• Prefer isEmpty() over size()

The isEmpty() method should be preferred over the size() method to check the emptiness of a collection. Even though there is performance difference between these two methods, this is done to enhance the readability of this code.

• Do not return null in a method that returns a collection

If a method returns a collection, then it should not return null if there is no element in the collection. Instead, it should return an empty collection.

• Specify initial capacity of a collection if possible

The initial capacity of a collection is always specified by an overloaded constructor that is contained in almost all concrete collection classes.

A STATIC nested class is a nested class DECLARED as static. A nested class can’t ACCESS the data members and METHODS of the outer class.

Pointers are considered unsafe in Java, so it does not SUPPORT it. The LACK of pointers is to STOP Java PROGRAMS from referencing MEMORY locations illegally.

The variable length arguments come into picture when you do not initially know the number of arguments PASSED to the method.

The variable length arguments can be zero or more. An example is shown below:

The above program displays the following output:

The following are the TYPES of Base64 ENCODING:

• Simple: The OUTPUT is mapped to a set of characters lying in A-Za-z0-9+/.
• URL: The output is mapped to set of characters lying in A-Za-z0-9+_.
• MIME: The output is mapped to MIME friendly FORMAT. It is represented in lines of no more than 76 characters each, and uses a carriage return '\r' followed by a linefeed '\n' as the line separator.

The Process API now provide more INFORMATION like:

• Process's native process ID,
• Accumulated CPU TIME,
• PARENT process
• Method to destroy a process
• Process’s Descendants, ETC.

A method has a return TYPE UNLIKE constructor. Constructor is invoked implicitly. Whereas method is invoked explicitly.

The NAME of the constructor is the same as the class name. HOWEVER, the name of the method may or may not be same as the name of the class.

To SERIALIZE an OBJECT, USE the ObjectOutputStream CLASS.

If you want to reorder OUTPUT in Java, then use Argument Index.

Let’s say the output is:

And you want to reorder and display it as:

For this, use the Argument Index as shown in the FOLLOWING example:

The above example displays that we have reordered the output:

The following are the RESTRICTIONS applied to STATIC METHODS in Java:

• Static method can access only static TYPE data.
• These methods cannot invoke non-static method directly.
• The ‘this’ and ‘super’ cannot be used in static context.
• You can’t override static methods in a subclass

When an EXCEPTION is thrown from the TOP of the stack, exception propagation OCCURS. Here are some of the points when the exception is not caught:

• The exception drops down the call stack of the PRECEDING METHOD.
• If it is still not caught there itself, it further goes down to the preceding method.
• The above goes till the method reaches the bottom of the call stack
• This can also go on till it is caught somewhere in between.

The collection classes that are thread safe in Java are Stack, Vector, Properties, Hashtable ETC. Details about some of these collection classes are given as follows:

Stack class in Java

The Stack class in Java implements the stack data structure that is based on the principle of LIFO. So, the stack class can provide many operations such as push, pop, peek, search, empty etc.

A program that demonstrates the Stack class is given as follows:

The output of the above program is as follows:

Vector class in Java

An array of OBJECTS that grows as required is implemented by the Vector class in Java. A program that demonstrates the Vector class is given as follows:

The output of the above program is as follows:

Covariant return TYPES REFER to the return type of the overriding method. It is possible to have DIFFERENT return types for overriding methods in the child class since Java 5. HOWEVER, the return type of the child class should be a subtype of the return type of the parent class.

A program that demonstrates covariant return type in Java is given as follows:

The output of the above program is as follows:

The above program demonstrates covariant return type as the return type of the class C1 ret() method is C1 while the return type of the class C2 ret() method is C2 and it is method overriding while both methods have different return types.

An immutable class in Java is one that cannot change its state after its construction. Some of the requirements to create an immutable class in Java are GIVEN as FOLLOWS:

1. The class should be final so that other classes can’t extend it.
2. All the fields of the class should be final so that they are only initialized one time inside the constructor.
3. Setter methods should not be exposed.
4. A new instance of the class should be returned if any methods that MODIFY the state of the class are exposed.
5. If there Is a mutable object inside the constructor, only a clone copy of the passed argument should be USED.

An example that demonstrates the creation of an immutable class in Java is given as follows:

The class given above is a basic immutable class. This class does not contain any mutable object or any setter methods. This type of a basic class is normally used for caching purposes.

The CONSTRUCTORS aren’t INHERITED in JAVA.

A method is created to sort the HashMap according to VALUE. The HashMap contains the names of 5 students as the key and their average marks as the value. Therefore, the HashMap is sorted according to the marks obtained by the students.

A program that demonstrates this is given as follows:

The output of the above program is as follows:

Static binding can be resolved at the compile time by the COMPILER. All the static, final and private method binding is DONE at compile time. Another word for static binding is EARLY binding.

An example of static binding is given as follows:

The output of the above program is as follows:

In dynamic binding, the type of the object is determined at run time. One of the examples of dynamic binding is overriding.

An example of dynamic binding is given as follows:

The output of the above program is as follows:

File permissions are set on the file when the operations PERMISSIBLE for the file need to be restricted by the user.

The permissible permissions for a file are given below:

1. Readable - This permission TESTS if the application can read the file that is denoted by the abstract path name.
2. Writable - This permission tests if the application can change the file that is denoted by the abstract path name.
3. Executable - This permission tests if the application can execute the file that is denoted by the abstract path name.

The methods that can be used to change the permissions of a file are setExecutable, setReadable and setWritable.

A program that demonstrates the permissions of a file is given as follows:

The output of the above program is as follows:

Spliterator is used for traversing the elements of a Collection, GENERATOR function, IO channel etc. It provides excellent support for parallel traversal as well as sequential traversal and hence is INCLUDED in the JDK 8.

The Spliterator is quite useful EVEN if parallel traversal is not REQUIRED as it combines the hasNext and next operations into a single method.

A program that demonstrates a Spliterator in Java is given as follows:

The output of the above program is as follows:

A final variable in Java is a special type of variable that can only be assigned a value one TIME, either at declaration time or at some other time.

A final variable that is not assigned a value at declaration time is known as a blank or uninitialized final variable. In other words, this variable is not initialized at its declaration time. An EXAMPLE is given as follows:

A program that demonstrates a blank or uninitialized final variable in Java is given as follows:

The OUTPUT of the above program is as follows: 

Inheritance can be restricted for a class in Java using the KEYWORD final. In other WORDS, if a class is declared as final, then no other class can be extended from it. This is quite useful while creating an immutable class  

An example of this is given as follows:

An error is generated if the class C2 tries to EXTEND the class C1 as it is a final class and so cannot be inherited.

This keyword cannot be used to refer to the static members of the CLASS. The reason is the “this” keyword points to the current object of the class and the static member does not need any object to be called.

The static members of the class can be accessed directly as no object is required. A program that demonstrates this is as follows:

The output of the above program is as follows:

The NAME of the enum constant is RETURNED by the method java.lang.Enum.name(). The method returns the name exactly as it was declared in the enum declaration.

A program that DEMONSTRATES the java.lang.Enum.name() method is given as follows:

The output of the above program is as follows:

The following were the drawbacks:

• java.util.DATE is not thread safe.
• No UNIFORMITY, since the default Date starts from 1900, month starts from 1, and day starts from 0.

The above drawbacks were fixed in Java 8 like INTRODUCTION of utility methods for date operations.

The method isLetterOrDigit() can be used to check if a character is a letter or a number in Java. If the character is a letter or a number then the method returns true, OTHERWISE it returns false.

A program that demonstrates this is given as follows:

The output of the above program is as follows:

The current date and time can be obtained using many METHODS in Java. One of these is using the LocalDateTime.now() method. The instance of the LocalDateTime class is RETURNED by this method which can then be printed.

A program that demonstrates this is given as FOLLOWS:

The output of the above program is as follows:

Overflow OCCURS when the VALUE is more than the maximum value of the specified datatype. LET’s say the datatype is LONG. If the value SET is more than the Long.MAX_VALUE, then overflow occurs.

A class is MADE FINAL in JAVA so that it cannot be extended. But we cannot make a CONSTRUCTOR final.

Two integer arrays in JAVA are said to be equal if they have the same number of elements and all the CORRESPONDING elements in the arrays are ALSO the same. So, the two arrays can be COMPARED in Java by using the Arrays.equals() method.

A program that demonstrates this method is given as follows:

The output of the above program is as follows:

An interface in JAVA is a collection of abstract methods. This interface is IMPLEMENTED by a class that abstract methods of the interface.

An interface can extend another interface using the extends keyword. In this way, the methods of the parent interface are inherited by the child interface.

An example of an interface extending another is given as follows:

The class that IMPLEMENTS the Finance interface NEEDS to implement 4 methods as there are 3 methods in Finance and it inherits 1 method from Department. Similarly, the class that implements the Marketing interface needs to implement 3 methods as there are 2 methods in Marketing and it inherits 1 method from Department.

An abstract class is a class that cannot be instantiated on its own. It can be created in Java using the abstract keyword.

A class can be declared as an abstract class without having an abstract method. In that case, the class created cannot be instantiated but can be inherited.

A PROGRAM that demonstrates this is given as follows:

The output of the above program is as follows:

Both ITERATOR and ListIterator in Java are an interface in the Collection framework. The Iterator is used to traverse the Collection elements by iterating each element individually in the forward direction.

ListIterator extends the Iterator and is used to traverse the Collection elements in both forward and BACKWARD directions. Also, elements can be added, modified and removed in the Collection using ListIterator which is not possible using Iterator.

The differences between Iterator and ListIterator are given as FOLLOWS:

A thread in Java is the path that is followed when a program is executed. There is atleast ONE thread in all Java programs that is created by the JVM at the start of the program. This is known as the main thread. The java.lang.Thread class CREATES and CONTROLS all the Java threads.

The thread life cycle in Java contains 5 states. These are given below:

1. New
2. Runnable
3. Running
4. Blocked (Non-runnable)
5. Terminated

Can a dead thread be started again in Java?

It is not possible to start a thread after it has completed execution i.e. after it is dead a thread cannot be BROUGHT to runnable state.

It is better to start a new instance. The actions that need to be executed should be wrapped in the Runnable interface and then the Runnable can be passed to the new instance of Thread.

A class can be made thread safe using the volatile keyword. This means that multiple threads can use the class instance or methods at the same time without any problem.

The USAGE of the volatile keyword on a particular variable means the following:

1. The VALUE of the variable with the volatile keyword is never CACHED thread locally. This means that all the read and write operations on the variable are saved in the main memory.
2. The access to the variable appears as though it is enclosed in a synchronized block and is synchronized on itself.

An example of the volatile keyword is given as follows:

In the above example, if there are any changes made by one thread then they are reflected in the other threads as WELL using the volatile keyword.

Differences between volatile and synchronized

Some of the differences between volatile and synchronized are given as follows:

If there is an attempt to store the wrong TYPE of object into an ARRAY of objects, then the ArrayStoreException is thrown in Java. This exception is thrown at runtime.

A program that demonstrates a try-catch block to HANDLE an ArrayStoreException in Java is given as follows:

The OUTPUT of the above program is as follows:

All the objects in Java are allocated memory from the heap memory. When an object cannot be allocated any memory because there is no more memory AVAILABLE and no memory can be obtained using the garbage collector, then the EXCEPTION OutOfMemoryError occurs in Java.

The Out Of Memory Error usually occurs if there is too much data processing at a time or objects are held for too long. This exception can also occur because of problems that are out of programmer control such as an application server that doesn’t clean up after deploys

A program that demonstrates the Out Of Memory Error in Java is given as FOLLOWS:

The output of the above program is as follows:

It is not possible to START a thread twice in Java. In other words, after a thread is started once, it cannot be started again. If the thread is started a second time, then the  IllegalThreadStateException is thrown.

A program that DEMONSTRATES this is given as FOLLOWS:

The output of the above program is as follows:

As is seen from the above program, if the thread is started the second time, the  IllegalThreadStateException is thrown.

The methods to FORMAT the data in Java are provided in the class java.text.SimpleDateFormat. This class is a concrete class that is used for formatting and parsing the date and it inherits from the java.text.DateFormat class.

A program to format the date in Java using the java.text.SimpleDateFormat is given as FOLLOWS:

The OUTPUT of the above program is as follows:

The TRY, catch and finally blocks are used for exception handling. The try block is allowed without a catch block in Java but the finally block should be PROVIDED. The finally block always executes whether there is an exception or not in the try block. The only time it does not execute is if System.exit() is called.

A program that demonstrates the try without a catch block is Java is GIVEN as follows:

The output of the above program is as follows:

The final keyword is a non-access MODIFIER in Java that is only applicable for variables, methods or classes.

The MAIN method can be declared as final in Java and the JVM has no problem with that. However, it is not possible to override the main method in Java unlike any final method.

A program that declares the main method as final in Java is given as follows:

The OUTPUT of the above program is as follows:

STREAMS support aggregate operations and introduced in JAVA 8. It is a sequence of OBJECTS with operations like Sorted, Map, Filter, etc.

For Streams, the following package is used:

Here is an example of Stream operations in Java 8 to work with map and collect:

Yes, Diamond operator can be USED with anonymous class in Java 9. It was INTRODUCED in Java 7 to make code more readable. Till Java 7, ENHANCEMENTS weren’t introduced for Diamond operator to use with Anonymous inner classes.

A group of objects can be stored and manipulated using an architecture that is provided by the Collections API in Java. All the possible operations in Java such as searching, sorting, deletion, insertion etc. can be performed using the Java Collections.

Some of the BEST practices of while working with Collections in Java are given as follows:

1. CHOOSING the right collections

Before using collections, the right collection needs to be chosen according to the problem that needs to be solved.

2. Using Arrays and Collections utility classes

The Arrays and Collections utility classes provided by the Java Collections Framework should be used as required as they provide many useful methods to SEARCH, sort and modify elements in a collection

3. Specify initial capacity of a collection if possible

The initial capacity of a collection is always specified by an overloaded CONSTRUCTOR that is contained in almost all concrete collection classes.

4. Prefer isEmpty() over size()

The isEmpty() method should be preferred over the size() method to check the emptiness of a collection. Even though there is a performance difference between these two methods, this is done to enhance the readability of this code.

5. Do not return null in a method that returns a collection

If a method returns a collection, then it should not return null if there is no element in the collection. Instead, it should return an empty collection.

6. Using the Stream API on collections

There is a stream method in every collection in Java 8 that returns a stream of elements. This means that the aggregate functions can be easily performed using the Stream API.

7. Do not use the classic for loop

Instead of using a classic for loop to iterate a list collection, use an iterator. This is because if the for loop variable is altered inside the loop, it can LEAD to bugs.

The most important usage of threads can be achieved USING Multithreading. This means that multiple tasks can run in parallel. Some of the best practices of multi-threading in Java are given as follows:

1. Minimize the locking scope

The locking scope should be minimized as any code inside a lock cannot be executed concurrently and this REDUCES the application performance.

2. Concurrent Collections should be preferred over synchronized Collection

Concurrent Collections should be preferred over synchronized Collections as they provide more scalability and performance.

3. Prefer Immutable Classes

Immutable classes like String, Integer etc. as well as other wrapper classes should be used as they simplify the concurrent code writing. This is because there is no NEED to worry about the state.

4. Thread Pool Executors should be preferred instead of Threads

A thread pool is a better option for a scalable Java application as thread creation is quite expensive.

5. Use Local Variables

Instead of using class or instance variables, local variables should be used as much as possible.

6. BlockingQueue should be preferred for producer-consumer design

The best way to implement the producer consumer design pattern is using BlockingQueue. This is quite important as many concurrency problems are based on  the producer consumer design.

7. Synchronization utility should be preferred over wait notify

There are a lot of synchronization utilities like CyclicBarrier, COUNTDOWNLATCH and Semaphore which should be used instead of wait and notify.

8. Use Semaphore to create bounds

There should be bounds on different resources such as the file system ,database, sockets etc. to build a stable system. These bounds can be created using semaphores.

The double-type and the FLOAT-type are both used to represent floating point numbers in Java. However, for some situations double-type is better and in some cases float-type is better.

Double-type is preferred over float-type if more precise and accurate result is required. The precision of double-type is up to 15 to 16 decimal points while the precision of float type is only around 6 to 7 decimal digits.

Another reason that double-type may be preferred over float-type is that it has a larger range. It uses 1 bit for sign, 11 bits for exponent and 52 bits for MANTISSA while float-type only uses 1 bit for sign, 8 bits for exponent and 23 bits for mantissa.

A program that demonstrates double-type and float-type in Java is given as FOLLOWS:

The OUTPUT of the above program is as follows:

A WRAPPER class is a specific class whose object CONTAINS or WRAPS PRIMITIVE data types. It can also be said that primitive data types are wrapped into an object of a wrapper class.

Some of the reasons the wrapper classes are required in Java are given as follows:

1. The wrapper classes convert the primitive data types into objects. This is required if the arguments passed to the methods need to be modified as the primitive data types are passed by value.
2. Synchronization in multithreading is supported by objects and so wrapper classes may be required.
3. Only objects and not primitive types are stored in data structures such as ArrayList and Vector in the Collection framework.
4. Another use of wrapper classes is because the classes in the java.util package HANDLE only objects.

A list of all the primitive data types and the corresponding wrapper classes is given as follows:

Shallow copy and deep copy are related to the cloning PROCESS i.e. creating a copy of an object in Java. Details about the shallow and deep copy are given as follows:

Shallow Copy in Java

A shallow copy of an object is able to copy the main object but not the inner objects. This means that the original object the created copy shares the inner objects.

An example of this is given as follows:

In the above example, if a shallow copy is created of an object of class Employee, then a SECOND Employee is created but the Name and DepartmentDetails objects are shared by both the objects. So if CHANGES are made to one of the objects, then they be reflected in the object created using a shallow copy.

Deep Copy in Java

The deep copy of an object is a fully independent copy and the WHOLE object structure is copied when a new deep copy is created.

An example of this is given as follows:

In the above example, if a deep copy is created of an object of class Employee then the whole object structure is copied and if changes are made to one of the objects, then they would not be reflected in the object created using a deep copy.