Explore topic-wise InterviewSolutions in .

Multiple THREADS can manage their access to a shared resource USING SYNCHRONIZATION where only one thread accesses the resource at a time.

There are two types of thread synchronization in Java. These are given as follows:

1. Mutual Exclusion
2. Inter thread Communication

A program of thread synchronization is given as follows:

The output of the above program is as follows:

The execution of a thread can be paused in a multithreading environment in Java using the sleep() or wait() methods. The thread is paused for the required time using sleep() while the thread goes into a wait state using wait() and can only be revived by calling NOTIFY() or NOTIFYALL().

Some of the differences between sleep() and wait() are given as follows:

An example of sleep() is given as follows:

An example of wait() is given as follows:

When a value is assigned to a variable that is less than the minimum allowed value for that variable, then underflow occurs. There is no exception THROWN by the JVM if an underflow occurs and it is the responsibility of the programmer to HANDLE the underflow condition.

A program that checks for underflow in Java is given as follows:

The output of the above program is as follows:

An anagram of a STRING is a string that has the same characters with the same frequency. Only the character order can be different. An EXAMPLE of a anagram is given as follows:

A program that checks if two strings are anagrams of each other in Java is given as follows:

The output of the above program is as follows:

Java 10 is the fastest release of a Java version till date. It has many important features with multiple changes that have a far-reaching impact. Some of the new features of Java 10 are given as follows:

1. Experimental Java Based JIT Compiler (JEP 317)

A new Java based JIT compiler is introduced by this JEP that is the basis of an experimental AOT(Ahead of Time) compiler.

2. Time-Based Release Versioning (JEP 322)

The version STRING scheme of the JDK and the Java SE platform can be revised using this JEP.

3. Remove the Native Header Generation Tool (JEP 313)

There is no separate tool in Java 10 to generate header files when compiling the JNI code. This was done as the above process can already be performed using javac.

4. Garbage Collector Interface (JEP 304)

The code isolation of different garbage collectors is increased and a clean interface is introduced by this JEP.

5. Parallel Full GC for G1 (JEP 307)

The full GC algorithm is parallelized with the JEP 307. This is done so that the same number of threads can be used in the event of a G1 full GC as are used in the concurrent collections.

6. Heap Allocation on Alternative Memory Devices (JEP 316)

The Java object heap is allocated by the HOTSPOT VM on an alternate memory device that is specified by the user.

7. CONSOLIDATE the JDK Forest into a Single Repository (JEP 296)

The multiple repositories of the JDK forest are combined into a single repository using this JEP.

8. Root CERTIFICATES (JEP 319)

A default SET of root certification authority is provided by the JEP 319 that makes openJDK builds more attractive for developers.

9. Local Variable Type Inference (JEP 286)

Some of the strict type declaration is removed to improve the developer experience. This means that the compiler can infer the type using only var.

The List interface is implemented using the ArrayList and the LinkedList. The ArrayList implements a dynamically RESIZED array while the LinkedList implements a doubly linked list. So ArrayList or LinkedList in Java should be SELECTED ACCORDING to the implementations required. Also the differences between both of these are provided to make the selection easily.

Some of the differences between Arraylist and LinkedList are given as follows:

1. The time required to find if an element is AVAILABLE in both ArrayList and LinkedList is O(n) in the worst case. But binary search can be used on a sorted ArrayList to reduce this time to O(log n).
2. It is easier and much faster to insert elements in LinkedList as compared to ArrayList. The time complexity for insertion in ArrayList is O(n) in worst case while it is O(1) in LinkedList.
3. Deletion of elements is also easier in LinkedList as compared to ArrayList. However the time complexity for deletion in ArrayList and LinkedList is O(n) in worst case.
4. There is more memory overhead in LinkedList as compared to ArrayList. This is because in LinkedList each node contains the DATA and address of the previous and next nodes while in ArrayList each index contains the data only.

Constructor chaining in JAVA is the process of calling one constructor with the help of another while considering the current object.

It can be done in 2 ways –

• Within same class: It can be done using this() keyword for constructors in the same class.
• From base class: By using super() keyword to call a constructor from the base class.

Here we will take a look at how constructor chaining is done with this keyword

The output is as follows:

A JAVA program can be compiled and executed without MAIN method if we use the static block having System.exit(0); statement at the end which terminates the program before JVM starts looking for main method. However, this is only possible upto Java 6 .

Let us see how to execute a Java program without the main() method

