Question

我尝试了两种不同的方法来反转char数组

    //method 1
    char c[] = {'A', 'B', 'C', 'D'};
    char c_rev[] = new char[4];
    for (int i = 3; i >= 0; i--) {
        c_rev[i] = c[3 - i];
    }
    System.out.println(Arrays.toString(c_rev));

    //method 2
    char c[]  = {'A', 'B', 'C', 'D'};
    Stack<Character> st = new Stack();
    for (int i = 0; i < 4; i++) {
        st.push(c[i]);
    }
    for (int i = 0; i < 4; i++) {
        c[i] = st.pop();
    }
    System.out.println(Arrays.toString(c));

我只是想知道什么是效率最高的。方法1还是方法2？任何人都可以帮助我或提出任何建议吗？

Answer 1

就时间复杂性而言，它们都是O（n）。这里的表现并不重要。

选择哪个？没有。我会使用一个现成的方法StringBuilder#reverse：

String reversed = new StringBuilder(new String(c)).reverse().toString();

如果我想从你提出的两个方法中选择一个，我会选择第一个，它只有一个循环而且很简单，不会调用任何方法，也不会创建任何辅助对象;您只需创建一个新数组并直接将其推送到新元素。

Answer 2

@ MarounMaroun的answer将适用于真正属于字符串的char数组。如果您只担心这两种方法，那么第一种方法涉及较少的堆分配和GC。

但是一般来说，对于数组我不会使用任何方法，而是使用

int len = c.length; 
for(int i = 0; i < len / 2; i++) {
    char ch = c[i];
    c[i] = c[len - i - 1];
    c[len - i - 1] = ch;
}

是：

比方法2更短的类型
只迭代数组长度的一半（由于每次迭代操作，它仍然是O（n））
适用于任何阵列类型
不需要额外的对象分配（对比方法2）或两个数组（对比方法1）

len

Answer 3

我认为方法1可能更快，因为它不需要创建，分配和销毁新对象（即堆栈及其内部对象）。出于同样的原因，它对垃圾收集器的影响也应该较小。

如果这是您代码中的频繁操作，则可以使用Google caliper之类的方法对这两种方法进行基准测试。否则，我不担心它：）

Answer 4

与使用第三个变量的赋值运算符（交换）方法相比，逻辑运算符的工作效率更高：

 public static char[] reverseArray(char[] array) {
    for(int i=0; i<array.length/2; i++)
    {
        array[i]^=array[array.length-i-1];
        array[array.length-i-1]^=array[i];
        array[i]^=array[array.length-i-1];
    }
    return array;
}

public static void main(String[] args) {
    char[] input = {'H','e','l','l','o'};
    System.out.println(reverseArray(input));
    char[] input2 = {'J','a','v','a'};
    System.out.println(reverseArray(input2));
}

反转char数组的最有效方法是什么？

4 个答案: