Amol Pawar

Threads are the lifeblood of concurrent programming in Java, enabling multiple tasks to execute seemingly simultaneously, enhancing the performance of applications by utilizing the available processing power efficiently. Understanding thread constructors and methods is crucial for effectively creating, managing, and synchronizing threads in your applications. In this blog post, we’ll delve into the various constructors and methods provided by the Thread class in Java. Specially three fundamental methods: yield(), join(), and sleep(). Each of these methods serves a specific purpose in controlling thread execution, offering developers flexibility and control over concurrent processes.

Thread Constructors

Thread t = new Thread();
Thread t = new Thread(Runnable r);
Thread t = new Thread(String name);
Thread t = new Thread(Runnable r, String name);
Thread t = new Thread(ThreadGroup g, String name);
Thread t = new Thread(ThreadGroup g, Runnable r);
Thread t = new Thread(ThreadGroup g, Runnable r, String name);
Thread t = new Thread(ThreadGroup g, Runnable r, String name, long stackSize);

let’s break down each constructor of the Thread class:

1. Thread t = new Thread();: This constructor creates a new thread object t but does not specify the task (runnable) for the thread to execute. In this case, the thread is considered to be in a “new” state, and calling t.start() will cause the thread to execute the run() method of the Thread class, which has an empty implementation.
2. Thread t = new Thread(Runnable r);: This constructor creates a new thread object t and associates it with the specified Runnable object r. When t.start() is called, the run() method of the Runnable object r will be executed by the new thread.
3. Thread t = new Thread(String name);: This constructor creates a new thread object t with the specified name. The thread is considered to be in a “new” state, and calling t.start() will cause the thread to execute the run() method of the Thread class, which has an empty implementation.
4. Thread t = new Thread(Runnable r, String name);: This constructor creates a new thread object t associated with the specified Runnable object r and with the specified name.
5. Thread t = new Thread(ThreadGroup g, String name);: This constructor creates a new thread object t within the specified ThreadGroup g and with the specified name.
6. Thread t = new Thread(ThreadGroup g, Runnable r);: This constructor creates a new thread object t within the specified ThreadGroup g and associates it with the specified Runnable object r.
7. Thread t = new Thread(ThreadGroup g, Runnable r, String name);: This constructor creates a new thread object t within the specified ThreadGroup g, associates it with the specified Runnable object r, and gives it the specified name.
8. Thread t = new Thread(ThreadGroup g, Runnable r, String name, long stackSize);: This constructor creates a new thread object t within the specified ThreadGroup g, associates it with the specified Runnable object r, gives it the specified name, and specifies the size of the thread’s stack.

Getting and Setting the Name of a Thread

Every thread in Java has a name, which may be a default name generated by the JVM or a customized name provided by the programmer. We can get and set the name of a thread using the following two methods of the Thread class:

• public final String getName(): This method returns the name of the thread as a String.
• public final void setName(String name): This method sets the name of the thread to the specified name.

class MyThread extends Thread {
}

class Test {
  public static void main(String[] args) {
    System.out.println(Thread.currentThread().getName());  // main
    MyThread t = new MyThread();
    System.out.println(t.getName()); // Thread-0
    Thread.currentThread().setName("softAai Apps");
    System.out.println(Thread.currentThread().getName()); // softAai Apps
  }
}

Here,

• Thread.currentThread().getName() returns the name of the current thread, which is “main” by default.
• t.getName() returns the name of the thread t, which is “Thread-0” by default since it’s created without a specific name.
• Thread.currentThread().setName("softAai Apps") sets the name of the current thread to “softAai Apps”.
• Thread.currentThread().getName() returns the updated name of the current thread, which is now “softAai Apps”.

These methods provide a way to manage and identify threads in Java programs.

Getting the Current Executing Thread Object

We can get the current executing thread object by using Thread.currentThread().

class MyThread extends Thread {
  public void run() {
    System.out.println("run method executed by Thread: " + Thread.currentThread().getName());
  }
}

class Test {
  public static void main(String[] args) {
    MyThread t = new MyThread();
    t.start()
    System.out.println("main method executed by Thread: " + Thread.currentThread().getName());
  }
}

Output:

main method executed by Thread: main
run method executed by Thread: Thread-0

• In the main() method, Thread.currentThread().getName() returns the name of the current thread, which is “main”. This is because the main() method is executed by the main thread.
• In the run() method of MyThread, Thread.currentThread().getName() returns the name of the current thread, which is “Thread-0”. This is because the run() method is executed by the thread represented by the MyThread object t, which has the default name “Thread-0”.

Using Thread.currentThread() allows you to obtain information about the thread currently executing a particular block of code, which can be useful for debugging and logging purposes.

Thread Priority

Every thread in Java has some priority, which may be a default thread priority generated by the JVM or a customized priority provided by the programmer. The valid range of thread priorities is from 1 to 10, where 1 is the minimum thread priority and 10 is the maximum thread priority. The Thread class defines the following constants to represent some standard priorities:

• Thread.MIN_PRIORITY –> 1
• Thread.NORM_PRIORITY –> 5
• Thread.MAX_PRIORITY –> 10

Identifying valid thread priorities:

• 0: Invalid
• 1: Valid
• 10: Valid
• Thread.LOW_PRIORITY: Invalid (not a standard constant in the Thread class)
• Thread.HIGH_PRIORITY: Invalid (not a standard constant in the Thread class)
• Thread.MIN_PRIORITY: Valid (constant defined in the Thread class)
• Thread.NORM_PRIORITY: Valid (constant defined in the Thread class)

If two threads have the same priority, then we can’t expect the exact execution order; it depends on the thread scheduler.

The Thread class defines the following methods to get and set the priority of a thread:

• public final int getPriority()
• public final void setPriority(int p) (allowed values range: 1 to 10; otherwise, IllegalArgumentException is thrown)

t.setPriority(7);  // valid
t.setPriority(17); // IllegalArgumentException

In this example, setting the priority to 7 is valid, but setting it to 17 would result in an IllegalArgumentException because it’s outside the valid range.

Default Thread Priority

The default thread priority for the main thread is 5, but for all other threads, the default thread priority will be inherited from the parent thread. This means that whatever priority the parent thread has, the same priority will be inherited by the child thread.

class MyThread extends Thread {
}

class Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getPriority());  // 5 (default priority for main thread)
        
        // Thread.currentThread().setPriority(15);  // Throws IllegalArgumentException
        // Thread.currentThread().setPriority(7);   // --> line 1 
        
        // line 1 allowed and sets 7 as priority, but it's redundant as the default priority is 5
        
        MyThread t = new MyThread();
        System.out.println(t.getPriority());  //initial output 7 if line 1 is not commented,  otherwise 5 (as inherited from the parent thread, which is the main thread)
    }
}

If we comment line 1, then the child thread priority will become 5, inherited from the parent thread.

MyThread t = new MyThread();
Here, the parent class is Thread class, and its parent thread is the Main Thread.
Parent thread and parent class are different entities.

Thread Priority Example

Let’s discuss the scenario of setting thread priorities and its implications:

class MyThread extends Thread {
  public void run() {
    for(int i=0; i<10; i++) {
      System.out.println("child thread");
    } 
  }
}

class ThreadPriorityDemo {
  public static void main(String[] args) {
    MyThread t = new MyThread();
    //t.setPriority(10);   --------->  line 1
    t.start();
   
    for(int i=0; i<10; i++) { 
      System.out.println("main thread");
    }
  }
}

If we comment out line 1, then both the child thread and the main thread will have the same priority, which is 5. Hence, we can’t expect the execution order and the exact output, as we don’t know which thread will get the first chance.

If we don’t comment out line 1, then the main thread has priority 5 and the child thread has priority 10. In this case, the child thread will get the chance first, followed by the main thread. The output will be:

child thread
child thread
(child thread repeated 10 times)
main thread
(main thread repeated 10 times)

Note: Some platforms may not provide proper support for thread priorities. In such cases, even if we set high priority, we may not get the exact output. This is a system problem, and there’s nothing we can do about it.

Ways to Temporarily Prevent Thread Execution

We can prevent a thread’s execution temporarily by using the following methods:

1. yield()
2. join()
3. sleep()

yield() Method

yield() causes the current executing thread to pause and gives a chance for waiting threads of the same priority. If there are no waiting threads or all waiting threads have a lower priority, then the same thread can continue its execution. If multiple threads are waiting with the same priority, we can’t predict which waiting thread will get the chance; it depends on the thread scheduler. When the thread that yielded will get a chance again also depends on the thread scheduler, and we can’t predict it precisely.

Complete prototype of yield():

public static native void yield();

Impact of yield() method on thread life cycle:

class MyThread extends Thread {
  public void run() {
    for(int i=0; i<10; i++) {
      System.out.println("Child Thread");
      Thread.yield();  // Commented line 1
    }   
  }
}

class ThreadYieldDemo {
  public static void main(String[] args) {
    MyThread t = new MyThread();
    t.start();
    for(int i=0; i<10; i++) {
      System.out.println("main Thread");
    }
  }
}

In the above program, if we comment out line 1, then both threads will be executed simultaneously, and we can’t predict which thread will complete first. If we don’t comment out line 1, then the child thread will always call yield(), causing the main thread to get more chances to execute, increasing the likelihood of the main thread completing first.

Note: Some platforms may not provide proper support for yield().

join() Method

This method waits for a thread to complete its execution. When a thread calls join() on another thread, it will wait until the specified thread completes its execution before continuing its own execution. There are several overloaded versions of the join() method that allow you to specify a timeout duration for the waiting period.

• Prototype of join() method:

public final void join() throws InterruptedException
public final void join(long ms) throws InterruptedException
public final void join(long ms, int ns) throws InterruptedException

