java 字符串问题

1.判断两个字符串包含的字符是不是一样，顺序无关。例如，abcd和dcba就相同，但是abcd和abce是不相同的。
解决思路：如果两个字符串的length不一样，直接返回false；接着把两个字符串转为字符数组，并做快排。排序后就简单了，遍历两个数组，只要下标一样，字符不一样就立即返回false，
代码：

package basic.orderBy;

import java.util.Scanner;

/**
 * author tanbin
 * 判断两个字符串里面的字符的是不是一样，不管顺序。只要字符的种类一样，同样字符的数量一样。
 * Created by Administrator on 2016/12/6.
 */
public class EssenseString {
    public static void quicksort(char[] a,int x,int y){
        if(x>=y){
            return;
        }
        int mid = a[x];
        int i = x;
        int j = y;
        while(i<j){
            while(i!=j && a[j]>=mid)
                j--;
            while(i!=j && a[i]<=mid)
                i++;
            char temp;
            if(i==j){
                temp = a[x];
                a[x] = a[i];
                a[i] = temp;
            }else{
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        quicksort(a,x,i);
        quicksort(a,i+1,y);
    }
    public static boolean compare(String s1,String s2){
        if(s1.length()!=s2.length()){
            return false;
        }
        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();

        quicksort(c1,0,c1.length-1);
        quicksort(c2,0,c2.length-1);

        for(int i=0;i<c1.length;i++){
           if(c1[i] != c2[i])
            return false;
        }

        return true;
    }
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String s1,s2;
        s1 = scanner.nextLine();
        s2 = scanner.nextLine();
        if(compare(s1, s2)){
            System.out.println("相同");
        }else{
            System.out.println("不相同");
        }

    }
}

2.反转字符串，这个问题很直接了，就是将字符串顺序倒过来。
解决思路：思路1，这里用到了递归的思想。和反转二叉树的思路一样（二叉树是最能体现递归的数据结构），递归的方法是先把根的左右子树的位置调换了，再递归的把左右子树的根传给递归函数。字符的做法是，把字符串分为两半，把这两半位子调换，再对这两半字符串做同样处理。
思路2：感觉上面的用递归不直观，我们可以把字符串转为字符数组，头和尾每个字符调换就可以了。
代码：

package basic.recursion;

import java.util.Scanner;

/**
 * author tanbin 
 * 将字符串反转的几种方法
 * Created by Administrator on 2016/12/6.
 */
public class reverseString {
    public static String reverse(String s){
        if(s.length()<=1){
            return s;
        }
        String left = s.substring(0,s.length()/2);
        String right = s.substring(s.length()/2,s.length());
        return reverse(right)+reverse(left);
    }
    public static void reverse2(char[] c){
        int i=0;
        int j= c.length-1;
        char temp;
        while(i!=j && i<j){
            temp =c[i];
            c[i] = c[j];
            c[j] = temp;
            i++;
            j--;
        }
    }
    public static void reverse3(char[] c){//利用栈,知道大小的数组的情况下用栈有点多余。
        Stack stack = new Stack(new char[c.length]);
        for(int i=0;i<c.length;i++){
            stack.push(c[i]);
        }
        for(int j=0;j<c.length;j++){
            c[j] = stack.pop();
        }

    }
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        //reverse
        String s = reverse(scanner.nextLine());
        System.out.println(s);

        //reverse2
        char[] c = s.toCharArray();
        reverse2(c);
        for(int i=0;i<c.length;i++) {
            System.out.print(c[i]);
        }
        //reverse3
        reverse3(c);
        System.out.println();
        for(int i=0;i<c.length;i++) {
            System.out.print(c[i]);
        }
    }
}


class Stack{
    private char[] container;
    int top=-1;
    public  Stack(char[] c){
        this.container = c;
    }
    public void push(char c){
        top++;
        container[top] = c;
    }
    public char pop(){
        char pop = container[top];
        top--;
        return pop;
    }
}