不使用StringBuffer.reverse（）的反向字符串

Question

以下示例有什么问题？ 如果字符串中的数百万个字符反转，会发生什么？

public static String reverseUsingStringBuffer(String source) {
    if(source == null || source.isEmpty()){
        return source;
    }       
    StringBuffer reverse = new StringBuffer();

    for(int i = source.length() -1; i>=0; i--){
        reverse.append(source.charAt(i));
    }

    return reverse.toString();
}

是否遵循更好的方法？ （除了使用api方法）。 巨大的String有什么好的方法？

public static String reverse(String source) {
    if(source == null || source.isEmpty()){
        return source;
    }       
    String reverse = "";
    for(int i = source.length() -1; i>=0; i--){
        reverse = reverse + source.charAt(i);
    }

    return reverse;
}

Answer 1

如前所述， String方法非常糟糕。 使用StringBuffer会更好，但是当StringBuilder可以更快地完成同样的过时的类时，则没有理由。

在这种情况下，更简单，更快的方法是使用数组：

char[] result = new char[source.length];
for(int i = 0; i < source.length(); ++i) result[source.length() - 1 - i] = source.charAt(i);
return new String(result);

除了char[]之外，它根本不分配任何垃圾。...但这是不可避免的，因为String是不可变的，并且共享构造函数是程序包私有的（有充分的理由）。

请注意，通常绝对不需要对此进行优化。

Answer 2

不，第一种方法更好，因为它将在内部为您管理缓冲区。 不要试图超越编译器。 为什么不将整个源代码附加在一行中，这将正确分配缓冲区。

Answer 3

第一个。 在第二个中，您使用“字符串=字符串+字符串”，并且每次使用“ +”都会创建一个对象。 我建议使用StringBuffer。

Answer 4

第一种方法更好，StringBuffer是可变的，并且使用string = string + string会降低性能。

Answer 5

您也可以使其就位。

public static String reverse(String s) {
   char[] chars = s.toCharArray();
   for(int i = 0, j = chars.length - 1; i < chars.length / 2; i++, j--) {
     char c = chars[i];
     chars[i] = chars[j];
     chars[j] = c;
   }
   return new String(chars);
}