Note: Every join() method throws InterruptedException, which is a checked exception. Hence, we must handle it using either try-catch or by using the throws keyword, otherwise, we will get a compile-time error.

Usage of join() Method

For example, if a thread t1 wants to wait until another thread t2 completes, then t1 has to call t2.join(). When t1 executes t2.join(), it immediately enters a waiting state until t2 completes. Once t2 completes, t1 can continue its execution.

Example Scenario:

Venue Fixing activity (t1)
Wedding card printing (t2) —- t1.join() —-
Wedding card distribution (t3) —– t2.join() —-

The wedding card printing thread has to wait until the venue fixing thread, hence t2 needs to call t1.join(). Similarly, the wedding card distribution thread has to wait until the wedding card printing thread, hence t3 needs to call t2.join().

Impact of join() on thread life cycle:

class MyThread extends Thread {
  public void run() {
    for(int i=0; i<10; i++) {
      System.out.println("Seetha Thread");
      try {
        Thread.sleep(2000);
      } catch(InterruptedException e) {
        // Handle the exception
      }
    }
  }
}
 
class ThreadJoinDemo {
  public static void main(String[] args) throws InterruptedException {
    MyThread t = new MyThread();
    t.start();
  
    t.join();     // Commented line 1   (Main thread waits for the child thread to complete)
   
    for(int i=0; i<10; i++) {
      System.out.println("Rama Thread");
    }
  }
}

In the above program, if we comment out line 1, then both the main and child threads will execute simultaneously, and we can’t predict the exact output. If we don’t comment out line 1, then the main thread calls join() on the child thread object, causing the main thread to wait until the child thread completes. In this case, the output will be:

Seetha Thread
Seetha Thread
.. (repeated 10 times)

Rama Thread
Rama Thread 
.. (repeated 10 times)

Waiting of Child Thread Until Completing Main Thread

Let’s discuss the scenario where the child thread waits until the completion of the main thread using the join() method:

class MyThread extends Thread {
    static Thread mt; //this line holds the main thread object in the main method

    public void run() {
        try {
            mt.join(); // Child thread waits until the main thread completes
        } catch (InterruptedException e) {
            // Handle the exception
        }

        for (int i = 0; i < 10; i++) {
            System.out.println("child thread");
        }
    }
}

class ThreadJoinDemo {
    public static void main(String[] args) throws InterruptedException {
        MyThread.mt = Thread.currentThread();
        MyThread t = new MyThread();
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("main thread");
            Thread.sleep(2000);
        }
    }
}

In the above example, the child thread calls join method on the main thread object, hence the child thread has to wait until the main thread completes. In this case, the output is:

main thread
main thread 
.
.
10 times
.
child thread 
.
.
10 times 
.

Explanation

• In this example, the child thread (MyThread) calls the join() method on the main thread object (mt). This causes the child thread to wait until the main thread completes its execution.
• The main thread is identified by Thread.currentThread(), and its reference is stored in the mt static variable of the MyThread class.
• After starting the child thread, the main thread continues its execution. It prints “main thread” ten times with a 2-second delay between each print statement.
• Meanwhile, the child thread is in the waiting state due to the join() method. Once the main thread completes its execution, the child thread resumes and prints “child thread” ten times.
• This ensures that the child thread waits for the main thread to finish before continuing its own execution.

Deadlock Situation in case of join() method

Let’s discuss two scenarios involving the join() method that can lead to program deadlock:

Case 1: Deadlock between Main Thread and Child Thread:

If the main thread calls the join method on the child thread object, and the child thread also calls join() on the main thread object, then both threads will wait indefinitely, resulting in a deadlock. This situation resembles a deadlock scenario where neither thread can proceed.

class MyThread extends Thread {
    static Thread mainThread;

    public void run() {
        try {
            mainThread.join(); // Child thread waits for main thread
        } catch (InterruptedException e) {
            // Handle the exception
        }

        System.out.println("Child thread finished.");
    }
}

class ThreadDeadlockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyThread.mainThread = Thread.currentThread(); // Save reference to main thread
        MyThread t = new MyThread();
        t.start();

        try {
            t.join(); // Main thread waits for child thread
        } catch (InterruptedException e) {
            // Handle the exception
        }

        System.out.println("Main thread finished.");
    }
}

Case 2: Deadlock within the Same Thread:

If a thread calls the join method on itself, then the program will be stuck, similar to a deadlock situation. In this case, the thread has to wait indefinitely for itself to complete, which cannot happen.

class Test {
    public static void main(String[] args) throws InterruptedException {
        Thread.currentThread().join(); // Main thread waits for itself
    }
}

In the above example, the main thread is calling join() on itself, causing the program to get stuck indefinitely.

Note: In both cases, the program will be stuck indefinitely, unable to proceed further, due to deadlock situations. These scenarios illustrate the importance of using join() method with caution to avoid deadlocks.

sleep() Method

If a thread doesn’t need to perform any operation for a specific amount of time, then it should use the sleep method. This method causes the currently executing thread to sleep (temporarily suspend execution) for the specified duration.

Prototypes:

public static native void sleep(long ms) throws InterruptedException
public static void sleep(long ms, int ns) throws InterruptedException

Note:
Every sleep() method throws InterruptedException, which is a checked exception. Therefore, whenever we use the sleep method, we must handle InterruptedException either by using try-catch or by using the throws keyword, otherwise, we will get a compile-time error.

Impact of sleep method on Thread life cycle

When a thread calls the sleep() method, it enters the TIMED_WAITING state for the specified duration. During this time, the thread does not consume CPU resources and is not eligible for execution. After the specified duration elapses, the thread transitions back to the RUNNABLE state and continues its execution.

class SlideRotator {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Slide-" + i);
            Thread.sleep(5000); // Sleep for 5 seconds
        }
    }
}

• In this example, the main method prints the slides from 1 to 10 and then sleeps for 5 seconds (Thread.sleep(5000)) before printing the next slide.
• After printing each slide, the thread sleeps for 5 seconds before proceeding to print the next slide.
• During the sleep period, the thread transitions to the TIMED_WAITING state, where it remains until the specified duration (5 seconds) elapses.
• Once the sleep duration is over, the thread transitions back to the RUNNABLE state and continues its execution by printing the next slide.

So, in the above example, the thread pauses for 5000 milliseconds (5 seconds) after printing each slide. This simulates a slide rotation process where each slide is displayed for 5 seconds before moving to the next one.

interrupt() Method

A thread can interrupt a sleeping or waiting thread by using the interrupt() method of the Thread class. This method interrupts the execution of the target thread, causing it to throw an InterruptedException if the target thread is in a sleeping or waiting state.

Prototype:

public void interrupt();

When a thread calls interrupt() on another thread, it sets the interrupt flag for that thread. If the target thread is in a blocking method such as sleep() or wait(), it will throw an InterruptedException immediately, or the next time it enters a blocking operation.

class MyThread extends Thread {
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("I am lazy thread");
                Thread.sleep(2000);
            }
        } catch (InterruptedException e) {
            System.out.println("I got interrupted");
        }
    }
}

class ThreadInterruptedDemo {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
        t.interrupt(); // Commented line 1 (Interrupt the child thread)
        System.out.println("End of main thread");
    }
}

If we comment out line 1, then the main thread won’t interrupt the child thread. In this case, the child thread will execute the for loop 10 times.

If we don’t comment out line 1, then the main thread interrupts the child thread. In this case, the output is:

End of main thread 
I am lazy thread
I got interrupted

• In this example, the main thread interrupts the MyThread thread by calling the interrupt() method on it.
• If line 1 is commented out, the main thread won’t interrupt the child thread. In this case, the child thread executes the for loop 10 times without interruption.
• If line 1 is not commented out, the main thread interrupts the child thread. As a result, the child thread throws an InterruptedException, and the message “I got interrupted” is printed.
• Regardless of whether the child thread is interrupted or not, the message “End of main thread” is always printed at the end of the main thread’s execution.

Note: Whenever we call the interrupt method, if a target thread is not in a sleeping state or waiting state, then there is no immediate impact of the interrupt call. The interrupt call will be queued until the target thread enters a sleeping or waiting state. If the target thread is in a sleeping or waiting state, then the interrupt call will immediately interrupt the target thread.

class MyThread extends Thread {
  public void run() {
    for(int i=0; i<=10000; i++) {
      System.out.println("I am lazy thread-"+i);
    }
    System.out.println("I am entering into sleeping state");
    try {
      Thread.sleep(10000);
    } catch(InterruptedException e) {
      System.out.println("I got interrupted");
    }
  }
}

class ThreadSleepDemo1 {
  public static void main(String[] args) {
    MyThread t = new MyThread();
    t.start();
    t.interrupt();  // Interrupt call is made immediately
    System.out.println("End of main thread");
  }
}

In the above example, the target thread t is interrupted immediately after the start method is called. However, since the target thread is not in a sleeping or waiting state yet, the interrupt call will not have any immediate effect. The interrupt call will be queued until the target thread enters the sleeping state. Therefore, in this case, the output will be:

End of main thread
I am lazy thread-0
I am lazy thread-1
...
I am lazy thread-9999
I am entering into sleeping state
I got interrupted

• In this example, the main thread starts a MyThread thread and immediately calls the interrupt() method on it.
• However, since the MyThread thread is executing a loop and not in a sleeping or waiting state, the interrupt call has no immediate effect.
• The interrupt call will be queued until the MyThread thread enters a sleeping or waiting state.
• In this case, the MyThread thread eventually enters a sleeping state using Thread.sleep(10000), and the interrupt call immediately interrupts it, causing it to throw an InterruptedException.
• If the MyThread thread never enters a sleeping or waiting state, the interrupt call would have no effect throughout its execution.

