Introduction

Swapping two characters in a string is a common string manipulation task in Java. Although Java strings are immutable, you can still swap characters by creating a modified copy of the original string.

This operation is useful in:

• String manipulation programs
• Interview coding questions
• Permutation algorithms
• Game development
• Encryption and encoding algorithms
• Backtracking problems
• Recursive algorithms

For example:

Input:
Hello

Swap index 0 and 4

Output:
oellH

Since strings cannot be modified directly, Java offers several approaches to accomplish this efficiently.

In this guide, you'll learn four different methods along with their advantages, disadvantages, performance characteristics, edge cases, and best practices.

Method 1: Using Character Array (Recommended)

The simplest and fastest approach is to convert the string into a character array, swap the characters, and create a new string.

public class SwapCharactersArray {

    public static String swapCharacters(String str,
                                        int pos1,
                                        int pos2) {

        if (str == null || str.isEmpty()) {
            return str;
        }

        if (pos1 < 0 || pos2 < 0 ||
            pos1 >= str.length() ||
            pos2 >= str.length()) {
            return str;
        }

        if (pos1 == pos2) {
            return str;
        }

        char[] chars = str.toCharArray();

        char temp = chars[pos1];
        chars[pos1] = chars[pos2];
        chars[pos2] = temp;

        return new String(chars);
    }

    public static void main(String[] args) {

        System.out.println(
                swapCharacters("Hello", 0, 4));

        System.out.println(
                swapCharacters("Java", 0, 3));

        System.out.println(
                swapCharacters("Programming", 2, 8));
    }
}

Output

oellH
aavJ
Progrmaming

How It Works

For "Hello":

Index:

0 1 2 3 4

H e l l o
↑       ↑

Swap

o e l l H

Advantages

• Fast
• Easy to understand
• Minimal code
• Most commonly used
• Ideal for interviews

Disadvantages

• Creates a new character array

Time Complexity

O(n)

Space Complexity

O(n)

Method 2: Using StringBuilder

StringBuilder allows characters to be modified directly using setCharAt().

public class SwapCharactersStringBuilder {

    public static String swapCharacters(String str,
                                        int pos1,
                                        int pos2) {

        if (str == null || str.isEmpty()) {
            return str;
        }

        if (pos1 == pos2) {
            return str;
        }

        StringBuilder sb = new StringBuilder(str);

        char temp = sb.charAt(pos1);

        sb.setCharAt(pos1, sb.charAt(pos2));
        sb.setCharAt(pos2, temp);

        return sb.toString();
    }

    public static void main(String[] args) {

        System.out.println(
                swapCharacters("Test", 0, 3));

        System.out.println(
                swapCharacters("Developer", 1, 6));
    }
}

Output

tesT
Deloveper

Advantages

• Clean code
• Mutable object
• Useful when performing multiple modifications

Disadvantages

• Slightly slower than character array
• Extra object creation

Time Complexity

O(n)

Space Complexity

O(n)

Method 3: Using substring()

This method rebuilds the string using substrings.

public class SwapCharactersSubstring {

    public static String swapCharacters(String str,
                                        int pos1,
                                        int pos2) {

        if (str == null ||
            pos1 == pos2) {
            return str;
        }

        if (pos1 > pos2) {

            int temp = pos1;
            pos1 = pos2;
            pos2 = temp;
        }

        return str.substring(0, pos1)
                + str.charAt(pos2)
                + str.substring(pos1 + 1, pos2)
                + str.charAt(pos1)
                + str.substring(pos2 + 1);
    }

    public static void main(String[] args) {

        System.out.println(
                swapCharacters("Programming", 0, 10));
    }
}

Output

mrogramPring

How It Works

Suppose

Programming

Swap index 0 and 10

P r o g r a m m i n g
↑                 ↑

New string becomes

mrogramPring

Advantages

• No character array
• Useful for understanding substring operations

Disadvantages

• Creates multiple temporary strings
• Less efficient
• Harder to read

Time Complexity

O(n)

Space Complexity

O(n)

Method 4: Using Streams (Java 8+)

Although not recommended for simple swapping, Streams can also be used.

import java.util.stream.IntStream;

public class SwapCharactersStream {

