Why is this not throwing a NullPointerException?

Nead clarification for following code:

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
referToSample.append("B");
System.out.println(sample);

This will print B so that proves sample and referToSample objects refer to the same memory reference.

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
sample.append("A");
referToSample.append("B");
System.out.println(referToSample);

This will print AB that also proves the same.

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
referToSample = null;
referToSample.append("A");
System.out.println(sample);

Obviously this will throw NullPointerException because I am trying to call append on a null reference.

StringBuilder sample = new StringBuilder();
StringBuilder referToSample = sample;
referToSample = null;
sample.append("A");
System.out.println(sample);

So Here is my question, why is the last code sample not throwing NullPointerException because what I see and understand from first two examples is if two objects referring to same object then if we change any value then it will also reflect to other because both are pointing to same memory reference. So why is that rule not applying here? If I assign null to referToSample then sample should also be null and it should throw a NullPointerException but it is not throwing one, why?

null assignments do not change value by globally destroying that object. That kind of behavior would lead to hard-to-track bugs and counterintuitive behavior. They only break that specific reference.

For simplicity, let's say that sample points to address 12345. This is probably not the address, and is only used to make things simple here. The address is typically represented with the weird hexadecimal given in Object#hashCode(), but this is implementation-dependent.¹

StringBuilder sample = new StringBuilder(); //sample refers to 
//StringBuilder at 12345 

StringBuilder referToSample = sample; //referToSample refers to 
//the same StringBuilder at 12345 
//SEE DIAGRAM 1

referToSample = null; //referToSample NOW refers to 00000, 
//so accessing it will throw a NPE. 
//The other reference is not affected.
//SEE DIAGRAM 2

sample.append("A"); //sample STILL refers to the same StringBuilder at 12345 
System.out.println(sample);

From the lines marked See diagram the diagrams of the objects at that time are as follows:

Diagram 1:

[StringBuilder sample]    -----------------> [java.lang.StringBuilder@00012345]
                                                      ↑
[StringBuilder referToSample] ------------------------/

Diagram 2:

[StringBuilder sample]    -----------------> [java.lang.StringBuilder@00012345]
                                                      
[StringBuilder referToSample] ---->> [null pointer]

Diagram 2 shows that annulling referToSample does not break the reference of sample to the StringBuilder at 00012345.

_{¹GC considerations make this implausible.}

Initially it was as you said referToSample was referring to sample as shown below:

1. Scenario1:

2. Scenario1 (cont.):

• Here as referToSample was referring to sample, so it appended "B" while you write

  referToSample.append("B")

Same thing happend in Scenario2 :

But, in 3. Scenario3 : as hexafraction said,

when you assign null to referToSample when it was referring sample it did not change value instead it just breaks the reference from sample, and now it points nowhere. as shown below:

Now, as referToSample points nowhere, so while you referToSample.append("A"); it would not be have any values or reference where it can append A. So, it would throw NullPointerException.

BUT sample is still the same as you had initialized it with

StringBuilder sample = new StringBuilder(); so it has been initalized, so now it can append A, and will not throw NullPointerException

In a nutshell: You assign null to a reference variable, not to an object.

In one example you change the state of an object that is referred to by two reference variables. When this occurs, both reference variables will reflect the change.

In another example, you change the reference assigned to one variable, but this has no effect on the object itself, and so the second variable, which still refers to the original object, will not notice any change in object state.

---

So as to your specific "rules": > if two objects referring to same object then if we change any value then it will also reflect to other because both are pointing to same memory reference.

Again, you refer to changing the state of the one object that both variables refer to.

> So why is that rule not applying here? If I assign null to referToSample then sample should also be null and it should throw nullPointerException but it is not throwing, why?

Again, you change the reference of one variable which has absolutely no effect on the reference of the other variable.

These are two completely different actions and will result in two completely different results.

See this simple diagram:

When you call a method on referToSample, then [your object] is updated, so it affects sample too. But when you say referToSample = null, then you're simply changing what referToSample refers to.

Here 'sample' and 'referToSample' are referencing the same object.That is the concept of different pointer accessing same memory location. So assigning one reference variable to null does not destroy the object.

   referToSample = null;

means 'referToSample' only pointing to null , object remains same and other reference variable are working fine. So for 'sample' which does not pointing to null and have a valid object

   sample.append("A");

works fine. But if we try to append null to 'referToSample', it will show NullPointException. That is,

   referToSample .append("A");-------> NullPointerException

That is why you got NullPointerException in your third code snippet.

Whenever a new keyword is used it Creates a Object at the Heap

1)StringBuilder sample = new StringBuilder();

2)StringBuilder referToSample = sample;

In 2) the Reference of referSample is created on same object sample

thus referToSample = null; is Nulling Only the referSample Reference giving no effect to sample that's why you are not getting NULL Pointer Exception Thanks to Java's Garbage Collection

Just easy, Java don't have pass by reference, It just pass object reference.