Quick Revision: yield(), join(), and sleep() methods

Let’s discuss yield(), join(), and sleep() methods in Java, along with their characteristics:

yield()

Purpose: If a thread wants to pause its execution to give a chance for the remaining threads of the same priority, then we should use yield().

• Is it Overloaded? No,
• Is it final? No
• Does it throw InterruptedException? No
• Is it native? Yes
• Is it static? Yes

join()

Purpose: If a thread wants to wait until completing some other thread, then we should use join().

• Is it Overloaded? Yes
• Is it final? Yes
• Does it throw InterruptedException? Yes
• Is it native? No
• Is it static? No

sleep()

Purpose: If a thread doesn’t want to perform any operation for a particular amount of time, then we should use the sleep method.

• Is it Overloaded? Yes
• Is it final? No
• Does it throw InterruptedException? Yes
• Is it native? sleep(long ms) is native, sleep(long ms, int ms) is non-native
• Is it static? Yes

Part 3: Mastering Synchronization in Java Threads

Conclusion

Thread management is a crucial aspect of developing robust and efficient multithreaded Java applications. The yield(), join(), and sleep() methods provide valuable tools for controlling thread execution, synchronization, and timing.

By leveraging these methods effectively, developers can orchestrate concurrent activities, coordinate thread interactions, and manage resource contention, thereby enhancing the performance and reliability of their applications in a concurrent environment.

Understanding the nuances of these thread-related methods empowers developers to design and implement multithreaded applications that exhibit optimal concurrency behavior, scalability, and responsiveness, contributing to the development of high-performance Java software systems.

In the realm of Java programming, efficient memory management is crucial for optimizing performance. One of the lesser-known yet powerful techniques employed by Java to conserve memory is string interning. String interning is a mechanism that allows multiple string objects with the same value to share the same memory location, thus reducing memory footprint and improving performance. In this blog post, we’ll explore the concept of string interning, its implementation in Java, its benefits, and when to use it.

What is String Interning?

String interning is the process of storing only one copy of each distinct string value in memory, rather than creating multiple copies. When a string is interned, it is added to a pool of strings called the “string intern pool” or “string constant pool.” Subsequent occurrences of the same string literal or identical string values are then referenced to the same string instance in the pool, rather than creating a new object. This ensures that memory is conserved by eliminating redundancy.

Interning of String object in Java

We can use the intern() method to get the corresponding SCP (String Constant Pool) object reference by using a heap object reference (or by using a heap object reference if we want to get the corresponding SCP object reference, then we should go for the intern method).

String s1 = new String("softAai");
String s2 = s1.intern();
System.out.println(s1 == s2); // false
String s3 = "softAai";
System.out.println(s2 == s3); // true

In the heap area: s1 points to "softAai".

In the SCP area: s2 and s3 point to "softAai".

If the corresponding SCP object is not available, then the intern method itself will create the corresponding SCP object.

String s1 = new String("softAai");
String s2 = s1.concat("Apps");
String s3 = s2.intern();
System.out.println(s2 == s3); // false
String s4 = "softAaiApps";
System.out.println(s3 == s4);

In the heap area:

s1 points to "softAai".

s2 points to "softAaiApps".

In the SCP area:

"softAai", "Apps" are stored individually,

Both s3, and s4 point to "softAaiApps".

Practical Proof of Where Objects Get Created: Heap Area or SCP Area

To illustrate the practical proof of where objects are created, let’s consider the following code:

String s1 = new String("you cannot change me!");
String s2 = new String("you cannot change me!");

System.out.println(s1 == s2); // false

String s3 = "you cannot change me!";

System.out.println(s1 == s3); // false

String s4 = "you cannot change me!";
System.out.println(s3 == s4); // true

String s5 = "you cannot" + "change me!"; // ----> 1
System.out.println(s3 == s5); // true  

String s6 = "you cannot";
String s7 = s6 + "change me!"; // ----> 2

System.out.println(s3 == s7); // false

final String s8 = "you cannot";
String s9 = s8 + "change me!"; // -----> 3

System.out.println(s3 == s9);   // true
System.out.println(s6 == s8);    // true 

In the heap area:

• s1 points to “you cannot change me!”
• s2 points to “you cannot change me!”
• s7 points to “you cannot change me!”

In the SCP area:

• s3, s4, s5, s9 point to “you cannot change me!”
• s6, s8 point to “you cannot”
• “change me!” is stored individually

Note

In the above code, see lines marked as 1, 2, and 3,

Now, let’s analyze the lines marked as —->1, —->2, and —->3:

1. This operation will be performed at compile time only because both arguments are compile-time constants.
2. This operation will be performed at runtime only because at least one argument is a normal variable.
3. This operation will be performed at compile time only because both arguments are compile-time constants.

Importance of String Constant Pool (SCP)

In our program, if a string object is required to be repeated, it is not recommended to create separate objects because it creates performance and memory problems. Instead of creating separate objects for every requirement, we have to create only one object, and we can reuse the same object for every requirement. This approach improves performance and memory utilization. This efficiency is possible because of SCP. Hence, the main advantages of SCP are improved memory utilization and performance.

However, the main problem with SCP is that if several references point to the same object, using one reference to change the content will affect the remaining references. To overcome this problem, Sun implemented string objects as immutable. This means that once we create a string object, we can’t perform any changes to the existing object. If we attempt to make any changes, a new object will be created. Hence, SCP is the primary reason for the immutability of string objects.

Conclusion

String interning is a powerful memory optimization technique in Java that allows for efficient storage and retrieval of string objects. By intelligently managing memory and reducing redundancy, string interning contributes to improved performance and resource utilization in Java applications. Understanding the principles and benefits of string interning empowers Java developers to leverage this technique effectively to optimize their applications for memory and performance efficiency.

Java, being an object-oriented programming language, allows developers to create and manipulate objects. In many cases, you might encounter a situation where you need to create a copy of an existing object. This process of creating an exact copy of an object is called object cloning. Understanding object cloning in Java is essential for various programming scenarios, such as creating copies of complex objects, implementing prototype patterns, and more. In this comprehensive guide, we’ll delve into the concept of object cloning in Java, explore different techniques, and discuss best practices.

What is Object Cloning?

The process of creating an exactly duplicate object is called cloning. The main purpose of cloning is to maintain a backup copy and preserve the state of the object. We can perform cloning by using the clone method of the Object class:

protected native Object clone() throws CloneNotSupportedException

In Java, to enable cloning for objects, the corresponding class must implement the Cloneable interface. This interface, found in the java.lang package, doesn’t contain any methods; it serves solely as a marker interface. Attempting to clone an object that doesn’t implement Cloneable will result in a CloneNotSupportedException.

class Test implements Cloneable {
    int i = 10;
    int j = 20;

    public static void main(String[] args) throws CloneNotSupportedException {
        Test t1 = new Test();
        Test t2 = (Test) t1.clone();
        t2.i = 888;
        t2.j = 999;
        System.out.println(t1.i + "......" + t1.j); //10...20
    }
}

Here, Test class implements the Cloneable interface, allowing its objects to be cloned using the clone() method.

What are different approaches to cloning objects in Java

Shallow cloning and deep cloning are two different approaches to cloning objects in Java.

Shallow Cloning

Shallow cloning refers to the process of creating a bitwise copy of an object. If the main object contains primitive variables, then exactly duplicate copies will be created in the cloned object. However, if the main object contains any reference variables, then corresponding objects won’t be created; instead, duplicate reference variables will be created, pointing to the old content object. The Object class’s clone method is meant for shallow cloning.

class Cat {
  int j;
  Cat(int j) {
    this.j = j;
  }
}

class Dog implements Cloneable {
  Cat c;
  int i;
  Dog(Cat c, int i) {
    this.c = c;
    this.i = i;
  }

  public Object clone() throws CloneNotSupportedException {
    return super.clone();
  }
}

class ShallowCloning {
  public static void main(String[] args) throws CloneNotSupportedException {
    Cat c = new Cat(20);
    Dog d1 = new Dog(c, 10);
    System.out.println(d1.i + "..............." + d1.c.j);
    Dog d2 = (Dog)d1.clone();
    d2.i = 888;
    d2.c.j = 999;
    System.out.println(d1.i + "........." + d1.c.j); // Output: 10 .... 999
  }
}

In shallow cloning, if changes are made to the content object through the cloned object reference, those changes will be reflected in the main object. To overcome this problem, we should use deep cloning.

Deep Cloning

Deep cloning refers to the process of creating an exactly duplicate independent copy, including the content object. In deep cloning, if the main object contains any primitive variables, then duplicate values will be created in the cloned object. If the main object contains any reference variables, then corresponding cloned objects will be created in the cloned copy. By default, the Object class’s clone method is meant for shallow cloning, but we can implement deep cloning explicitly by overriding the clone method in our class.

class Cat {
  int j;
  Cat(int j) { 
    this.j = j; 
  } 
} 

class Dog implements Cloneable {
  Cat c;
  int i;
   
  Dog(Cat c, int i) { 
    this.c = c;
    this.i = i;
  }

  public Object clone() throws CloneNotSupportedException {
    Cat c1 = new Cat(c.j);
    Dog d  = new Dog(c1, i);
    return d;
  } 
}

class DeepCloning {
  public static void main(String[] args) throws CloneNotSupportedException {
    Cat c = new Cat(20);
    Dog d1 = new Dog(c, 10);
    System.out.println(d1.i + "......." + d1.c.j);
    Dog d2 = (Dog) d1.clone();
    d2.i = 888;
    d2.c.j = 999;
    System.out.println(d1.i + "..........." + d1.c.j);
  }
}

