Object value doesn't change

Question

class smth{
    public static void main(String[] args){
        private Integer x = new Integer(17);
        inc(x);
        System.out.print("x="+x);
    }
    public static void inc(Integer x){
        x++;
        System.out.println("n="+x);
    }
}

output: n=18; x=17;

Integer is an object and I don't understand why the value of x did not change in this case.

here's a similar question: http://stackoverflow.com/questions/2208943/how-to-increment-a-class-integer-references-value-in-java-from-another-method Regards — Bautista, Nov 30 '12 at 21:15
Remove `private` before `Integer x = ...` because it doesn't compile. — Michaël, Nov 30 '12 at 21:17

score 3 · Accepted Answer · answered Nov 30 '12 at 21:15

Cause Integer is immutable object. When you send it to method, new reference to it is created. When you do increment, reference inside method is reassigned to new Integer with value 18 but reference inside main is still referencing to old Integer with value 17.

score 1 · Answer 2 · answered Nov 30 '12 at 21:14

1

Integer is immutable. The x++ creates a new object, and rebinds x to refer to it. The change does not propagate back to the caller since the reference to the original x was passed by value.

answered Nov 30 '12 at 21:14

NPE

486,780
108
951
1,012

amphibient · Answer 3 · 2012-11-30T21:22:07.180

1

It is because Java passes objects to methods by value and not by reference. Upon completing the method call, the object value will be the same in the calling method as it was before passing it. Within the called method, the value can change but the scope of the change is the method to which it was passed.

edited Nov 30 '12 at 21:22

answered Nov 30 '12 at 21:14

amphibient

29,770
54
146
240

Sergey Kalinichenko · Answer 4 · 2012-11-30T21:22:34.530

This is because Integer, a wrapper over the primitive int, is immutable, and Java passed object references by value. Any change made to the object reference inside the method has no effect on the object passed in: the reference is replaced with a reference to a new object, yet the original remains intact because it is immutable.

To address this issue, you need another level of indirection - you can use an array, a mutable int from apache commons, or roll your own suitably designed class.

public static void main(String argv[])
    MutableInt x = new MutableInt (17);
    inc(x);
    System.out.print("x="+x.intValue());  
}
public static void inc(MutableInt x){
    x.add(1);
    System.out.println("n="+x.intValue());
}

score 1 · Answer 5 · answered Nov 30 '12 at 21:16

1

Any wrapper classes are immutable class.

answered Nov 30 '12 at 21:16

bhuang3

3,493
2
17
17

dreamcrash · Answer 6 · 2019-02-03T15:05:42.463

It is because the object modifying inside the method incis not the same as the one printed outside this method.

Inside the method inc x is a reference which points to an object. When you run x ++, that reassigns X to reference a new Integer object, with a different value. Thus, you are not modifying your original 'x' variable declared on the main.

You have to return the "pointer" to the new integer object:

public static int inc(Integer x){
          x++;
          System.out.println("n="+x);
          return x;
      }

  public static void main(String argv[])

              Integer x = new Integer(17);
              x = inc(x);
              System.out.print("x="+x);  
  }

An Integer, is a Object that contains a single int field. An Integer is much bulkier than an int. It is sort like a Fedex box to contain the int. Integers are immutable (source)

score 1 · Answer 7 · answered Nov 30 '12 at 21:19

1

Because x++, on an Integer object, actually means:

int temp = x.intValue();
temp++;
x = Integer.valueOf(temp);

The x variable is being assigned a new Integer instance. And since parameters are passed by value, the original reference stays unmodified.

answered Nov 30 '12 at 21:19

JB Nizet

678,734
91
1,224
1,255

Object value doesn't change

7 Answers7