Upto Java 6, the output would be as follows:

Java 7 onwards, the program gets compiled but will not get executed and will show an error message as.

When a byte is converted to another data type, it is always considered to be signed. In ORDER for unsigned byte conversion, we must mask it to Java and cast it to an integer.

Firstly, we declare three byte values b1, b2 and b3 and assign them values in the range of -128 to 127. Then we cast the value to an integer and use a logical & operator with 0xFF which represents the HEXADECIMAL number having integer value 255 or has binary representation as 00000000000000000000000011111111 (under the 32-bit integer) and it along with the bitwise effectively masks the VARIABLE leaving its values in the last 8 bits and ignores the other values as the other bits become 0.Thus & 0xff is used for masking variables.

Let us see how an unsigned byte is converted to a Java type:

The output is as follows:

In Java 9, the CompletableFuture API has been further developed. Some of the changes done to the API are:

• Support for timeouts and delays
• Improved support for subclassing
• Addition of new factory methods

Support for timeouts and delays

This METHOD COMPLETES the CompletableFuture with the provided value. If not, it completes it before the GIVEN timeout.

Improved support for subclassing

public Executor DEFAULTEXECUTOR()

It returns the default Executor used for async methods that do not show an Executor. This method may be OVERRIDDEN in subclasses to return an Executor to give at least one independent thread

It returns a new incomplete CompletableFuture of the specification to be returned by a CompletionStage method.

New factory Methods

This factory method returns a new CompletableFuture which is already accomplished with the provided value.

This factory method returns a new CompletionStage which is accomplished beforehand with the provided value and is compatible with only those methods available in interface CompletionStage.

Before Java 9, we had to ADD DATA to Set and List separately and then Map them. Java 9 added methods to List, Set and Map along with their overloaded counterparts.

Some of the Collection Objects have the FOLLOWING factory methods:

The of(...) method is overloaded to have 0-10 parameters and one with variable var args parameter for Set and Map interfaces and is overloaded to have 0-10 parameters for Map interface. When there are more than 10 parameters for a Map Interface, ofEntries() method is used to accept var args parameter.

Let us see an example showing the USE of Collection Factory Methods:

The output is as FOLLOWS

The PURPOSE of the diamond operator was to increase reusability of code, avoid redundant code which was ACHIEVED by leaving the generic type on the right SIDE of the expression.

There was a certain problem with the diamond operator as it couldn’t be used with anonymous inner classes. Java 9 enhanced the diamond operator so that it could be used with anonymous inner classes.

Let us look at an example of diamond operator with anonymous inner class

The output is as FOLLOWS:

JAVA STATIC METHODS cannot be OVERRIDDEN.

When Java 9 burst onto the scene, it BROUGHT with it some improvements in STREAM API. Quite a few methods were added to the Stream Interface. Let us have a look at some of them.

• takewhile(Predicate)

takewhile() method accepts all VALUES until the predicate RETURNS false. If a stream is ordered, takewhile() returns a stream consisting the longest prefix of elements taken from this stream that match the predicate. If the stream is unordered, the method returns a stream consisting of a subset of elements extracted from this stream that match the given predicate.

The syntax:

Let us see an example of the takeWhile() method:

The takeWhile() method accepts all y, a, and m and then once it finds the String to be empty, it stops its execution.

The output is as follows:

• dropWhile(Predicate)

The dropWhile() method drops all the value until it matches with the predicate. After that, it starts to accept values. The dropWhile() method returns the remaining stream after matching the predicate if the stream is ordered. When the stream is unordered , it returns a stream consisting of the remaining elements of this stream after dropping a subset of elements that match the given predicate.

The syntax:

Let us see a program showing the use of the dropWhile() method:

dropWhile() method for the first SEQUENCE drops y,a,m values, then once string is empty, it takes all the values. dropWhile() method for the first sequence drops y values, then once string is empty, it takes all the values.

• iterate() 

The iterate() method has hasNext predicate as argument which terminates the loop once hasNext predicate returns false. It takes three arguments, seed, hasNext and next.

The syntax:

Let us see an example of the iterator method:

The output is as follows:

• ofNullable()

The ofNullable prevents Null pointer exceptions and prevents null checks for streams. It returns a sequential stream that contains a single element, if non-null. Otherwise, it returns an empty stream.

The syntax:

Java 9 introduced private methods and private STATIC methods. An interface can now have six features. The features are as follows:

• Constant variables
• Default methods
• Static methods
• Abstract methods
• Private methods
• Private Static methods

The private methods increase reusability of code within interfaces. Their scope is limited to the interface itself and cannot be CALLED or accessed outside the interface.

An example to show private methods in interfaces is as follows:

The output is as follows:

A self-explanatory COLLECTION of code and resources is called a MODULE. It adds a higher level of hierarchy above packages. A module is basically a uniquely named, RECLAIMABLE group of related packages, as well as resources (such as images and XML FILES) and a module descriptor.

Without further ado, let us go on and see the Steps to create a module in Java 9.

Let the name of our module be examplemodule.
Step 1: Create a folder:

C:\>Java\src 

The same folder is visible here:

Create a folder named examplemodule inside the src folder: 

The screenshot displays the same path:

Step 2: Create a module-info.java file in the C:\>Java\src\examplemodule folder with following code:

The screenshot:

Step 3: Create a file Example.java in the C:\Java\src\examplemodule folder.

The file has the following SOURCE code:

Step 4: Create a folder C:\Java\mods.

Create a folder name examplemodule in the mods folder. This is the same as the name of the module we have created.

Now compile the module to mods directory

Step 5: Let us run the module by running the following command

C:\Java>java --module-path mods -m examplemodule/examplemodule.Example

The module-path provides the module location as mods and -m signifies the main module.

The following is the output:

The BASE64 class consist of static methods for obtaining encoders and decoders for Base64 encoding. JAVA 8 allows us to use three types of encoding:

• Basic − The output is plotted to a set of characters lying in Base64 alphabet. The encoder does not add any line feed in output, and the decoder rejects any character other than Base64 alphabet.
• Uniform Resource Locator(URL) and filename safe − The output is plotted to set of characters lying in Base64 alphabet. The decoder rejects data that contains characters outside the Base64 alphabet.
• Multipurpose Internet Mail Extensions (MIME) − The output is plotted to MIME compatible format. The encoded output must have lines with a maximum of 76 characters each and applies a carriage return '\r' followed instantly by a linefeed '\n' as the line separator. There is no linefeed separator at the end of the encoded output. All the characters apart from the Base64 alphabet are IGNORED by the decoder.

The declaration of the Base64 class is as follows:

Let us see an example of basic Base64 encoding and decoding:

The output is as follows:

YES, all the FUNCTIONS in JAVA are VIRTUAL by DEFAULT.

Optional is a container object which might not contain a non-null value. If a value is AVAILABLE, isPresent() will RETURN true and get() will return the value. Supplementary methods that rely on the availability of a contained value are provided, like orElse() methods (return a default value if value not present) and ifPresent()(execute a block of code if the value is present).

Syntax for optional class

Optional class is a value based class. Operations pertaining to identity including reference equality (==), identity hash code, or synchronization on objects of the class may have unprecedented outcomes and should be avoided.

Let us see an example where the isPresent() method of the optional class is used:

The OUTPUT is as follows:

Java 8 introduced a new Date/Time Application Program Interface(API) as the previous Date/Time API w drawbacks.

• Not thread safe: The java.util.Date class was not thread safe. This FORCED developers to cope with the concurrency issue when the threads of the Date class were not in complete order with each other. The new date-time API is immutable and does not have setter methods.
• Poor design: Default Date had become obsolete since it started from the year 1900, MONTH started from 1, and day started from 0. Thus uniformity couldn’t be achieved.  The old API had less immediate methods for the functions to be PERFORMED on date. The new API provides numerous useful methods for such operations.
• Inconvenient handling of time zone:  The problems faced due the timezone needed huge amount of code written by a developer. The new API has been developed bearing  the domain-specific blueprint in mind.
• The new API has been listed under the java.time package. Some of the significant classes under the java.time package are:
• Local: The Local class is a streamlined Data/Time API  without the hodoo of timezone handling
• Zoned: The Zoned class is a streamlined Data/Time API with consideration of timezones

Let us see an EXAMPLE of the Local class with the new Date/Time API:

The output is as follows:

Now, let us see an example of the Zoned class with the new Date/Time API:

The output is as follows:

Predicate is a FUNCTIONAL interface defined in java.util.Function package. It helps in improving the control of the code. It can be used as an assignment target in lambda expressions and functional interfaces. Functional interfaces are those interfaces that have only ONE abstract method.

Here is the declaration

Methods:

The test() method evaluates the predicate BASED on the given argument.