When using a cloned object reference, if we perform any change to the contained object, those changes won’t be reflected in the main object.

Which cloning method is the best?

While shallow cloning creates a new object with copies of the original object’s fields, including references to the same content objects, deep cloning creates a completely independent duplicate copy, including new instances of all referenced objects. The choice between shallow and deep cloning depends on the specific requirements of the cloning operation and the desired behavior of the cloned objects.

If the object contains only primitive variables, then shallow cloning is the best choice. If the object contains reference variables, then deep cloning is the best choice.

Best Practices for Object Cloning

When implementing object cloning in Java, consider the following best practices:

1. Override clone() method: Always override the clone() method to ensure proper cloning behavior.
2. Implement Cloneable interface: If you choose to use the clone() method, implement the Cloneable interface to indicate that your class supports cloning.
3. Handle CloneNotSupportedException: Handle the CloneNotSupportedException appropriately when cloning an object.
4. Deep cloning when necessary: For complex objects containing reference types, implement deep cloning to ensure that all referenced objects are also cloned.
5. Immutable classes: If possible, design your classes to be immutable to avoid the need for cloning.

Conclusion

Object cloning in Java is a powerful mechanism for creating copies of objects. By understanding the concepts of shallow and deep cloning and implementing the clone() method or Cloneable interface, you can effectively clone objects in your Java applications. However, it’s essential to be cautious while cloning objects, especially when dealing with complex data structures and mutable objects. Following best practices and considering the implications of cloning ensures that your Java applications perform as expected while maintaining the integrity of your data.

In Java, developers often encounter situations where they need to compare objects for equality. However, understanding the nuances between using the == operator and the .equals() method is crucial for writing correct and efficient code. This article delves into the relationship between these two approaches in the java.lang package, providing insights into their differences, similarities, and best practices.

Understanding the == Operator

The == operator in Java is primarily used for comparing primitive data types and object references. When applied to primitive types such as int, double, or char, it compares their values directly. For example:

int a = 5;
int b = 5;
boolean result = (a == b); // result will be true

However, when it comes to objects, the == operator behaves differently. It compares object references rather than their actual contents. Two object references are considered equal if they point to the same memory location, i.e., if they refer to the same object instance. For instance:

String str1 = new String("softAai");
String str2 = new String("softAai");
boolean result = (str1 == str2); // result will be false

Here, str1 and str2 point to different memory locations, even though their contents are the same. Therefore, the == operator returns false.

Understanding the .equals() Method

In Java, the .equals() method is used to compare the contents of objects for equality. The java.lang.Object class, which is the root class for all Java classes, provides a default implementation of the .equals() method. This default implementation compares object references similar to the == operator.

However, many classes in Java override the .equals() method to provide custom equality comparison based on the contents of objects rather than their references. For example, the String class overrides the .equals() method to compare the actual string contents:

String str1 = new String("Hello");
String str2 = new String("Hello");
boolean result = str1.equals(str2); // result will be true

In this case, the .equals() method compares the contents of str1 and str2, resulting in true since they contain the same string.

Relation between == Operator and .equals() Method

The relationship between the == operator and the .equals() method can be summarized as follows:

• If two objects are determined to be equal by the == operator, it’s guaranteed that they will also be equal when compared using the .equals() method.
  • This means that if r1 == r2 evaluates to true, then r1.equals(r2) will always be true as well.

• However, if two objects are not deemed equal by the == operator, we cannot make any assumptions about the outcome of the .equals() method. It may return either true or false.
  • In other words, if r1 == r2 evaluates to false, r1.equals(r2) may return true or false, and we cannot predict the exact result.

• Similarly, if two objects are determined to be equal by the .equals() method, we cannot infer anything about the == operator. It may return true or false.
  • So, if r1.equals(r2) is true, then r1 == r2 may return true or false, and we cannot determine the exact outcome.

• Conversely, if two objects are not equal according to the .equals() method, they will always not be equal when compared using the == operator.
  • Therefore, if r1.equals(r2) evaluates to false, then r1 == r2 will always be false as well.

Example

String s1 = new String("softAai");
String s2 = new String("softAai");
StringBuffer sb1 = new StringBuffer("softAai");
StringBuffer sb2 = new StringBuffer("softAai");

System.out.println(s1 == s2);  //false
System.out.println(s1.equals(s2)); //true
System.out.println(sb1 == sb2);  //false
System.out.println(sb1.equals(sb2)); //false
// System.out.println(s1 == sb1);  //CE: incomparable types: java.lang.String and java.lang.StringBuffer
System.out.println(s1.equals(sb1)); //false

Note: To use the == operator, there must be some relation between argument types (either child to parent, parent to child, or the same type); otherwise, we will get a compilation error saying “incomparable types.” If there is no relation between argument types, then the .equals() method won’t raise any runtime or compile-time errors; it simply returns false.

Differences between the == operator and .equals() method

The differences between the == operator and .equals() method can be summarized as follows:

== operator

• It is an operator applicable for both primitives and object types
• In the case of object references, the == operator is meant for reference comparison, which entails comparing memory addresses.
• We can’t override the == operator for content comparison
• To use the == operator, there must be a relationship between the argument types (either child to parent, parent to child, or the same type); otherwise, we will receive a compile-time error indicating “incomparable types.”

.equals() method

• It is a method applicable only for object types and not for primitives.
• By default, the .equals() method present in the object class is also intended for reference comparison.
• We can override the .equals() method for content comparison.
• If there is no relation between argument types, then .equals() won’t raise any compile-time or runtime errors and simply returns false.

In general, use the == operator for reference comparison and .equals() for content comparison;

For any object reference “r,”

both “r == null” and “r.equals(null)” always return false.

// Example:
Thread t = new Thread();
System.out.println(t == null); // false
System.out.println(t.equals(null)); // false

Also, one more thing,

Hashing-related data structures follow the following fundamental rules:

Two equivalent objects should be placed in the same bucket, but not all objects present in the same bucket need to be equal.

Contract between .equals() and hashCode()

If two objects are equal by the .equals() method, then their hashcodes must be equal; that is, two equivalent objects should have the same hashcode. Therefore, if “r1.equals(r2)” is true, then “r1.hashCode() == r2.hashCode()” is always true. The Object class’s .equals() and hashCode() methods follow these contracts; hence, whenever we override .equals(), it is compulsory to override hashCode() to satisfy these contracts. This ensures that two equivalent objects have the same hashcode.

If two objects are not equal by .equals(), then there are no restrictions on their hashcodes; they may be equal or not equal. If the hashcodes of two objects are equal, we cannot conclude anything about .equals(); it may return true or false. However, if the hashcodes of two objects are not equal, then these objects are always not equal by the .equals() method.

Note: To satisfy the contract between equals and hashCode methods, whenever we are overriding .equals(), it is compulsory to override the hashCode method; otherwise, we won’t get any compile-time or runtime error, but it is not a good programming practice.

In the String class, .equals() is overridden for content comparison, hence the hashCode method is also overridden to generate a hashcode based on content. For example:

String s1 = new String("softAai");
String s2 = new String("softAai");
System.out.println(s1.equals(s2)); // true
System.out.println(s1.hashCode()); // 95950491
System.out.println(s2.hashCode()); // 95950491

In the StringBuffer class, .equals() is not overridden for content comparison, and hence the hashCode method is also not overridden. For example:

StringBuffer sb1 = new StringBuffer("softAai");
StringBuffer sb2 = new StringBuffer("softAai");
System.out.println(sb1.equals(sb2)); // false
System.out.println(sb1.hashCode()); // 19621457
System.out.println(sb2.hashCode()); // 4872882

It is highly recommended to override the hashCode() method. In all collection classes, in all wrapper classes, and in the String class, .equals() is overridden for content comparison; hence, it is highly recommended to override .equals() as well for content comparison.

Best Practices

To ensure correctness and efficiency in your Java code, consider the following best practices:

1. Use the == operator for primitive types and object reference comparison.
2. Use the .equals() method for comparing the contents of objects, especially when dealing with strings, arrays, and custom classes.
3. Override the .equals() method in custom classes to provide meaningful content comparison.
4. Be cautious when comparing objects of different types, as the behavior of == and .equals() may vary depending on the implementation.

Conclusion

Understanding the relationship between the == operator and the .equals() method is essential for writing robust and efficient Java code. By knowing when to use each approach and following best practices, developers can ensure correct object comparison and avoid common pitfalls. Whether comparing object references or their contents, choosing the appropriate method is key to achieving desired behavior in Java applications.

Java, being a statically-typed language, often requires explicit type conversions and careful handling of primitive types and their corresponding wrapper classes. However, certain features introduced in later versions of Java, particularly in the java.lang package, aim to simplify the process of working with primitive types and their object counterparts. In this article, we’ll delve into four such features: autoboxing, auto-unboxing, widening, and varargs methods.

Autoboxing and Auto-Unboxing

Autoboxing and auto-unboxing were introduced in Java 5 as a means to automatically convert between primitive types and their corresponding wrapper classes (Integer, Double, Boolean, etc.) without explicit intervention from the programmer.

Autoboxing

Autoboxing refers to the automatic conversion from a primitive type to its corresponding wrapper object by the compiler.

For example, when we write: Integer I = 10, the compiler converts the int to Integer automatically through autoboxing.

After compilation, the above line becomes: Integer I = Integer.valueOf(10);. Internally, autoboxing is always implemented using .valueOf().

So, Integer I = Integer.valueOf(10); is what the compiler executes at the time of autoboxing.

Auto-Unboxing

AutoUnboxing refers to the automatic conversion of a wrapper object to its corresponding primitive type by the compiler.

For example:

Integer I = new Integer(10);
int i = I;  // Compiler converts Integer to int automatically by autounboxing

