Java字符串反转

    //字符串反转
    //思路：将字符串转换为字符数组，再把字符数组转换为包装类数组，再把包装类数组转换为集合，利用集合方法反转字符串，再转为数组
    public String reverse(String s){
        char[] chars = s.toCharArray();
        Character[] characters = new Character[s.length()];
        for (int i = 0; i < chars.length; i++) {
            characters[i] = chars[i];
        }
        List<Character> characterList = Arrays.asList(characters);
        Collections.reverse(characterList);
        characters = (Character[])characterList.toArray();
        for (int i = 0; i < characters.length; i++) {
            chars[i] = characters[i];
        }
        return new String(chars);
    }

    //字符串反转2
    //将字符串转换为字符数组，将字符数组从后向前遍历，并放入到一个新的字符数组中，然后将字符数组转换为字符串返回
    public String reverse2(String s ){
        char[] chars = s.toCharArray();
        char[] newChars = new char[s.length()];
        for(int i = chars.length-1,j=0;i>=0;i--,j++){
            newChars[j] = chars[i];
        }
        return new String(newChars);
    }


    //优化
    public String reverse3(String s){
        char[] chars = s.toCharArray();
        char[] newChars = new char[s.length()];
        for (int i = chars.length-1; i >= 0; i--) {
            newChars[chars.length-i-1] = chars[i];
        }
        return new String(newChars);
    }

    //优化
    public String reverse4(String s){
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length / 2 ; i++) {
            //利用两个数交换，在原本字符数组上修改
            char temp = chars[i];
            chars[i] = chars[chars.length-i-1];
            chars[chars.length-i-1] = temp;
        }
        return new String(chars);
    }

    //优化
    public String reverse5(String s){
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length / 2 ; i++) {
            //利用两个数交换，在原本字符数组上修改
            //int a=3,b=4;
            //a=a+b;
            //b=a-b;
            //a=a-b;
            //不需要创建第三个变量，但是相加可能会超过char的最大范围65535，再进行强转时会出现丢失字节的情况，如下：
            //char超出范围
            //char c8 = (char) (65536+97);
            //System.out.println(c8);//a
            chars[i] = (char) (chars[i] + chars[chars.length-i-1]);
            chars[chars.length-i-1] = (char) (chars[i] - chars[chars.length-i-1]);
            chars[i] = (char) (chars[i] - chars[chars.length-i-1]);
        }
        return new String(chars);
    }



    //优化
    public String reverse6(String s){
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length / 2 ; i++) {
            //利用两个数交换，在原本字符数组上修改
            //int a=3,b=4;
            //a = a ^ b;
            //b = a ^ b;
            //a = a ^ b;
            //不需要创建第三个变量，但是异或可能会超过char的最大范围65535，再进行强转时会出现丢失字节的情况,如下
            //char超出范围
            //char c8 = (char) (65536^97);
            //System.out.println(c8);//a
            chars[i] = (char) (chars[i] ^ chars[chars.length-i-1]);
            chars[chars.length-i-1] = (char) (chars[i] ^ chars[chars.length-i-1]);
            chars[i] = (char) (chars[i] ^ chars[chars.length-i-1]);
        }
        return new String(chars);
    }
public String reverse7(String s){
        return new String(new StringBuilder(s).reverse());
    }

综合上述所有方法，关注reverse4方法和reverse7方法