The and() method returns a formulated predicate by short circuited logical AND of this predicate and the other. If the other is null, it throws a NullPointerException. If this predicate is false, the other is not evaluated.

The negate() method returns a predicate that REPRESENTS the logical NOT of this predicate.

The or() method returns a formulated predicated by short circuited OR of this predicate and the other. If this predicate is true, the other is not evaluated.

The isEqual() method returns a predicate that tests if two arguments are equal according to Objects.equals(Object, Object).

Here is a SAMPLE program for Predicates in Java :

The output is as follows:

Daemon Thread are a specific kind of thread in JAVA that has the lowest priority while multithreading. All the User Threads have higher priority than the Daemon Thread. It cannot STOP the JVM from exiting while rest of the threads have finished executing.

JVM doesn’t depend on the execution of the daemon threads. The Daemon thread performs background TASKS like Garbage collection but is terminated as soon as the User Threads complete their execution. JVM doesn’t take into consideration whether the Daemon Thread is STILL running or not. It terminates the threads and then shuts itself down.

Daemon thread in java is a service provider thread that provides services to the user thread. There are many automatic daemon threads like gc and finalizer.

Methods for the Daemon thread include:

The void setDaemon(boolean status) labels the current thread as a Daemon thread or an User Thread

The boolean isDaemon() checks whether the thread is a Daemon thread or not.

Let us see the execution of Daemon Threads along with User Threads

The OUTPUT is as follows:

We can notice that after the execution of the User Thread t3 has completed, the Daemon Thread t4 terminates and is not checked for being a Daemon Thread.

The Remote Method Invocation is an API in Java which manages the creation of a distributed application by ALLOWING an object to invoke a method on another object that may be on the same machine or another remote machine but is on another address space.

The communication between the CLIENT and server in RMI is done by using the stub object and the skeleton object that are on the client SIDE and server side respectively.

Details about the stub object and the skeleton object are provided along with the FOLLOWING DIAGRAM:

• Stub object: All the outgoing requests for the client side are routed through the stub object and so it is also known as the gateway for the client-side object.
• Skeleton Object: All the incoming requests for the server side are routed through the skeleton object and so it is also known as the gateway for the server-side object.

The steps to create a Remote Method Invocation program are given as follows:

1. First the remote interface is created.
2. The implementation of the remote interface is provided.
3. The implementation class is compiled and the stub and skeleton objects are created.
4. The registry service is started using the rmiregistry tool.
5. The remote application is created and started.
6. The client application is created and started.

The JAVASCRIPT engine in Java SE 8 which replaces the erstwhile Rhino engine is called NASHORN. It is 2-10 times better in performance than Rhino, as it compiles the source code in the system memory directly and sends it in the form of bytecode to the JVM.

JAVA 8 provides a new command for Nashorn namely, jjs which runs JAVASCRIPTS codes at command window (Command Prompt for Windows and Terminal for Linux operating systems).

RUNNING js file using jjs

Create and save JavaScript file example.js in the C:\Java Folder

The example.js has the following command:

The screenshot showing the location of the example.js file:

Open Command Prompt in Windows and type C:\Java>jjs example.js

Running jjs in Interactive mode

Type jjs in the console window and type a print command.

For exiting, type quit():

Now, quit:

JShell is a FEATURE introduced in Java 9. JShell provides Java with REPL ability. REPL STANDS for Read-Eval-Print-LOOP. With REPL, we can test java based logic and expressions without any requirement of compiling.

REPl is acts as an immediate feedback loop and can have a great effect on productivity in that particular language.

Now let us play around with JShell for a bit.

Running JShell on Windows

Step 1: Setup the JDK path

Go to Control Panel > System > Advanced System Settings > Advanced tab > Environment Variables.

Under System Variable, click Path, then New and add the following JDK path,

Step 2: Now open Command Prompt and type jshell.

Step 3: Viewing the JShell commands
Type /help in the command window once JShell start running:

Step 4: Running jshell commands

Type /imports in the jshell command window for obtaining the packages imported by jshell

Step 5: Performing CALCULATIONS in jshell

Try simple arithmetic calculations with jshell

Step 6: Creating functions in jshell

You can create functions and use them in jshell

Step 7: Exiting jshell

To exit jshell, type /exit

The Java Memory Model helps to understand the way the Java Virtual Machine works with the computer memory. The internal Java memory model divides the memory into thread stacks that are used by individual threads and the heap that is used by the entire APPLICATION.