After compilation, the above line becomes:

int i = I.intValue();

Internally, the autounboxing concept is implemented using xxxValue() methods.

The conversion can be summarized as follows:

• Primitive value ———– Autoboxing[valueOf()] ——————-> Wrapper object
• Wrapper object ————- AutoUnboxing[xxxValue()] —————-> Primitive value

Here’s an example demonstrating autoboxing and autounboxing in code:

class Test {
    static Integer I = 10;   // AutoBoxing
    public static void main(String[] args) { 
        int i = I;  // AutoUnboxing
        m1(i);   
    } 

    public static void m1(Integer K) {  // AutoBoxing
        int m = K; // AutoUnboxing
        System.out.println(m);  // Output: 10 
    }
} 

Just because of autoboxing and autounboxing, we can use wrapper class objects and primitives interchangeably from Java 1.5 onwards.

Example 2:

class Test {
    static Integer I = 0;
    public static void main(String[] args) { 
        int m = I;
        System.out.println(m);   // Output: 0
    }
}

However, if the wrapper object is null when performing autoboxing, it will result in a NullPointerException:

class Test {
    static Integer I;
    public static void main(String[] args) {
        int m = I;  
        System.out.println(m); // NullPointerException
    }
}

To avoid NullPointerException in such cases, ensure that the wrapper object is not null before performing autounboxing.

Lets see one more example for another use case

Integer X = 10;
Integer Y = X;

X++;

System.out.println(X);  // Output: 11
System.out.println(Y);  // Output: 10

System.out.println(X == Y); // Output: false

Explanation:

1. Integer X = 10;: This line creates an Integer object X with the value 10.
2. Integer Y = X;: Here, a reference to the same Integer object that X points to is assigned to Y.
3. X++;: This increments the value of X by 1. Since Integer objects are immutable, a new Integer object with the value 11 is created, and X now points to this new object.
4. System.out.println(X);: Prints the value of X, which is 11.
5. System.out.println(Y);: Prints the value of Y, which still holds the original value of X, i.e., 10.
6. System.out.println(X == Y);: Compares the references of X and Y, which are pointing to different objects after the increment operation, hence it returns false.

Note: All wrapper classes are immutable, meaning once we create a wrapper object, we cannot modify its value. If we attempt to perform any changes to it, a new object will be created instead. This is why a new Integer object with the value 11 is created when we increment X.

Few more examples:

Example 1

Integer x = new Integer(10);  // x => 10
Integer y = new Integer(10);  // y => 10
System.out.println(x == y);   // Output: false

x and y are referencing different Integer objects, even though they hold the same value 10. Therefore, the comparison using == returns false.

Example 2

Integer x = new Integer(10);  // x => 10
Integer y = 10;                // y => 10
System.out.println(x == y);    // Output: false

x refers to a new Integer object with the value 10, while y refers to an Integer object from the Integer cache. Though they hold the same value, they are different objects, hence false is printed.

Example 3

Integer x = 10;   // x, y => 10
Integer y = 10;
System.out.println(x == y);   // Output: true

Both x and y refer to the same Integer object with the value 10. In this case, they are referencing the same cached object, so the comparison using == returns true.

Example 4

Integer x = 100;   // x, y => 100
Integer y = 100;
System.out.println(x == y);   // Output: true

Similar to the previous case, x and y reference the same Integer object with the value 100, which is within the range of the Integer cache. Hence, true is printed.

Example 5

Integer x = 1000;  // x => 1000
Integer y = 1000;  // y => 1000
System.out.println(x == y);   // Output: false

The values 1000 are outside the range of the Integer cache (-128 to 127), so new Integer objects are created for both x and y, resulting in false when compared using ==.

To facilitate autoboxing, Java internally maintains a buffer of wrapper objects upon the loading of wrapper classes. This buffer strategy optimizes memory usage by reusing existing objects. When an object is required, the JVM checks if it’s already present in the buffer. If so, the existing object is utilized; otherwise, a new object is created.

The buffer concept is available only within specific ranges for each wrapper type:

• Byte: Always available.
• Short: Ranges from -128 to 127.
• Integer: Ranges from -128 to 127.
• Long: Ranges from -128 to 127.
• Character: Ranges from 0 to 127.
• Boolean: Always available.

See below example usage which demonstrating buffer behavior

Integer x = 127;
Integer y = 127;
System.out.println(x == y);  // Output: true

Integer x = 128;
Integer y = 128;
System.out.println(x == y);  // Output: false

Boolean x = false;
Boolean y = false;
System.out.println(x == y);  // Output: true

Double x = 10.0;
Double y = 10.0;
System.out.println(x == y);  // Output: false

Internally, autoboxing is implemented using valueOf(), so the buffer concept applies to it as well.

Examples using valueOf():

Integer x = new Integer(10);
Integer y = new Integer(10);
System.out.println(x == y);  // Output: false

Integer x = 10;
Integer y = 10;
System.out.println(x == y);  // Output: true

Integer x = Integer.valueOf(10);
Integer y = Integer.valueOf(10);
System.out.println(x == y);  // Output: true

Integer x = 10;
Integer y = Integer.valueOf(10);
System.out.println(x == y);  // Output: true

Widening Methods

Let’s delve into overloading with respect to autoboxing, widening, and varargs, but befor that let’s see what is widening exactly.

Widening refers to the automatic conversion of a smaller data type to a larger data type in the hierarchy. In Java, the widening conversion follows the hierarchy: byte -> short -> char -> int -> long -> float -> double.

In the given example:

class Test {
    public static void m1(Integer I) {
        System.out.println("Autoboxing");
    }

    public static void m1(long l) {
        System.out.println("Widening");
    }

    public static void main(String args[]) {
        int x = 10;
        m1(x);
    }
}

Explanation:

• We have two overloaded methods m1: one accepts an Integer parameter, and the other accepts a long parameter.
• In the main method, we have an int variable x.
• When we call m1(x), the int value x undergoes widening to match the long parameter, as widening is preferred over autoboxing.
• Therefore, the output will be “Widening”.

This happens because widening is applicable from Java 1.0 version and gets priority over autoboxing, which was introduced later in Java 1.5 version.

Varargs Methods

Varargs, short for variable-length arguments, allow methods to accept a variable number of arguments of a specified type. This feature simplifies the creation of methods that operate on a variable number of inputs.

Syntax

The syntax for declaring a varargs parameter is to use an ellipsis (...) after the parameter type.

public void exampleMethod(String... strings) {
    // Method body
}

public void printValues(String... values) {
    for (String value : values) {
        System.out.println(value);
    }
}

// Invoking the method
printValues("Hello", "World"); // Output: Hello\nWorld
printValues("Java", "is", "awesome"); // Output: Java\nis\nawesome

Now, Let’s see overloading with respect to varargs and widening.

class Test {
    public static void m1(Int... x) {
        System.out.println("Varargs method");
    }

    public static void m1(long l) {
        System.out.println("Widening");
    }

    public static void main(String args[]) {
        int x = 10;
        m1(x);
    }
}

• We have two overloaded methods m1: one accepts a varargs parameter of type Int, and the other accepts a long parameter.
• In the main method, we have an int variable x.
• When we call m1(x), the int value x undergoes widening to match the long parameter, as widening is preferred over varargs methods.
• Therefore, the output will be “Widening” (as widening is from 1.0v to it gets first chance instead of Autoboxing).

Let’s see overloading with respect to varargs, autoboxing, and widening

class Test {
    public static void m1(Int... x) {
        System.out.println("Varargs method");
    }

    public static void m1(Integer I) {
        System.out.println("Autoboxing");
    } 

    public static void main(String args[]) {
        int x = 10;
        m1(x);
    }
}

• We have two overloaded methods m1: one accepts a varargs parameter of type Int, and the other accepts an Integer parameter.
• In the main method, we have an int variable x.
• When we call m1(x), the int value x undergoes autoboxing to match the Integer parameter, as autoboxing is preferred over varargs methods.
• Therefore, the output will be “Autoboxing”.

This happens because, while resolving overloaded methods, the compiler gives priority to widening, then autoboxing, and finally varargs methods. Since autoboxing has a higher priority than varargs, it gets selected in this scenario.

Order Priority -> 1. Widening 2. Autoboxing 3. var-arg method

Compilation Error (CE)

In some cases compiler error occurs, Let’s see why we face a compilation error (CE).

class Test {
  public static void m1(Long l) { 
    System.out.println("Long");
  } 
  
  public static void main (String args[]) {
    int x = 10;
    m1(x);
  }
}

Compilation Error: m1(java.lang.Long) in Test cannot be applied to (int)

Here, compiler error occurs because there’s no direct conversion path from int to Long involving both autoboxing and widening.

1. In the m1 method, the parameter type is Long.
2. In the main method, an int variable x is declared and initialized with the value 10.
3. When calling m1(x), the compiler attempts to find a suitable method to match the argument x, which is of type int.
4. In Java, there are no implicit conversions from int to Long that involve both autoboxing and widening. Although int can be widened to long and then autoboxed to Long, this kind of conversion sequence is not supported by the compiler.
5. Therefore, the compiler reports a compilation error because there is no suitable overload of m1 that accepts an int argument directly or through a sequence of implicit conversions involving autoboxing and widening.
6. To resolve the error, you can either change the type of x to Long or provide a suitable overload of m1 that accepts an int argument or its equivalent types.

This limitation arises because after widening, autoboxing is not implemented in Java. However, after autoboxing, widening is internally implemented. This means that widening followed by autoboxing is not supported directly, leading to the compilation error.

What will happen in case of Java Objects

class Test {
    public static void m1(Object o) {
        System.out.println("Object version");
    }
  
