Is it possible to swap two variables in Java? [duplicate]

Answer 1

I'm going to be reallllyyyy annoying and pedantic here because the word "value" has a very specific meaning in Java, which people often don't often understand, especially when the variables hold references to objects.

I am going to assume the question asks for this behavior:

x = initialValueForX;
y = initialValueForY;
swap(x, y);
// x now holds initialValueForY;
// y now holds initialValueForX;

This is not possible because Java passes all arguments to methods by value. You can never change the actual value stored inside of x and y this way.

You can, however, if x and y hold references to objects, change the properties of the two objects in such a way as to make the printed values look like each other's initial values:

x = initialValueForX;
y = initialValueForY;
swap(x, y);
System.out.println(x);  prints what looks like initialValueForY
System.out.println(y);  prints what looks like initialValueForX

This works if your understanding of value is what the object looks like, rather than what the identity of an object is. Usually, that is acceptable.

(Was going to give a good example here, but cHao already did. Plus others pointed out that this was a duplicate question anyway.)

Answer 2

Not with primitive types (int, long, char, etc). Java passes stuff by value, which means the variable your function gets passed is a copy of the original, and any changes you make to the copy won't affect the original.

void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    // a and b are copies of the original values.
    // The changes we made here won't be visible to the caller.
}

Now, objects are a bit different, in that the "value" of an object variable is actually a reference to an object -- and copying the reference makes it point at the exact same object.

class IntHolder { public int value = 0; }

void swap(IntHolder a, IntHolder b)
{
    // Although a and b are copies, they are copies *of a reference*.
    // That means they point at the same object as in the caller,
    // and changes made to the object will be visible in both places.
    int temp = a.value;
    a.value = b.value;
    b.value = temp;
}

Limitation being, you still can't modify the values of a or b themselves (that is, you can't point them at different objects) in any way that the caller can see. But you can swap the contents of the objects they refer to.

BTW, the above is rather hideous from an OOP perspective. It's just an example. Don't do it.