Comment échanger des caractères de chaîne de caractères en Java?

Depuis String les objets sont immuables, allant à un char[] par toCharArray, en changeant les caractères, puis en faisant un nouveau Stringchar[] via le String(char[]) le constructeur fonctionnerait.

l'exemple suivant échange les premier et deuxième caractères:

String originalString = "abcde";

char[] c = originalString.toCharArray();

// Replace with a "swap" function, if desired:
char temp = c[0];
c[0] = c[1];
c[1] = temp;

String swappedString = new String(c);

System.out.println(originalString);
System.out.println(swappedString);

Résultat:

abcde
bacde

"Dans" une chaîne de caractères, vous ne pouvez pas. Les cordes sont immuables. Vous pouvez facilement créer une deuxième chaîne avec:

 String second = first.replaceFirst("(.)(.)", "");

ceci a été répondu quelques fois mais en voici un autre juste pour le plaisir : -)

public class Tmp {
    public static void main(String[] args) {
        System.out.println(swapChars("abcde", 0, 1));
    }
    private static String swapChars(String str, int lIdx, int rIdx) {
        StringBuilder sb = new StringBuilder(str);
        char l = sb.charAt(lIdx), r = sb.charAt(rIdx);
        sb.setCharAt(lIdx, r);
        sb.setCharAt(rIdx, l);
        return sb.toString();
    }
}

static String  string_swap(String str, int x, int y)
{

    if( x < 0 || x >= str.length() || y < 0 || y >= str.length())
    return "Invalid index";

    char arr[] = str.toCharArray();
    char tmp = arr[x];
    arr[x] = arr[y];
    arr[y] = tmp;

    return new String(arr);
}

Chaîne de caractères.toCharArray () vous donnera un tableau de caractères représentant de cette chaîne.

vous pouvez modifier ceci sans changer la chaîne de caractères d'origine (changer tous les caractères dont vous avez besoin), puis créer une nouvelle chaîne de caractères en utilisant String (char []).

Notez que les chaînes sont immuable, vous devez donc créer un nouvel objet string.

StringBuilder sb = new StringBuilder("abcde");
    sb.setCharAt(0, 'b');
    sb.setCharAt(1, 'a');
    String newString = sb.toString();

Chaîne de caractères.replaceAll() ou replaceFirst()

String s = "abcde".replaceAll("ab", "ba")

Lien vers la documentation Javadoc API String

voici un exemple de code java pour échanger des caractères java de façon récursive.. Vous pouvez obtenir le code d'échantillon complet à http://java2novice.com/java-interview-programs/string-reverse-recursive/

public String reverseString(String str){

    if(str.length() == 1){
        return str;
    } else {
        reverse += str.charAt(str.length()-1)
                +reverseString(str.substring(0,str.length()-1));
        return reverse;
    }
}

import java.io.*;
class swaping
{
     public static void main(String args[]) 
     {
         String name="premkumarg";
         int len=name.length();
         char[] c = name.toCharArray();
         for(int i=0;i<len-1;i=i+2)
         {
             char temp= c[i];
             c[i]=c[i+1];
             c[i+1]=temp;
         }

         System.out.println("Swapping string is: ");
         System.out.println(c);

    }
}

Voici une solution avec un StringBuilder. Il supporte le rembourrage des cordes résultantes avec une longueur de corde inégale avec un caractère de rembourrage. Comme vous l'avez deviné, cette méthode est faite pour hexadécimal-grignoter-échange.

/**
 * Swaps every character at position i with the character at position i + 1 in the given
 * string.
 */
public static String swapCharacters(final String value, final boolean padding)
{
   if ( value == null )
   {
      return null;
   }

   final StringBuilder stringBuilder = new StringBuilder();
   int posA = 0;
   int posB = 1;
   final char padChar = 'F';

   // swap characters
   while ( posA < value.length() && posB < value.length() )
   {
      stringBuilder.append( value.charAt( posB ) ).append( value.charAt( posA ) );
      posA += 2;
      posB += 2;
   }

   // if resulting string is still smaller than original string we missed the last
   // character
   if ( stringBuilder.length() < value.length() )
   {
      stringBuilder.append( value.charAt( posA ) );
   }

   // add the padding character for uneven strings
   if ( padding && value.length() % 2 != 0 )
   {
      stringBuilder.append( padChar );
   }

   return stringBuilder.toString();
}

public static String shuffle(String s) {
    List<String> letters = Arrays.asList(s.split(""));
    Collections.shuffle(letters);
    StringBuilder t = new StringBuilder(s.length());
    for (String k : letters) {
        t.append(k);
    }
    return t.toString();
}

je pense que cela devrait aider.

import java.util.*;

public class StringSwap{

public static void main(String ar[]){
    Scanner in = new Scanner(System.in);
    String s = in.next();
    System.out.println(new StringBuffer(s.substring(0,2)).reverse().toString().concat(s.substring(2)));
  }
}

return str.charAt (1) + str.charAt (0) + str.substring (2); / / va permuter les deux premiers caractères dans string