A diagram that demonstrates the internal Java memory model is given as follows:

Details about the thread stack and Heap in the internal Java memory model are given as follows:

The Thread Stack memory in Java is used for thread execution. Specific values are stored in the thread stack that are available for a short time. Also, stack memory may contain data references to objects getting referred from the method that are in the heap memory.

The order in Thread Stack memory is Last In First Out (LIFO). A block is created in the stack memory for all the primitive values and references to other objects in a method when that method is invoked. After the end of the method, the memory block in the stack memory is free and can be used by another method.

The heap space in Java is used to allocate memory to the Objects and the JRE CLASSES by the Java runtime. All the objects in the application are created in the heap space. The objects in the heap space are globally accessible from any place in the application and so they have a lifetime for the whole application execution.

The memory model of the heap space is divided into parts KNOWN as generations. Details about these are given as follows:

• Young Generation

All the new objects are allocated in the young generation and they age here. When this place fills up, then minor garbage collection occurs.

• Old Generation

All the longer existing objects are stored in the old generation. When objects in the young generation reach a certain age THRESHOLD, they are moved to the old generation.

• Permanent Generation

The Java metadata for runtime classes is stored in the permanent generation.

Cloning means creating a copy of an object or creating a duplicate object - the state of them should be the same. An object may be composed of SEVERAL other OBJECTS. Shallow cloning creates a new object and assigns its field values to the corresponding fields of the new object. As the fields contain only the references of the objects which reside in the HEAP, fields of the new object also point to the same component instances. Shallow cloning is fast but has a serious downside in that if any of the component objects is changed, it REFLECTS in the cloned object as well, because both of them holds the references of the same objects. 

Deep Cloning, on the other side, doesn’t copy the references from the fields, it creates a duplicate of the component objects as well. As in Deep cloning, all the component objects are cloned it’s comparatively slow but creates a true duplicate of the actual object. 

Yes, String is an immutable class. String is WIDELY used in different situations like sharing as a parameter of a method, loading a class by its name, returning as a value. So, there would be a huge possibility that a String object could be changed without any knowledge of its other users and result in creating difficult to catch bugs in the system. String has been a POPULAR choice as a key in the HASHMAP or HashTable. A good candidate for a key in the HashMap should be immutable. If String had been mutable and changes its state, it might result in retrieving the wrong value for the same key or not finding it at all. String LITERALS are fetched from the String pool instead of creating it every time. Had the String been mutable, this would not be possible as it could not identify whether the value exists in the pool after any CHANGE in its state.  

A SET is a collection of UNORDERED and UNIQUE elements. While adding an element a HashSet uses the hashCode() and equals() method to determine if the element already exists in the Set. If it doesn’t exist, it adds the element into the set. A HashSet uses a HashMap internally which uses the element as the key and keeps a fixed item as the VALUE. If the element exists in the HashMap as a key, it simply returns with a boolean value false denoting it already exists in the set, otherwise puts the element in the map and returns TRUE. 

STACK memory is used to create the local variables and object references while executing a method by a thread. This means each thread has a SEPARATE stack and set of local variables. Stack doesn’t contain the actual objects - it only contains the references. The memory space for the actual objects is allocated in the heap memory. Heap memory is composed of a number of parts - young generation (EDEN and Survivor space) and old generation. For each method CALL JVM creates a new stack frame containing the local variables. Maintaining them as a stack helps to retrieve the most recent stack frame i.e., the set of variables of the caller method easily when a method returns. 

In the earlier versions of Java (up to 1.7), the interface was DESIGNED to have only method signatures. From Java 8 the interface is now able to CONTAIN method implementation as well. These methods should be marked with default keyword and are called default methods of an interface. This means it is not mandatory to override the default methods in the implementing classes. When an interface is widely used by many applications, it was very DIFFICULT to add a new method in the same, because, it can break the code. The implementers need to change their code in many places. To overcome this COMPLEXITY and make interfaces backward compatible this change has been introduced. public interface SHAPE { 

An immutable class doesn’t allow to change the state of its objects after creation. If we need to change that state of an object it will create a new object. One of the most popular examples of an immutable class is String. We need to TAKE care of several things to make a TYPE immutable. 

1.  The class needs to be final. The reason for not allowing to extend it is that a subclass may GET access the sensitive fields or methods which may change the state of the object. 
2.  The class should declare all its members as private. 
3.  It should not offer APIs or public methods to change its state. For example setter methods. Even if it does, it should create a clone of its own, make the changes there and return the object. 
4.  If any member of the class is mutable, we should declare it as final. 
5. We should initialize the object through a constructor making a deep clone of the mutable objects passed as the constructor ARGUMENTS. 
6. we should not expose the references of the mutable members OUTSIDE the class. If we need to do this, we need to clone the member properly and return it. This ensures even if the object is changed via its reference, it is not the same object. 

Strings are immutable in Java. When we make changes in a String, it creates a new String OBJECT. Our PROGRAMS create a LOT of String objects in the runtime. To offer optimum performance, JVM minimizes the String object creation maintaining a pool of String literals in the heap memory (Java 7 onwards). So, when it is required to create a String literal, it first checks in the pool, whether it exists there. If found, it returns the reference of that object. Otherwise, it creates the object and reserves it in the pool for REUSING it in a later phase. 

We cannot override a public method by a protected method. The ACCESS modifiers of the method in the child class cannot limit the scope of the method of the parent class while overriding. This is because we call the method through a SUPERCLASS reference which overrides the parent implementation by the child implementation. As the type of reference is of Parent class, the client code knows the API with the broader scope (public) and is prepared BASED on the parent API. So, it doesn’t make any sense to limit the scope in the overriding (child) method, but the opposite is possible, of course.

Two dates in Java can be compared using the compareTo() method. The syntax for this is given as follows:

This method returns 0 if both the dates are equal, it returns a value greater than 0 if date1 is after date2 and it returns a value less than 0 if date1 is before date2.

A PROGRAM that compares two dates in Java is given as follows:

The output of the above program is as follows:

Two arrays in Java are SAID to be equal if they have the same number of elements and all the corresponding elements 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:

YES, we can OVERRIDE the OVERLOADED METHOD in JAVA.

When a value is assigned to a variable that is more than the MAXIMUM allowed value for that variable, then overflow occurs. There is no exception thrown by the JVM if an overflow occurs and it is the RESPONSIBILITY of the programmer to handle the overflow condition.

A program that checks for overflow in JAVA is given as follows:

The OUTPUT of the above program is as follows:

DETAILS about the heap space and stack memory in Java as well as their differences is given as follows:

The heap space in Java is allocated the memory to the Objects and the JRE classes by the Java runtime. All the objects in the application are created in the heap space. The objects in the heap space are globally accessible from any place in the application and so they have a lifetime for the whole application execution.

The memory model of the heap space is divided into parts known as generations. The three generations are young generation, old generation and PERMANENT generation.

The Stack memory in Java is used for thread execution. Specific values are stored in the stack memory that are available for a short time. Also, stack memory may contain data references to objects getting referred from the method that are in the heap memory.

The order in Stack memory is Last In First Out (LIFO). A block is created in the stack memory for all the primitive values and references to other objects in a method when that method is invoked. After the end of the method, the memory block in the stack memory is free and can be used by another method.

Some of the differences between stack memory and heap memory are given as follows:

1. The stack memory management is DONE USING LIFO but it is more complicated for heap memory as that is used by the whole application.
2. Stack memory is faster than heap memory as its memory allocation procedure is much more simple.
3. The stack memory is only used by a thread whereas the heap memory is required by all the application parts.
4. The stack memory is only accessible by the individual thread but the heap memory objects can be accessed globally.
5. The stack memory is COMPARATIVELY short lived while the heap memory exists for the whole execution of the application.

Reversing an integer involves reversing all of its DIGITS. An example of this is given as follows:

A program that demonstrates reversing an integer in Java is given as follows:

The OUTPUT of the above program is as follows:

In the above program, the number 2413 is REVERSED using a while loop and the result is stored in rev which is then DISPLAYED.

The Calendar.DAY_OF_WEEK constant is used in Java to get the day number of week.

The EXAMPLE DISPLAYS the same:

The example displays the day number of the week:

The JAVA CLASS file has a .class extension and contains the Java bytecode. This class file can be executed by the Java Virtual Machine.

The Java class file is created as a result of successful compilation by the Java compiler from the .java file. Each class in the .java file is compiled into a separate class file if the .java file has more than one class.

A program that demonstrates the creation of a class file in Java is given as FOLLOWS:

The output of the above program is as follows:

After the above program is compiled successfully, there are 3 class files created in the corresponding folder as there are 3 CLASSES in the .java file. These class files are A.class, B.class and Demo.class.

The Java Class is stored in the form of byte code in a .class file after it is compiled. The ClassLoader loads the Class of the Java program into memory when it is required.

The ClassLoader is hierarchical and so if there is a request to load a class, it is DELEGATED to the parent class loader. The uniqueness in the Java Runtime ENVIRONMENT is maintained using this method.   

The types of build-in ClassLoader in Java are given as follows:

1. Bootstrap Class Loader
2. Extensions Class Loader
3. System Class Loader

A program that demonstrates ClassLoader in Java is given as follows:

The output of the above program is as follows:

Nested classes in Java is declared inside a CLASS or interface. Non-STATIC nested classes are known as inner class in Java as there are two types of nested classes i.e. static and non-static.

A PROGRAM that demonstrates an inner class in Java is given as follows:

The output of the above program is as follows:

Generics were introduced to deal with type-safe objects in J2SE 5. Only specific TYPES of objects can be stored in Collections as forced by Generics.

Some of the benefits of Generics in Java are given as FOLLOWS:

Elimination of type casting

Type casting is not required after the advent of generics. An example that demonstrates this is as follows:

Checking at COMPILE time

Compile time checking is PROVIDED so that there is no problem at run time as it is much better to handle a problem at compile time than at run time. An example that demonstrates this is as follows:

Type-Safety

Generics result in type safety as only a single type of object can be held in them. This means that other types of objects are not allowed.

GO to “Start” and type “Environment Variables”. Then you will reach a window “”.

System Properties

Now, click on “Environment Variables”:

Now click on “Path” in the user variables drop down list.

Click on “New” and ENTER the following path. We are setting path here for Java 11:

After adding the path above, click “OK”.

Click “OK” again.

Click “OK”.
You have successfully set the JDK Path.

For verification, go to command prompt (cmd) and type:

The above shows that we have successfully set the path.

The Java provides compareTo() method to COMPARE two characters.
Create characters:

Now let us compare them:

The OUTPUT:

It is quite possible to overload the main() method in Java as it is not an extra-terrestrial method. The main() method is like any other method and can be overloaded too like other methods.

As public static void main(STRING [] args) serves as the method signature of the main method, JVM calls its first. public static void main(String [] args) acts as the entry point for the Java program.

We can overload the main method in Java. SINCE the program doesn’t execute the overloaded main method when the program executes, we need to call the overloaded main method from the ACTUAL main method which has the method signature.

Let us see an EXAMPLE of overloading of the main method in Java

The output is as FOLLOWS:

Using compare methods

Compare two strings in Java using the compareTo() and compareToIgnoreCase() methods. The compareTo() method is used to compare two strings lexicographically or in dictionary order. Each CHARACTER is translated into a Unicode VALUE for comparison. If both the strings are equal, it returns 0 otherwise it returns positive or negative values.

The compareTo() method returns a positive value if the first string is lexicographically greater than the second string and it returns a negative value if the first string is lexicographically lesser than the second string. The compareToIgnoreCase() method compares two strings lexicographically irrespective of their cases.

Let us SEE an example where compareTo() and compareToIgnoreCase() methods are used to compare two strings:

The output is as follows:

Using equals() and equalsIgnoreCase()

The equals() method compares the string to a specific object. It returns a boolean value either true or false. It returns true when argument is not NULL and the string matches the characters of the object. The equalsIgnoreCase() does the same operation but does not take into account the case of the string and the sequence of characters of the object.

Let us see an example where equals() and equalsIgnoreCase() are used to compare two strings.

The output is as follows:

Using the == operator

We can use the == operator to compare two strings. This operator acts like the equals() method and returns a boolean value as the result.

Let us see the application of == operator for comparison of two strings:

The output is as follows:

The size of a primitive array cannot be increased in Java as it is fixed. If we try to increase the size of the primitive array, it would lead to an ArrayIndexOutOfBoundsException.

The OUTPUT is as follows:

The code generates an java.lang.ArrayIndexOutOfBoundsException exception.

To increase the size of an array, we need to copy it and increase its size dynamically. The java.util.Arrays class provides Arrays.copyOf() METHOD which helps us to create a new array with an increased size and copy the values of the elements of the original array simultaneously.

The syntax:

Let us see an example where we copy an array and increase its size:

The output is as follows:

We can use the ArrayList class to create a dynamic array list but that would occupy a lot more memory. Thus we use the Arrays.copyOf() method.