如何在 Java 中交换字符串的第一个和最后一个字符？

Question

我整个夏天都在练习，试图变得更好，但我有点坚持以下几点：

http://www.javabat.com/prob/p123384

给定一个字符串，返回一个新字符串，其中第一个和最后一个字符已交换。

---

例子：

frontBack("code") → "eodc"
frontBack("a") → "a"
frontBack("ab") → "ba"

---

代码：

public String frontBack(String str) 
{
    String aString = "";
    
    if (str.length() == 0){
        return "";
    }
    
    char beginning = str.charAt(0);
    char end = str.charAt(str.length() - 1);
    
    str.replace(beginning, end);
    str.replace(end, beginning);
    
    return str;
}

Answer 1

字符串可以拆分为一个字符数组，并且可以用一个字符数组组成。 有关 String 对象的更多详细信息，请转到Java API并单击左下窗格中的 String。 该窗格按字母顺序排序。

编辑：由于有些人更彻底，我想我会提供更多细节。 使用 String 的 .toCharArray() 方法创建一个 char 数组。 取出第一个元素并将其存储在 char 中，将第一个元素与最后一个元素交换，然后将存储在 char 中的元素放入数组的最后一个元素中，然后说：

String temp = new String(charArray);

并返回。 这是假设 charArray 是您的字符数组。

Answer 2

我建议不要使用String.replace方法，而是使用String.substring方法来获取不包括第一个和最后一个字母的字符，然后连接beginning和end字符。

此外， String.replace方法将替换所有出现的指定字符，并返回具有所述替换的新String 。 由于在上面的代码中没有提取返回值，因此String.replace调用在这里实际上并没有做太多的事情。

这是因为 Java 中的String是不可变的，因此replace方法不能对原始String进行任何更改，在这种情况下是str变量。

---

还要补充一点，这种方法不适用于长度为 1 的String 。使用上面的方法，使用长度为 1 的源String调用String.substring将导致StringIndexOutOfBoundsException ，所以这也会如果采用上述方法，则必须作为特殊情况处理。

坦率地说， indyK1ng 的回答中提出的方法，其中char[]是从String获得的，并执行开始和结束字符的简单交换，然后从修改后的char[]制作String开始听起来更愉快。

Answer 3

Java 中的String实例是不可变的。 这意味着您不能更改String中的字符； 不同的字符序列需要一个新对象。 因此，当您使用replace方法时，请丢弃原始字符串，并改用该方法的结果。

但是，对于此方法，您可能希望将String实例转换为可变的字符数组 ( char[] )。 交换所需字符后，使用该数组创建一个新的String实例。

Answer 4

一些提示：

• 字符串是不可变的，这意味着它们无法更改。 因此， str.replace()不会更改str ，而是返回一个新字符串。

• 也许replace不是最好的......考虑frontBack("abcabc") ：你的函数，如果它被纠正，将用'c'替换'a' ' 产生"cbccbc" ，然后'c'用'a'产生"abaaba" 。 这不太对！

Answer 5

String中的replace方法实际上返回一个String ，所以如果你坚持使用replace ，你会这样做：

beginReplace = str.replace( beginning, end );
endReplace = beginReplace.replace( end, beginning );
return( str );

但这实际上并不能解决您的具体问题，因为replace会将字符串中所有出现的字符替换为其替换。

例如，如果我的字符串是“apple”并且我说的是“apple”.replace('p', 'q')，那么结果字符串将是“aqqle”。

Answer 6

另一个 没有创建额外对象 的例子：

if (str.length() > 1) {
    char[] chars = str.toCharArray();
    // replace with swap()
    char first = chars[0];
    chars[0] = chars[chars.length - 1];
    chars[chars.length - 1] = first;
    str = new String(chars);
}

return str;

编辑：在长度 = 1 字符串上执行交换是无操作的。

编辑 2： dfa 对 copyValueOf 的更改没有任何意义，正如 Java 源代码在 String.java 中所说：“// 所有公共字符串构造函数现在都复制数据。” 并且调用只是委托给一个字符串构造函数。

Answer 7

你可以使用正则表达式..

return str.replaceFirst("(.)(.*)(.)", "$3$2$1");

Answer 8

只是另一种略有不同的方法，因此您可以了解各种可能性。 我建议您注意短字符串的快速退出（而不是将更复杂的处理嵌套在 if() 子句中），以及 String.format() 的使用，因为它是您工具箱中的一种方便的技术，不是因为在这个特定示例中它明显优于常规的“+”连接。

