确定两串乱序同构

最开始一看到这个，感觉大致的思路是有的，就是构造两个存放String的集合列表，然后去匹配，但是题目有点描述的不清楚的是“字符串重点空格”是什么含义，而且到底是字母重构，还是单词重构，举个例子吧，”this is micro”和”orcim is this”返回false还是true。如果返回true，那它举的例子只是解决方案的真子集，并不代表一般性。
最开始，我非常不巧的理解成了是单词重构呢。我这样去考虑：

private static boolean checkSam(String stringA, String stringB)
    {
        List<String> list = new ArrayList<String>();
        //空格个数
        //初始化一个StringBuffer
        StringBuffer sb = new StringBuffer();
        int spaceCount = 0;
        for(int i = 0;i < stringA.length();i ++)
        {
            //如果不等于空格，拼接StringBuffer
            if(stringA.charAt(i) != ' ')
            {
                sb.append(stringA.charAt(i));
                if(i == stringA.length() - 1)
                {
                    list.add(sb.toString());
                }
            }
            else 
            {
                spaceCount ++;
                //如果等于空格，则将StringBuffer添加到集合
                list.add(sb.toString());
                //重置StringBuffer
                sb = new StringBuffer();
            }
        }
        //此时获得了String的集合
        //同理处理stringB
        int spaceCount2 = 0;
        List<String> list2 = new ArrayList<String>();
        StringBuffer sb2 = new StringBuffer();
        for(int i = 0;i < stringB.length();i ++)
        {
            //如果不等于空格，拼接StringBuffer
            if(stringB.charAt(i) != ' ')
            {
                sb2.append(stringB.charAt(i));
                if(i == stringB.length() - 1)
                {
                    list2.add(sb2.toString());
                }
            }
            else 
            {
                spaceCount2 ++;
                //如果等于，则将StringBuffer添加到集合
                list2.add(sb2.toString());
                //重置StringBuffer
                sb2 = new StringBuffer();
            }
        }
        if(spaceCount != spaceCount2) return false;
        //接下来匹配
        for(String str : list2)
        {
            if(list.contains(str))
            {
                list.remove(str);
            }
            else
            {
                return false;
            }
        }
        //判断list是否为空
        return list.size() == 0 ? true : false;
    }

思路比较复杂，大概就是list1和list2分别去存放两个字符串里的单词，然后list1和list2中都有的，就取出，然后继续遍历，然后遍历结束判断集合是否为空。我并不感觉解决方案有什么问题，要说真的问题可能也是效率问题。但是总是通过不了测试用例。
这里我遇到了一个问题，如果List里存放的是String和StringBuffer。都有contains方法，如果内容一样，会返回什么结果呢。

        StringBuffer sb1 = new StringBuffer("a");
        StringBuffer sb2 = new StringBuffer("a");
        System.out.println(sb1.equals(sb2));
        System.out.println(sb1.equals("a"));

运行结果为false,false

使用list的contains方法比较StringBuffer

//测试StringBuffer的contains方法
        List<StringBuffer> list = new ArrayList<StringBuffer>();
        StringBuffer sb = new StringBuffer("a");
        list.add(sb);
        StringBuffer sb2 = new StringBuffer("a");
        System.out.println(list.contains(sb2));
        //测试结果为false。StringBuffer的equals方法没有重写，是比较的引用

对于String:

List<String> list2 = new ArrayList<String>();
        String s1 = new String("a");
        list2.add(s1);
        String s2 = new String("a");
        System.out.println(list2.contains(s2));
        //list2如果指定为String类型，会去equals比较。也就是contains就是用equals去比较值

返回true

可以得出的结论就是StringBuffer并没有重写equals方法，因此不会像String那样比较内容，而是比较引用

我再次考虑是否为字母重构。那只有推倒一切从字符去考虑：

//字符重构
    private static boolean reconstruct(String stringA,String stringB)
    {
        char[] cArray1 = stringA.toCharArray();
        char[] cArray2 = stringB.toCharArray();
        Arrays.sort(cArray1);
        Arrays.sort(cArray2);
        for(int i = 0;i < cArray1.length;i ++)
        {
            if(cArray1[i] != cArray2[i])
            {
                return false;
            }
        }
        return true;
    }

成功通过所有测试用例。
这里用了Arrays的类方法sort，有多个重载版本，如果是char数组会比较ASCII码的值排列。实数类型会从小到大排列。