字符串倒置

说到这字符串倒置，其实还有些值得说道的，尽管不难。
C/C++有个reverse()，可以直接用，但我大Java并没有……
想到一种办法并不难，但你能想到几种有效的办法呢？
一起来看看吧！

先做一下基本的定义，后面可以统一使用：

String string = "ADFGJINJOOKC";
int length = string.length();
char[] chars0 = string.toCharArray();

Strategy_1：倒转char[]

倒转char[]其实就是新生成一个char[]，正向遍历原char[]，把char数据逆向复制到新char[]中。

char[] chars1 = new char[length];
for (int i = 0; i < length; i++) {
    chars1[i] = chars0[length-i-1];
}
System.out.println(new String(chars1));

Strategy_2：利用StringBuilder的reverse()

虽然String没有reverse()，但可以利用String对象生成StringBuilder对象，再reverse()，打印就直接调toString()了，方便简洁。

System.out.println(new StringBuilder(string).reverse());

Strategy_3：直接拼接

所谓直接拼接，其实就是new一个StringBuilder对象，倒着遍历char[]，把char一个一个append()到StringBuilder对象上。

StringBuilder reverse3 = new StringBuilder();
for (int i = length-1; i >= 0; i--) {
    reverse3.append(chars0[i]);
}
System.out.println(reverse3);

看了解法二，说实话，此法大可不必……

Strategy_4：直接倒着打印

倒着遍历，直接打印。
由于需要大量的IO，所以慢。
也就初学者会真的这么用吧……

for (int i = length-1; i >= 0; i--) {
    System.out.print(chars0[i]);
}
System.out.println();

Strategy_5：利用charAt(i)来拼接

String确实有charAt(i)，但为什么摆着现成的随机访问index不用呢？何必何必，感觉还不如方法三。

StringBuilder reverse5 = new StringBuilder();
for (int i = length-1; i >= 0; i--) {
    reverse5.append(string.charAt(i));
}
System.out.println(reverse5);

Strategy_6：使用栈来拼接

栈自然是可以的，LIFO，但单独拿出来而不利用数组的随机访问，大可不必。

何况是Java的java.util.Stack，继承自java.util.Vecter的一个类，一个被synchronized包裹的类，不必……

Stack<Character> stack = new Stack<>();
for (char c : chars0) {
    stack.push(c);
}
StringBuilder reverse6 = new StringBuilder();
while (!stack.isEmpty()) {
    reverse6.append(stack.pop());
}
System.out.println(reverse6);

Strategy_7：两侧向中间交换

这个思想就是swap()，经典的交换算法。

char[] chars7 = chars0;
for (int i = 0; i < length/2; i++) {
    char temp = chars7[i];
    chars7[i] = chars7[length-i-1];
    chars7[length-i-1] = temp;
}
System.out.println(new String(chars7));

Strategy_7の位运算优化

先写swap()：

private static void swap(char a, char b) {
    if (a != b) {
        a ^= b;
        b ^= a;
        a ^= b;
    }
}

再写具体的交换：（毕竟引用传递嘛，隐去了指针，不需使用&）

char[] chars8 = chars0;
for (int i = 0; i < length/2; i++) {
    swap(chars8[i], chars8[length-i-1]);
}
System.out.println(new String(chars8));

完整Java代码

import java.util.Stack;

public class StringReverseTest {

    private static void swap(char a, char b) {
        if (a != b) {
            a ^= b;
            b ^= a;
            a ^= b;
        }
    }

    public static void main(String[] args) {
        String string = "ADFGJINJOOKC";
        int length = string.length();
        char[] chars0 = string.toCharArray();
        //方法一：倒转char[]
        char[] chars1 = new char[length];
        for (int i = 0; i < length; i++) {
            chars1[i] = chars0[length-i-1];
        }
        System.out.println(new String(chars1));
        //方法二：利用StringBuilder的reverse()
        System.out.println(new StringBuilder(string).reverse());
        //方法三：直接拼接
        StringBuilder reverse3 = new StringBuilder();
        for (int i = length-1; i >= 0; i--) {
            reverse3.append(chars0[i]);
        }
        System.out.println(reverse3);
        //方法四：直接倒着打印
        for (int i = length-1; i >= 0; i--) {
            System.out.print(chars0[i]);
        }
        System.out.println();
        //方法五：利用charAt(i)来拼接
        StringBuilder reverse5 = new StringBuilder();
        for (int i = length-1; i >= 0; i--) {
            reverse5.append(string.charAt(i));
        }
        System.out.println(reverse5);
        //方法六：使用栈来拼接
        Stack<Character> stack = new Stack<>();
        for (char c : chars0) {
            stack.push(c);
        }
        StringBuilder reverse6 = new StringBuilder();
        while (!stack.isEmpty()) {
            reverse6.append(stack.pop());
        }
        System.out.println(reverse6);
        //方法七：两侧向中间交换
        char[] chars7 = chars0;
        for (int i = 0; i < length/2; i++) {
            char temp = chars7[i];
            chars7[i] = chars7[length-i-1];
            chars7[length-i-1] = temp;
        }
        System.out.println(new String(chars7));
        //swap()
        char[] chars8 = chars0;
        for (int i = 0; i < length/2; i++) {
            swap(chars8[i], chars8[length-i-1]);
        }
        System.out.println(new String(chars8));
    }

}

表表态

个人用着方法二，那个StringBuilder的reverse()比较顺手。

声明一个Java native方法

/**
  * @param param 待转置的字符串。
  * @return 转置后的字符串。
  */
public static native String reverseStr(String param);

生成一个native C方法声明

JNIEXPORT jstring JNICALL Java_____reverseStr(JNIEnv *, jclass, jstring);

实现native C方法

JNIEXPORT jstring JNICALL Java_____reverseStr(JNIEnv *env, jclass jc, jstring p) {
    jsize js = (*env)->GetStringLength(env, p);
    const jchar *jch = (*env)->GetStringChars(env, p, NULL);
    jsize j = 0, i = js - 1;
    jchar jch_tmp_1[js];
    for (; j < js; ++j, --i) {
        jch_tmp_1[j] = jch[i];
    }
    (*env)->ReleaseStringChars(env, p, jch);
    return (*env)->NewString(env, jch_tmp_1, js);
}

此处重点放在本地方法的实现中。

测试

System.out.println(reverseStr("!anihC uoy evol I!国中你爱我"));

2020-04-14 22:42:55.257 1106-1106/I/System.out: 我爱你中国!I love you China!