public static String exchange(String s) {
    int n = s.length();
    if (n < 2)
        return s;
    return String.format("%s%s%s", s.charAt(n - 1), s.substring(1, n - 1), s.charAt(0));
}

Answer 9

简单的解决方案是：

public String frontBack(String str) {
  if (str == null || str.length() == 0) {
    return str;
  }
  char[] cs = str.toCharArray();
  char first = cs[0];
  cs[0] = cs[cs.length -1];
  cs[cs.length -1] = first;
  return new String(cs);
}

使用字符数组（注意讨厌的空字符串或空字符串参数！）

---

另一种解决方案使用 StringBuilder （通常用于进行字符串操作，因为字符串本身是不可变的。

public String frontBack(String str) {
  if (str == null || str.length() == 0) {
    return str;
  }
  StringBuilder sb = new StringBuilder(str);  
  char first = sb.charAt(0);
  sb.setCharAt(0, sb.charAt(sb.length()-1));
  sb.setCharAt(sb.length()-1, first);
  return sb.toString();
}

---

另一种方法（更多用于指导而不是实际使用）是这种方法：

public String frontBack(String str) {
  if (str == null || str.length() < 2) {
    return str;
  }
  StringBuilder sb = new StringBuilder(str);
  String sub = sb.substring(1, sb.length() -1);
  return sb.reverse().replace(1, sb.length() -1, sub).toString();
}

这里将完整的字符串反转，然后将不应该反转的部分替换为子字符串。 ;)

Answer 10

public String frontBack(String input)
{
    return
        input.substring(input.length() - 1) +  // The last character
        input.substring(1, input.length() - 1) +  // plus the middle part
        input.substring(0, 1);                  // plus the first character.
}

Answer 11

您可以使用表示“可变字符序列”的 StringBuilder。
它具有解决问题所需的所有方法：charAt、setCharAt、length 和 toString。

Answer 12

if (s.length < 2) {
   return s;
}
return s.subString(s.length - 1) + s.subString(1, s.length - 2) + s.subString(0, 1);

（未经测试，索引可能是一个...

Answer 13

public String lastChars(String a, String b) {

  if(a.length()>=1&&b.length()>=1){
   String str = a.substring(0,1);
    String str1 =b.substring(b.length()-1);
    return str+str1;
}
else if(a.length()==0&&b.length()==0){
 String v ="@";
String z ="@";
return v+z;
   }
   else if(a.length()==0&&b.length()>=1){

   String s ="@";
   String s1 = b.substring(b.length()-1);
   return s+s1;
   }
   else if(a.length()>=1&&b.length()==0){
   String f= a.substring(0,1);
   String h = "@";
   return f+h;
   }
   return a;
   }

Answer 14

您可以使用以下代码：

public String frontBack(String str) {
    if (str.length() <= 1) 
        return str;

    String mid = str.substring(1, str.length()-1);

    // last + mid + first
    return str.charAt(str.length()-1) + mid + str.charAt(0);
}

Answer 15

class swap 
{
public static void main(String[] args) 
{
    Scanner s=new Scanner(System.in);
    System.out.println("no of elements in array");
    int n=s.nextInt();
    int a[]=new int[n];
    System.out.println("Elements");
    for(int i=0;i<n;i++)
    {
        a[i]=s.nextInt();
    }
    int b[]=new int[n];
    for(int i=0;i<n;i++)
    {
        b[i]=a[i];
    }
    int end=n-1;
    b[0]=b[end];
    b[end]=a[0];
    for(int i=0;i<n;i++)
    {
        System.out.println(b[i]);
    }   
}
}

Answer 16

if (str.length() <= 1) {
  return str;
}

String mid = str.substring(1, str.length()-1);
return str.charAt(str.length()-1) + mid + str.charAt(0);

Answer 17

def front_back(str): if len(str)==1: return str else: str1=str[len(str)-1] str2=str[1:len(str)-1] str3=str[0] str4 =str1 +str2+str3 返回 str4

显示字符串索引超出范围

Answer 18

    function frontBack(str: string) { 


         return str.slice(str.length - 1) + str.slice(1, -1) + str.slice(0, 1) 

    }

Slice 将“切掉”最后一个字母。 计算字符串的长度str.length -1 ，（加）从索引 1 开始并且是在索引 -1 处表示的最后一个字符的提示切片字符串，（加）切片从索引 0 到的最后一个字母索引 1。