    public static void main(String[] args) {
        int x = 10;
        m1(x);
    }
}

The output will be “Object version”. As we know autoboxing then widening is possible in java

Explanation:

• The method m1(Object o) expects a parameter of type Object.
• In the main method, we have an int variable x.
• When m1(x) is called, autoboxing is applied to convert int to Integer.
• Then, widening is applied to convert Integer to Object, as widening is applicable in Java.
• Therefore, the method m1(Object o) is invoked with the argument Integer, and the output will be “Object Version”.

Additionally, the statements:

Object o = 10;  // is perfectly valid
Number n = 10;  // is also perfectly valid

These statements are valid because of autoboxing. In Java, autoboxing allows automatic conversion between primitive types and their corresponding wrapper classes (e.g., int to Integer, double to Double, etc.). Since Integer is a subclass of Object, and Integer is a subclass of Number, the assignments Object o = 10; and Number n = 10; are perfectly valid.

Conclusion

Autoboxing, auto-unboxing, widening, and varargs methods are features introduced in Java to simplify the handling of primitive types and method parameterization. They enhance code readability, reduce boilerplate, and provide more flexibility in method invocation. However, it’s essential to understand their implications and usage patterns to leverage them effectively in Java programming.

In Java programming, the java.lang package plays a pivotal role, containing fundamental classes and interfaces that are automatically imported into every Java program. Among these classes, the wrapper classes stand out as essential components that bridge the gap between primitive data types and objects. In this article, we delve into the nuances of wrapper classes, exploring their significance, usage, and practical applications within the Java ecosystem.

What are Wrapper Classes?

In Java, data types can be classified into two categories: primitive types (such as int, double, boolean) and reference types (objects). While primitive types offer efficiency and simplicity, they lack the ability to participate in object-oriented paradigms directly. Wrapper classes address this limitation by providing an object representation for each primitive type, allowing them to be treated as objects.

Imagine a scenario where you need to store primitive data types (like int, char, boolean) within collections, pass them as arguments to methods expecting objects, or perform operations that leverage object-oriented features. This is where wrapper classes come to the rescue! They essentially “wrap” primitive data types into objects, bestowing upon them the power of object-oriented capabilities.

Wrapper classes’ main objective is to wrap primitives into object form so that we can handle primitives just like objects.

Several utility methods are required for primitives.

Almost all wrapper classes contain two constructors: one that can take corresponding primitives as arguments and another one that can take a string as an argument.

Example 1

Integer I = new Integer(10);
Integer I = new Integer("10");

Example 2

Double D = new Double(10.5);
Double D = new Double("10.5");

Note: If the string argument does not represent a number, then we will get a NumberFormatException. For example, Integer I = new Integer("ten"); will result in a NumberFormatException.

Integer I = new Integer("ten"); // Resulting in a NumberFormatException

List of Wrapper Classes

Wrapper classes serve the purpose of encapsulating primitive data types into object form, facilitating the handling of primitives as objects. Each wrapper class provides constructors tailored to accept either the corresponding primitive type or a string representation.

Byte

Constructor Arguments: byte or String

Short

Constructor Arguments: short or String

Integer

Constructor Arguments: int or String

Long

Constructor Arguments: long or String

Float

Constructor Arguments: float, double, or String

Example Usage:

Float f = new Float(10.5f);
Float f = new Float("10.5");
Float f = new Float(10.5);
Float f = new Float("10.5");

Note: Float class can contain three constructors with float, double, and string arguments.

Double

Constructor Arguments: double or String

Character

Constructor Arguments: char

Character ch = new Character('a'); // Correct
Character ch = new Character("a"); // Incorrect

Note: Character class contains only one constructor which can take only one argument, that is, char and does not take a String constructor.

Boolean

Constructor Arguments: boolean or String

Boolean class contains two constructors which can take boolean and String arguments, that is, boolean and String constructor. but there are some twists, Let’s see it.

Case 1: When passing boolean primitives, only allowed values are true and false where case is important and content also very important.

Boolean B = new Boolean(true);  // Correct
Boolean B = new Boolean(false); // Correct
Boolean B = new Boolean(True);  // Incorrect
Boolean B = new Boolean(amol); // Incorrect

Case 2: When passing a String as an argument, case and content both are not important. If the content is a case-insensitive String of “true”, then it is treated as true; otherwise, it is treated as false.

Boolean B = new Boolean("true");  // true
Boolean B = new Boolean("True");  // true
Boolean B = new Boolean("TRUE");  // true 
Boolean B = new Boolean("malaika"); // false
Boolean B = new Boolean("mallika"); // false
Boolean B = new Boolean("jareena"); // false

Let’s see one more example,

Boolean X = new Boolean("yes"); 
Boolean Y = new Boolean("no");  

System.out.println(X);  // Output: false
System.out.println(Y);  // Output: false
System.out.println(X.equals(Y)); // Output: true

Note: In all wrapper classes, toString method is overridden to return content directly, and .equals method is overridden for content comparison.

Utility Methods

1.valueOf()
2.xxxValue()
3.parseXxx()
4.toString()

Here’s the breakdown of the utility methods for wrapper classes:

1. valueOf()

Every wrapper class except the Character class contains a public static method valueOf(String s) which can take a String as an argument to create the corresponding wrapper class.

public static wrapper valueOf(String s)

Example:

Integer I = Integer.valueOf("10");
Double D = Double.valueOf("10.5");
Boolean B = Boolean.valueOf("softAai");

Form 2

Every integral type wrapper class (Byte, Short, Integer, Long) contains the following valueOf method to create a wrapper object for the specified radix string.

public static wrapper valueOf(String s, int radix);

Note: Radix is the parameter that specifies the number system to be used. For example, binary = 2, octal = 8, hexadecimal = 16, etc. The allowed range of radix is 2 to 36.

Example:

Integer I = Integer.valueOf("100", 2);
System.out.println(I); // Output: 4

Integer I = Integer.valueOf("101", 4);
System.out.println(I); // Output: 17

Form 3

Every wrapper class including the Character class contains a public static method valueOf(primitive p) to create a wrapper object for the given primitive.

public static wrapper valueOf(primitive p);

Integer I = Integer.valueOf(10);
Double D = Double.valueOf(10.5);
Character ch = Character.valueOf('a');

In short, valueOf() methods are used to create wrapper objects for given primitive or string values.

Primitive/String ——– valueOf() ———> Wrapper Object

2. xxxValue()

We can use xxxValue() methods to get the primitive value from a given wrapper object.

Every number type wrapper class (Integer, Byte, Short, Long, Float, Double) contains the following methods to get primitive values for a given wrapper object:

1. byteValue():
   • Returns the byte primitive value of the wrapper object.
   • Method Signature: public byte byteValue()
2. shortValue():
   • Returns the short primitive value of the wrapper object.
   • Method Signature: public short shortValue()
3. intValue():
   • Returns the int primitive value of the wrapper object.
   • Method Signature: public int intValue()
4. longValue():
   • Returns the long primitive value of the wrapper object.
   • Method Signature: public long longValue()
5. floatValue():
   • Returns the float primitive value of the wrapper object.
   • Method Signature: public float floatValue()
6. doubleValue():
   • Returns the double primitive value of the wrapper object.
   • Method Signature: public double doubleValue()

Integer I = new Integer(130);
System.out.println(I.byteValue());    // Output: -126
System.out.println(I.shortValue());   // Output: 130
System.out.println(I.intValue());     // Output: 130
System.out.println(I.longValue());    // Output: 130
System.out.println(I.floatValue());   // Output: 130.0
System.out.println(I.doubleValue());  // Output: 130.0

These methods allow us to obtain the primitive values (byte, short, int, long, float, double) from the given wrapper object.

• charValue():
  • The charValue() method is available in the Character class to get the char primitive value for a given character object.
  • Method Signature: public char charValue()

Character ch = new Character('a');
char c = ch.charValue();
System.out.println(c); // Output: 'a'

This method allows us to obtain the char primitive value from the given character object.

• booleanValue():
  • The booleanValue() method is available in the Boolean class to get the boolean primitive value for the given Boolean object.
  • Method Signature: public boolean booleanValue()

Boolean B = Boolean.valueOf("softAai");
boolean b = B.booleanValue();
System.out.println(b); // Output: false

This method allows us to obtain the boolean primitive value from the given Boolean object.

In total, there are 38 (6*6 + 1 + 1) xxxValue() methods present.

Wrapper Object ———————— xxxValue() ———————-> Primitive Value

3. parseXxx()

We can use parseXxx() methods to convert a String to a primitive.

String ——————- parseXxx() ———————-> primitive

Form 1:

Every wrapper class except the Character class contains the following parseXxx() method to find the primitive for the given String object.

public static primitive parseXxx(String s);

int i = Integer.parseInt("10");
double d = Double.parseDouble("10.5");
boolean b = Boolean.parseBoolean("true");

Form 2:

Every integer wrapper class (Byte, Short, Integer, Long) contains the following parseXxx() method to convert a specified radix String to a primitive. The allowed range of radix is 2 to 36.

public static primitive parseXxx(String s, int radix);

int i = Integer.parseInt("1111", 2);
System.out.println(i); // Output: 15

4. toString()

We can use toString() to convert a wrapper object or primitive to a String.

Form 1

Every wrapper class contains the following toString() method to convert a wrapper object to a String type.

public String toString();

It is an overriding version of the toString() method in the Object class. Whenever we try to print a Wrapper class reference, internally this toString() method will be called.

Integer I = new Integer(10);
String s = I.toString();
System.out.println(s); // Output: "10"

System.out.println(I); // internally calls I.toString(), Output: "10"

Wrapper Object ——————- toString() ———————-> String

Form 2

