如何在Java中交换字符串？

如何交换

字符串中的两个字符？例如，
“abcde”
将变成
“bacde”
字符串。replaceAll（）或replaceFirst（）

链接到JavaDocs的字符串，你不能。字符串是不可变的。您可以使用以下命令轻松创建第二个字符串：

 String second = first.replaceFirst("(.)(.)", "$2$1");

由于
String
对象是不可变的，因此通过构造函数转到
char[]
中，交换字符，然后从
char[]
中创建一个新的
String
是可行的

以下示例交换第一个和第二个字符：

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);

结果:

abcde
bacde

将为您提供表示此字符串的字符数组

您可以在不更改原始字符串的情况下对此进行更改（交换所需的任何字符），然后使用创建新字符串

请注意，字符串是不可变的，因此您必须创建一个新的字符串对象。
这已经回答了好几次了，但这里还有一个只是为了好玩：-）

下面是递归交换java字符的java示例代码。。您可以在以下位置获得完整的示例代码：

import java.io.*；
阶级交换
{
公共静态void main（字符串参数[]）
{
String name=“premkumarg”；
int len=name.length（）；
char[]c=name.toCharArray（）；
对于（int i=0；i
静态字符串交换（字符串str，int x，int y）
{
如果（x<0 | | x>=str.length（）| | y<0 | | y>=str.length（））
返回“无效索引”；
char arr[]=str.toCharArray（）；
char tmp=arr[x]；
arr[x]=arr[y]；
arr[y]=tmp；
返回新字符串（arr）；
}
这里有一个使用
StringBuilder
的解决方案。它支持使用填充字符填充字符串长度不均匀的结果字符串。正如您所猜测的，此方法适用于十六进制半字节交换

/**
 * 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();
}

/**
*将位置i处的每个字符与给定区域中位置i+1处的字符交换
*绳子。
*/
公共静态字符串交换字符（最终字符串值、最终布尔填充）
{
如果（值==null）
{
返回null；
}
最终StringBuilder StringBuilder=新StringBuilder（）；
int-posA=0；
int-posB=1；
最终字符padChar='F'；
//交换字符
while（posA
公共静态字符串洗牌（字符串s）{
列表字母=数组.asList（s.split（“”）；
收藏。洗牌（字母）；
StringBuilder t=新的StringBuilder（s.length（））；
for（字符串k：字母）{
t、 附加（k）；
}
返回t.toString（）；
}
我认为这应该会有所帮助

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)));
  }
}

以下代码行将交换
str
中的前两个字符：

return str.charAt(1) + str.charAt(0) + str.substring(2);

//这是一种非常基本的按字母顺序排列字符串的方法，它不需要任何花哨的东西，非常适合学校使用
包装线分拣机；
公共类字符串分拣机{
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
String word=“jihgfedcba”；
对于（int endOfString=word.length（）；endOfString>0；endOfString--）{
int largestWord=word.charAt（0）；
int位置=0；
for（int index=0；index最大单词）{
最大单词=单词字符（索引）；
位置=索引；
}
}
如果（位置
我喜欢正则表达式的外观。很好。我不知道为什么我直接去StringBuilder而不是考虑字符数组。@Jon Skeet：我的第一个想法实际上是构建一个新字符串，但由于要求是交换，所以我认为字符数组会更容易。：）只需添加，String类使用字符[]在内部保留其字符串数据。这可以从浏览OpenJDK的源代码中看到。因此它可能是老式的，但字符串类本身使用数组。非常好！我喜欢您在没有
StringBuilder
的情况下这样做。这假设您提前知道要交换的字符，这看起来不像usab大多数情况下，这是一个简单的解决方案。请添加一些解释，而不仅仅是一行代码？这会产生一个完全错误的结果。提示：在Java中，与几乎所有编程语言一样，具有相同优先级的计算运算符都保持关联性。//您可以这样做……提示：如果字符串长度大于2，则代码可以工作>>>>包到.pkgtry；导入java.util.Scanner；公共类ToTry{public static String swap（String str）{String ret=”“+str.charAt（1）+str.charAt（0）+str.substring（2）；返回ret；}public static void main（String[]args）{String s=swap（“abcg”）；System.out.println（s）；}}请记住，您必须返回一个新字符串，因为java字符串是不可变的。请在响应时添加一些文本解释。只有代码响应可能不是很清楚
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);

    }
}

StringBuilder sb = new StringBuilder("abcde");
sb.setCharAt(0, 'b');
sb.setCharAt(1, 'a');
String newString = 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);
}

/**
 * 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();
}

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);

s = s.substring(0, firstChar)
            +s.charAt(secondChar)
            +s.substring(firstChar + 1, secondChar)
            +s.charAt(firstChar)
            +s.substring(secondChar+1);