    public static String swap(String str,
                              int first,
                              int second) {

        char[] chars = str.toCharArray();

        char temp = chars[first];
        chars[first] = chars[second];
        chars[second] = temp;

        return IntStream.range(0, chars.length)
                .collect(StringBuilder::new,
                        (sb, i) -> sb.append(chars[i]),
                        StringBuilder::append)
                .toString();
    }

    public static void main(String[] args) {

        System.out.println(
                swap("Stream", 1, 4));
    }
}

Output

Steram

Advantages

• Modern Java style
• Functional programming

Disadvantages

• More verbose
• Slower
• Not ideal for interviews

Performance Comparison

Approximate benchmark:

Handling Edge Cases

Same Position

swapCharacters("Hello", 2, 2);

Output

Hello

Invalid Index

swapCharacters("Hello", 2, 10);

Output

Hello

(or throw an exception based on your implementation)

Empty String

swapCharacters("",0,1)

Output

""

Null String

swapCharacters(null,0,1)

Output

null

Practical Examples

Example 1: Swap First and Last Character

public static String swapFirstLast(String str) {

    if (str == null || str.length() < 2) {
        return str;
    }

    return SwapCharactersArray.swapCharacters(
            str,
            0,
            str.length() - 1);
}

Output

Java

↓

aavJ

Example 2: Reverse String Using Swaps

public static String reverse(String str) {

    char[] chars = str.toCharArray();

    int left = 0;
    int right = chars.length - 1;

    while (left < right) {

        char temp = chars[left];
        chars[left] = chars[right];
        chars[right] = temp;

        left++;
        right--;
    }

    return new String(chars);
}

Example 3: Shuffle Characters

Random random = new Random();

char[] chars = str.toCharArray();

for (int i = chars.length - 1; i > 0; i--) {

    int j = random.nextInt(i + 1);

    char temp = chars[i];
    chars[i] = chars[j];
    chars[j] = temp;
}

Used in:

• Games
• Password generation
• Randomization algorithms

Example 4: Swap Adjacent Characters

Input

abcdef

↓

badcfe

Useful for encoding algorithms.

Common Mistakes

Mistake 1: Trying to Modify String Directly

❌ Wrong

str.charAt(0) = 'A';

Strings are immutable.

✅ Correct

char[] chars = str.toCharArray();
chars[0] = 'A';

Mistake 2: Ignoring Bounds Checking

Always validate indexes before swapping.

Mistake 3: Forgetting Same Position Check

if (pos1 == pos2)
    return str;

Avoids unnecessary work.

Mistake 4: Forgetting Null Checks

if (str == null)
    return null;

Best Practices

Prefer Character Array

It is the fastest and simplest solution.

Validate Input

Always check:

• null
• empty string
• negative index
• index out of range

Use StringBuilder for Multiple Modifications

If many swaps are required, StringBuilder is a better choice.

Avoid substring() for Performance-Critical Code

It creates multiple temporary strings.

Frequently Asked Questions

Q1: What happens if both positions are the same?

Answer: The string remains unchanged because swapping the same character has no effect.

Q2: What if the indexes are outside the string length?

Answer: Either return the original string or throw an IndexOutOfBoundsException, depending on your implementation.

Q3: Which method is the fastest?

Answer: The character array approach is generally the fastest because it performs direct character swapping with minimal overhead.

Q4: Can I swap multiple pairs of characters?

Answer: Yes. Convert the string to a character array once, perform all swaps, and then create a new string.

Q5: Is the original string modified?

Answer: No. Java strings are immutable. Every method returns a new string.

Q6: How can I swap characters based on their values instead of indexes?

Answer: First find the indexes using methods like indexOf(), then perform the swap.

Q7: Does this work for very large strings?

Answer: Yes. All methods are O(n), but the character array approach remains the most efficient for large strings.

Q8: Can I swap adjacent characters?

Answer: Yes. Simply provide consecutive indexes such as (2, 3).

Q9: Do these methods work with Unicode characters?

Answer: Yes, they work correctly for most Unicode characters represented as single UTF-16 code units. Characters represented by surrogate pairs (such as some emoji) require additional care.

Q10: How do I swap words instead of characters?

Answer: Split the string into words using split(), swap the desired array elements, and join them back together using String.join().