字符串--------如何判断两个字符串是否由相同的字符组成

问题描述：

         由相同的字符组成是指两个字符串，字母以及各个字母的个数是相同的，只是顺序不同。如：“aaaabbc”与“abcbaaa”是由相同字符组成。
算法思路：

方法一：排序法，也是最容易想到的方法，将两个字符串转换为字节数组，分别排序后，判断是否相同即可。

    package JBString;
     
    import java.util.Arrays;
     
    public class Compare {
        public static void compare(String s1, String s2) {
            // char[] b1 = s1.toCharArray();
            // char[] b2 = s1.toCharArray();
            byte[] b1 = s1.getBytes();
            byte[] b2 = s2.getBytes();
            Arrays.sort(b1);
            Arrays.sort(b2);
            s1 = new String(b1);
            s2 = new String(b2);
            if (s1.equals(s2)) {
                System.out.println("equal");
            } else {
                System.out.println(" not equal");
            }
        }
     
        public static void main(String[] args) {
            String str1 = "gdeacbf";
            String str2 = "gdeacbf";
            compare(str1, str2);
            str1 = "gdeacbf";
            str2 = "hmgdeacbf";
            compare(str1, str2);
        }
    }

方法二：集合法（空间换时间），利用Map集合key的唯一性，遍历第一个字符串，将字符作为key，字符出现的次数作为value，若遇到重复字符则将value+1。之后遍历第二个字符串，遇到字符就将对应的value-1,若value值为1时，就将该字符remove掉。最后判断map是否为空，为空则说明两字符串相同。

方法三：数组法（空间换时间）：由于ASCII字符共266个，，申请一个字节数组byte[256]，初始化为0，然后遍历第一个字符串，将对应的ASCII下标+1，然后遍历第二个字符串，将对应标-1。若最后数组中各个元素的值都是0，则说明字符串相等，反之不等。

    package CharString;
     
    import java.util.HashMap;
    import java.util.Map;
     
    public class CompareString {
     
        public static boolean compare(char[] a,char[] b){
            int aLen = a.length;
            int bLen = b.length;
            if(aLen!=bLen){
                return false;
            }
            Map<Character,Integer> map = new HashMap<Character,Integer>();
            for(int i=0;i<aLen;i++){
                if(map.containsKey(a[i])){
                    map.put(a[i], map.get(a[i])+1);
                }else{
                    map.put(a[i], 1);
                }
            }
            for(int j=0;j<bLen;j++){
                if(map.containsKey(a[j])&&map.get(a[j])==1){
                    map.remove(a[j]);
                }else{
                    map.put(a[j], map.get(a[j])-1);
                }
            }
            return map.isEmpty();
            
        }
        
        public static boolean compare2(String a,String b){
            byte[] b1 = a.getBytes();
            byte[] b2 = b.getBytes();
            int[] bCount = new int[256];
            for(int i=0;i<256;i++){
                bCount[i] = 0;
            }
            for(int i=0;i<b1.length;i++)
                bCount[b1[i]-'0']++;
            for(int i=0;i<b2.length;i++)
                bCount[b2[i]-'0']--;
            for(int i=0;i<256;i++){
                if(bCount[i]!=0)
                    return false;
            }
            return true;
        }
        
        public static void main(String[] args) {
            // TODO Auto-generated method stub
     
            StringBuffer s11 = new StringBuffer();
            StringBuffer s22 =  new StringBuffer();
            for(int i=0;i<10000;i++){
                s11.append("aybcybayaatt");
            }
            for(int i=0;i<10000;i++){
                s22.append("aybcybayaatt");
            }
            String s1 = s11.toString();
            String s2 = s22.toString();
            char[] a = s1.toCharArray();
            char[] b = s2.toCharArray();
            
            long l3=System.currentTimeMillis();
            System.out.println(compare(a,b));
            long l4=System.currentTimeMillis();
            System.out.println("集合用时："+(l4-l3));
            
            long l1=System.currentTimeMillis();
            System.out.println(compare2(s1,s2));
            long l2=System.currentTimeMillis();
            System.out.println("数组用时："+(l2-l1));
        }
     

---------------------
作者：hd_sky
来源：CSDN
原文：https://blog.csdn.net/hd12370/article/details/82380039
版权声明：本文为博主原创文章，转载请附上博文链接！