Every wrapper class, including the Character class, contains the following static toString() method to convert a primitive value to a String type.

public static String toString(primitive p)

String s = Integer.toString(10);
String s = Boolean.toString(true);
String s = Character.toString('a');

This method is particularly useful when you need to convert a primitive value to a String without creating an object of the corresponding wrapper class.

Primitive Value ——————- toString() ———————-> String

Form 3

Integer and Long classes contain the following static toString() method to convert a primitive to a radix String.

public static String toString(primitive p, int radix);

The allowed radix range is from 2 to 36.

String s = Integer.toString(15, 2);
System.out.println(s);  // Output: "1111"

This method is particularly useful when you need to convert a primitive value to a String representation in a specific radix (base).

Form 4

Integer and Long wrapper classes contain the following toXxxString() methods to convert a primitive to a String in binary, octal, and hexadecimal form.

public static String toBinaryString(primitive p);

public static String toOctalString(primitive p);

public static String toHexString(primitive p);

String s = Integer.toBinaryString(10);
System.out.println(s); // Output: "1010"

String s = Integer.toOctalString(10);
System.out.println(s); // Output: "12"

String s = Integer.toHexString(10);
System.out.println(s); // Output: "a"

These methods allow you to obtain a string representation of the given primitive value in binary, octal, or hexadecimal form. They are particularly useful for formatting output or performing bitwise operations.

Wrapper Object / Primitive ———————- toString() —————————–> String

Conversions between String, WrapperObject, and Primitive

Wrapper Object to String:

• Using toString(): Converts a wrapper object to a String.

Wrapper Object ----------------- toString --------------------> String

Wrapper Object to Primitive Value:

• Using XxxValue(): Extracts the primitive value from a wrapper object.

Wrapper Object ------------------ XxxValues() ---------------------> Primitive Value

String to Primitive Value:

• Using parseXxx(): Converts a String to a primitive value.

String ------------------------- parseXxx() -------------------------> Primitive Value

String to Wrapper Object:

• Using valueOf(): Converts a String to a wrapper object.

String -------------------------- valueOf() -----------------------------> Wrapper Object

Primitive Value to Wrapper Object:

• Using valueOf(): Converts a primitive value to a wrapper object.

Primitive Value ---------------- valueOf() ----------------> Wrapper Object

Primitive Value to String:

Using toString(): Converts a primitive value to a String.

Primitive Value ----------------- toString() --------------------> String

Here we saw various conversions between String, Wrapper Object, and Primitive Value in Java. Each step serves a specific purpose and facilitates flexible data manipulation within the Java ecosystem.

Partial Hierarchy of java.lang package

• Object:
  • String, StringBuffer, StringBuilder, Number, Boolean, Character, Void, …
• Number:
  • Byte, Short, Integer, Long, Float, Double

Object ──┬─ String
         ├─ StringBuffer
         ├─ StringBuilder
         ├─ Number ──┬─ Byte
         │           ├─ Short
         │           ├─ Integer
         │           ├─ Long
         │           ├─ Float
         │           └─ Double
         ├─ Boolean
         ├─ Character
         └─ Void

Conclusions:

1. Wrapper classes which are not child classes of Number are Boolean and Character.
2. Wrapper classes which are not direct child classes of Object are Byte, Short, Integer, Long, Float, Double.
3. Final wrapper classes are String, StringBuffer, and StringBuilder.
4. In addition to the String class, all wrapper class objects are also immutable.
5. Sometimes Void class is also considered a wrapper class.

Void class

• It is a final class and is the direct child class of Object. It doesn’t contain any methods and contains only one variable, Void.TYPE.
• In general, we can use the Void class in reflection to check whether any method return type is void or not.

if(getMethod("m1").getReturnType() == Void.TYPE)

Void is the class representation of the void keyword in Java.

Conclusion

Wrapper classes in the java.lang package play a crucial role in Java programming, providing a bridge between primitive types and objects. They offer a range of features and utilities, including conversion, nullability, and seamless integration with collections and generics. While wrapper classes enhance the flexibility and expressiveness of Java code, developers should be mindful of their performance implications in certain contexts. By understanding the nuances of wrapper classes, developers can leverage them effectively to write robust and maintainable Java applications.

In conclusion, wrapper classes are integral components of the Java language, empowering developers to work with primitive types in an object-oriented manner. Their versatility and utility make them indispensable in various programming scenarios, enriching the Java ecosystem with enhanced expressiveness and functionality.

In the realm of Java programming, the java.lang.Object class holds a position of utmost importance. It serves as the root of the class hierarchy, making it a foundational element of the Java language. Understanding the Object class is crucial for every Java developer, as it forms the basis for many core concepts and functionalities within the language.

Understanding the java.lang Package

For any Java program, the most commonly required classes and interfaces are grouped together into a separate single package known as the java.lang package. We are not required to import the java.lang package because all classes and interfaces in this package are by default available to all Java classes.

Java Object Class (java.lang.Object)

The most commonly required methods for any Java class are grouped into a single class called the Object class. It is also the root class for any Java class. If any Java class does not extend any other Java class, then it is a direct child class of the Object class; otherwise, it is an indirect child class of the Object class. When it is an indirect child of the Object class, it is multi-level inheritance, not multiple inheritance.

For example, class A extends B i.e., A --> B --> Object. This is multilevel inheritance and not multiple inheritance.

Whether directly or indirectly, Java does not support multiple inheritance with respect to Java classes.

The Object class defines the following 11 methods:

• public String toString()
• public native int hashCode()
• public boolean equals(Object o)
• protected native Object clone() throws CloneNotSupportedException
• protected void finalize() throws Throwable
• public final Class getClass()
• public final void wait() throws InterruptedException
• public final native void wait(long ms) throws InterruptedException
• public final native void wait(long ms, int ns) throws InterruptedException
• public native final void notify()
• public native final void notifyAll()

Note: The Object class contains a 12th method, but it is for internal purposes for the JVM: private static native void registerNatives.

toString(): This method is used to get the string representation of an object. If our class does not contain toString(), then the toString() method of the Object class will be executed. The Object class toString() method is: public String toString(){return getClass().getName() + "@" + Integer.toHexString(hashCode());}. For example, classname@hashcode-in-hexadecimal-form, i.e., Student@1888759.

Based on our requirement, we can override toString() in any Java class, and it is highly recommended. For example: public String toString(){return name + "..." + rollno;}.

hashCode(): Based on the object’s address, the JVM will generate a unique number called the hash code of that object. It doesn’t mean the object’s address is the hash code of that object. The JVM will generate a hash code for hashing-related data structures like HashTable, HashMap, HashSet to store objects into buckets based on their hash codes so that searching for that object becomes very efficient. As we know, the number one searching algorithm is hashing, and its time complexity is O(1).

public native int hashCode(); 

We can override the hashCode() method of the Object class according to our requirement. Suppose we want to override hashCode() in the Student class; then, it will return the unique roll number of the student. This is the proper way to implement the hashCode method.

equals(): For example, obj1.equals(obj2).

If our class doesn’t contain equals(), then the equals() method of the Object class will be executed. The equals() method of the Object class is built for reference comparison, not for content comparison.

For example:

Student s1 = new Student("amol", 101);   
Student s2 = new Student("softAai", 102); 
Student s3 = new Student("amol", 101); 
Student s4 = s1;

System.out.println(s1.equals(s2)); // false, as the Object class equals() is built for reference comparison
System.out.println(s1.equals(s3)); // false, even though the content is equal, the references are different
System.out.println(s1.equals(s4)); // true, as both references are pointing to the same object, meaning the references are equal

Now, based on our requirement, we can override the equals() method of the Object class for content comparison into our own class. But while doing this, we need to take care of the following things:

• Determine whether we are comparing the whole content (student name, roll number) or only specific content (only roll number), and implement our equals() accordingly.
• Ensure that if we pass a different object, it will not raise a ClassCastException, and if we pass null, it won’t raise a NullPointerException. In both cases, we need to handle them by returning false.

In the case of Strings

String s1 = new String("softAai");
String s2 = new String("softAai");

System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true

// In the case of StringBuffer:

StringBuffer sb1 = new StringBuffer("softAai");
StringBuffer sb2 = new StringBuffer("softAai");

System.out.println(sb1 == sb2); // false
System.out.println(sb1.equals(sb2)); // false

“==” is built for reference comparison. In the case of the String class, the equals() method is overridden for content comparison. Therefore, even though the objects are different, if the content is the same, equals() returns true. However, for StringBuffer, the equals() method is not overridden for content comparison, so if the objects are different, equals() returns false even if the content is the same. Its behavior is like the equals() method of the Object class, built for reference comparison.

getClass() is used to get the runtime class definition of an object so that we can access class-level properties like class name, declared methods, and constructors. The signature is: public final Class getClass(). We can utilize the Reflection API for this purpose from java.lang.reflection.*.

The finalize() method is called just before an Object is destroyed by the garbage collector to perform cleanup activities. Once the finalize method completes, the garbage collector automatically destroys that object.

Other methods like wait(), notify(), and notifyAll() are discussed in more detail in multithreading.

We can use these methods for inter-thread communication. The thread that is expecting an update is responsible for calling wait(), which immediately puts the thread into a waiting state. The thread responsible for performing the update can then call notify(). The waiting thread will receive that notification and continue its execution with those updates.

ay to create string objects from different sources such as literals, StringBuffer objects, char arrays, or byte arrays, offering flexibility in string manipulation and handling in Java.

Conclusion

Empower your Java programming journey by mastering the Object class and its myriad functionalities. With our comprehensive guide, you’ll gain a deeper understanding of Java’s foundational concepts and learn how to harness the full potential of the Object class for building robust and scalable applications. Start exploring today and elevate your Java programming skills to new heights!

