How to Swap Variables in Java

Swapping means exchanging the values of two variables: what was stored in the first ends up in the second, and vice versa. You reach for this constantly when sorting, reordering elements, or solving algorithm problems. Below are three ways to swap two variables in Java, plus a separate look at why a swap method for ordinary variables does not behave the way beginners expect.

Swap using a temporary variable

The simplest and most reliable approach. Introduce a temporary variable tmp that holds the value from the first variable while we overwrite it with the value from the second:

int tmp = a;
a = b;
b = tmp;

Full example:

public class SwapExample1 {
    public static void main(String[] args) {
        int a = 3;
        int b = 5;

        int tmp = a;
        a = b;
        b = tmp;

        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

Output:

a = 5
b = 3

This version works with any type — int, double, String, object references — and has no hidden traps. It is the one you should reach for by default.

Swap without a temporary variable (arithmetic)

Sometimes you are asked to swap values without a third variable. One option is addition and subtraction:

a = a + b;
b = a - b;
a = a - b;

Full example with a step-by-step breakdown in the comments:

public class SwapExample2 {
    public static void main(String[] args) {
        int a = 3;
        int b = 5;

        a = a + b; // a = 8, b = 5
        b = a - b; // a = 8, b = 3
        a = a - b; // a = 5, b = 3

        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

Swap using XOR

Another no-temp trick is the bitwise exclusive OR (^). It works only for integer types, but it has no overflow problem:

a = a ^ b;
b = a ^ b;
a = a ^ b;

Full example:

public class SwapExample3 {
    public static void main(String[] args) {
        int a = 3;
        int b = 5;

        a = a ^ b;
        b = a ^ b;
        a = a ^ b;

        System.out.println("a = " + a); // a = 5
        System.out.println("b = " + b); // b = 3
    }
}

It works thanks to two properties of XOR: x ^ x == 0 and x ^ 0 == x. One gotcha: if you accidentally apply this swap to the same variable (for example arr[i] and arr[j] when i == j), it zeroes the value out. XOR swapping looks clever in an interview, but in ordinary code it loses to the temporary variable on readability.

Why a swap() method does not change the variables

It is tempting to move the swap into a reusable swap method. But with primitives that will not work — Java always passes arguments by value: the method receives copies, not the variables themselves.

public class SwapMethod {

    // Does NOT work: x and y are copies, the originals a and b stay unchanged
    static void swap(int x, int y) {
        int tmp = x;
        x = y;
        y = tmp;
    }

    public static void main(String[] args) {
        int a = 3;
        int b = 5;
        swap(a, b);
        System.out.println("a = " + a); // a = 3
        System.out.println("b = " + b); // b = 5 - nothing was swapped
    }
}

This is one of the most common interview traps. A universal swap(int, int) method for two local variables is simply impossible in Java. The workaround is to pass not the values themselves but a container whose contents you can modify from inside: an array, a list, or a wrapper object.

Swapping array and list elements

When the values live in an array, a swap method works perfectly: the method gets a copy of the reference, but it still points to the same array object, so element changes are visible to the caller.

static void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

For collections, the standard library already ships Collections.swap, which exchanges two list elements by their indices:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SwapList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("A", "B", "C"));
        Collections.swap(list, 0, 2);
        System.out.println(list); // [C, B, A]
    }
}

Which one to use in practice

The takeaway is simple: in real code, almost always use the temporary-variable swap — it is clear, works with any type, and has no hidden limits. The arithmetic and XOR tricks are worth knowing for interviews, but in production they only make the code harder to read. And when you need to swap values "in the caller", remember pass-by-value: work through an array, a list, or a wrapper object.