The java.lang package forms the core foundation of the Java programming language, encompassing fundamental classes and utilities essential for Java development. Within this package, crucial classes like String, StringBuffer, StringBuilder, and various primitive data types reside, offering robust functionalities for string manipulation, mathematical operations, and more. Understanding the nuances of these classes, including their differences, constructors, methods, and best practices, is vital for every Java developer. Moreover, delving into concepts such as immutability, synchronization, and method chaining within the java.lang package provides insights into efficient coding practices and performance optimization strategies.

java.lang package String Basic Concept in Java

In Java, strings are immutable. Once a string object is created, any attempt to modify it actually results in the creation of a new string object. This immutability means that the original object remains unchanged. Let’s dive into the distinction between immutable and mutable objects.

Consider the following snippet:

String s = new String("softAai");
s.concat("Apps");
System.out.println(s); // Output: softAai

s ---> softAai
       |
        ----> softAaiApps // Here, a new object will be created with those changes, but it doesn't hold any reference in this case. So, by default, it is eligible for garbage collection.

Here clearly shows that, once we create a string object, we can’t perform any changes to the existing object. If we try to perform any change, a new object will be created with those changes. This non-changeable behavior is known as the immutability of strings.

Mutable Objects: StringBuffer

Let’s examine another scenario involving a mutable object, StringBuffer:

StringBuffer sb = new StringBuffer("softAai");
sb.append("Apps");
System.out.println(sb); // Output: softAaiApps

sb ---> softAaiApps

Unlike strings, StringBuffer objects in Java are mutable. This means that modifications can be made directly to the existing object without creating new ones.

Here’s what happens:

Initially, sb references the StringBuffer object containing “softAai”.

Upon calling sb.append("Apps"), the content of sb is modified to “softAaiApps” in place.

As a result, when we print sb, it displays “softAaiApps”, reflecting the changes made directly to the original object.

This mutability allows for efficient manipulation of StringBuffer objects, as they can be altered without the overhead of creating new objects.

Understanding “==” Vs .equals() in Java Strings

Let’s explore the comparison between “==” and .equals() methods in Java strings:

String s1 = new String("softAai");
String s2 = new String("softAai");
System.out.println(s1 == s2);      // Output: false
System.out.println(s1.equals(s2)); // Output: true

//Note: This not output

s1 --> softAai
s2 --> softAai

In the String class, .equals() is overridden for content comparison. Hence, even though the objects are different, if the content is the same, .equals() returns true.

Here’s what’s happening:

Initially, s1 and s2 both reference separate String objects with the content “softAai”.

When we use “==” to compare s1 and s2, it checks whether they reference the same object in memory. Since s1 and s2 are distinct objects, the result is false.

However, when we use .equals(), it compares the content of the strings. In the case of String objects, the .equals() method is overridden to compare the content of the strings rather than their references. Since the content of s1 and s2 is the same, .equals() returns true.

This distinction is important: “==” checks for reference equality, while .equals() checks for content equality. In the context of strings, .equals() is typically used to compare their actual values.

Exploring “==” vs. .equals() in StringBuffer

By the way, what will happen in StringBuffer? 🤔

Let’s analyze the behavior of “==” and .equals() methods when used with StringBuffer objects:

StringBuffer sb1 = new StringBuffer("softAai");
StringBuffer sb2 = new StringBuffer("softAai");
System.out.println(sb1 == sb2);         // Output: false
System.out.println(sb1.equals(sb2));    // Output: false

sb1 --> softAai
sb2 --> softAai

In Java, “==” compares references, while .equals() typically compares content, but in the case of StringBuffer, .equals() does not compare content; instead, it defers to the default implementation of the equals() method in the Object class, which checks for reference equality.

Here’s what’s happening:

Initially, sb1 and sb2 reference separate StringBuffer objects with the content “durga”.

When we use “==” to compare sb1 and sb2, it checks whether they reference the same object in memory. Since sb1 and sb2 are distinct objects, the result is false.

Similarly, when we use .equals(), it compares the references of sb1 and sb2, not their content. Since they are distinct objects, .equals() returns false.

In StringBuffer, .equals() doesn’t override the behavior inherited from the Object class, so it performs reference comparison rather than content comparison. Thus, even though the content of sb1 and sb2 is the same, .equals() returns false because they refer to different objects in memory.

Understanding the String Constant Pool (SCP)

The String Constant Pool (SCP) in Java is a special memory area within the Java Virtual Machine (JVM) that stores unique string literals (sequence of characters enclosed in double quotation marks (")). When you create a string using double quotes (e.g., "softAai"), Java checks if a string with the same value already exists in the SCP. If it does, the existing string reference is returned; otherwise, a new string is created and added to the SCP.

Here’s how the String Constant Pool works:

String Constant Pool (SCP)
--------------------------
|                        |
--------------------------

Initially, the SCP is empty. When we create a string literal "softAai", it’s added to the SCP:

String Constant Pool (SCP)
--------------------------
|     "softAai"          |
--------------------------

If you create another string literal with the same value "softAai", Java will reuse the existing string from the SCP instead of creating a new one:

String Constant Pool (SCP)
--------------------------
|     "softAai"          |
--------------------------

This behavior helps to conserve memory by avoiding the creation of duplicate string objects with the same value. However, it’s important to note that string objects created using the new keyword (e.g., new String("softAai")) are not added to the SCP, even if they have the same value as existing literals.

Case1: String Created Using ‘new’ Keyword

String s = new String("softAai");

In this case, two objects are created: one in the heap area and the other in the SCP area. The variable s always points to the object in the heap.

Here’s the breakdown:

In the heap area, a new String object is created with the content “softAai”, and s references this object.

s ==> softAai

In the SCP area, another String object with the content “softAai” is created. However, this object isn’t pointed to by any reference; it exists solely in the SCP.

String Constant Pool (SCP)
--------------------------
|     "softAai"          |
-------------------------- 

// not pointing to any reference

So,

In the heap area: s points to the String object containing “softAai”. In the SCP area: There’s a String object with the content “softAai”, but it’s not referenced by any variable.

Case2: String Created Using String Literal (“”)

String s = "softAai";

In this case, only one object is created in the SCP area, and s is always pointing to that object.

In the heap area, nothing is created.

In the SCP area:

String Constant Pool (SCP)
--------------------------
|     "softAai"          |
--------------------------



s ==> softAai  // here 's' points to the String object containing "softAai"

A String object with the content “softAai” is created. s directly references this object.

In the heap area: No new objects are created because string literals (here “softAai”) are directly stored in the SCP. Therefore, there’s no need for a separate object in the heap.

Understanding Object Creation in SCP and Heap

Object creation in the SCP is optional. First, it will check if any object is present in SCP with the required content. If an object is already present, the existing object will be reused. If an existing object is not available, then a new object will be created. However, this rule is applicable only for SCP and not for the heap.

GC is not allowed to access the SCP area. Hence, even though an object doesn’t contain a reference variable, it is not eligible for GC if it is present in the SCP area. All SCP objects will be destroyed at the time of JVM shutdown.

Let’s explore the nuances of object creation in the String Constant Pool (SCP) and the heap, along with garbage collection considerations:

Consider the following examples:

Example 1

String s1 = new String("softAai");
String s2 = new String("softAai");
String s3 = "softAai";
String s4 = "softAai"

In the heap area:

s1 ==> softAai  
s2 ==> softAai

s1 and s2 refer to separate String objects with the content “softAai”.

In the SCP area:

s3, s4 ==> softAai

s3 and s4 both refer to the same String object containing “softAai”

Here Total 3 objects created (2 in heap, 1 in SCP)

Note: Whenever we use the new operator, a new object will be created in the heap area. Hence, there may be existing two objects in the heap area but not in SCP. That means duplicate objects are possible in the heap area but not in SCP.

String s1 = new String("softAai");
s1.concat("Apps");
String s2 = s1.concat("Blogs");
s1 = s1.concat("Jobs");

System.out.println(s1); // softAaiJobs
System.out.println(s2); // softAaiBlogs

In the heap area:

s1 ==> softAai  // With the new operator, a new object will be created in the heap area and one in SCP.
     ==> softAaiApps  // Due to runtime change like .concat(), a new object will be created with those new changes.
s2 ==> softAaiBlogs
s1 ==> softAaiJobs  // As reference reassignment.

• s1 initially refers to a String object with the content “softAai”.
• After s1.concat("Apps"), a new object “softAaiApps” is created due to the immutable nature of strings.
• s2 refers to a String object “softAaiBlogs” created by concatenating “softAai” with “Blogs”.
• Finally, s1 is reassigned to a new object “softAaiJobs” after concatenating “Jobs”.

In the SCP area:

==> softAai  // With the new operator, a new object will be created in the heap area and one in SCP, not holding any reference here.
==> Apps  // This is a string constant, thus created in SCP.
==> Blogs
==> Jobs

Objects “softAai”, “Apps”, “Blogs”, and “Jobs” are created due to string literals and stored in the SCP.

Total 8 objects are created (4 in heap and 4 in SCP).

Note: For every string constant, one object will be placed in the SCP area. If an object is required to be created due to some runtime operation, that object will be placed only in the heap area, not in SCP.

Understanding String Constructors

Let’s explore the various constructors available in the String class in Java:

String s = new String();

• This constructor creates an empty string object with a size of zero.
• Example: String s = "";

String s = new String(String literal);

• This constructor creates a string object in the heap for the given string literal.
• Example: String s = new String("softAai");

String s = new String(StringBuffer sb);

• This constructor creates a string object for an equivalent StringBuffer object.
• Example:

StringBuffer sb = new StringBuffer("softAai");
String s = new String(sb);