给大家出道题，算法的

jdk用的是归并排序，这里有些不合适，效率不高
改用先统计每个字母的数量再组装字符串，效率提高一倍

public static String sort(String s){
//26个字母
short[] t =new short[26];
char c[]=s.toCharArray();
for(short i=0;i<c.length;t[c[i++]-'a']++) ;
for(short i=0,j=0;i<26&&j<c.length;i++){
for(short k=1;k<=t[i];k++){
c[j++]=(char)(i+'a');
}
}
return new String(c);
}
[\code]
下面有就有个问题了，对于程序来说，字符串是什么，还不是char[]，这里我们再思考下，反正都是要比较的，我直接把上面的那个short []t丢出来比较是不是更快

public class Comparable {
public short[] t;
public Comparable(String s){
t=PP.sort2(s);
}
@Override
public boolean equals(Object paramObject) {
if(paramObject==null) return false;
if(paramObject instanceof Comparable){
Comparable cast = (Comparable)paramObject;
if(cast.t.length!=this.t.length) return false;
for(int i=0;i<cast.t.length;i++){
if(cast.t[i]!=this.t[i]) return false;
}
return true;
}
return false;
}
@Override
public int hashCode() {
int r=0;
for(int i=0;i<t.length;i++){
r+=r*31+t[i];
}
return r;
}

}
[\code]

完整测试代码

public class PP {
public static void main(String[] args) {
String s="cccabcfdjfdisojfiosfuqjofjidosjfasofusafus";
double time = System.currentTimeMillis();
for(int i=0;i++<1000000;Arrays.sort(s.toCharArray()));
double time2 = System.currentTimeMillis();
System.out.println((time2-time));
for(int i=0;i++<1000000;sort(s));
double time3 = System.currentTimeMillis();
System.out.println(time3-time2);
for(int i=0;i++<1000000;sort2(s));
double time4 = System.currentTimeMillis();
System.out.println(time4-time3);
String str=new String(s);
double time5 = System.currentTimeMillis();
for(int i=0;i++<1000000;s.equals(str));
double time6 =System.currentTimeMillis();
System.out.println(time6-time5);
Comparable c1= new Comparable(s);
Comparable c2 =new Comparable(s);
double time7 = System.currentTimeMillis();
for(int i=0;i++<1000000;c1.equals(c2));
double time8= System.currentTimeMillis();
System.out.println(time8-time7);
}

public static String sort(String s){
//26个字母
short[] t =new short[26];
char c[]=s.toCharArray();
for(short i=0;i<c.length;t[c[i++]-'a']++) ;
for(short i=0,j=0;i<26&&j<c.length;i++){
for(short k=1;k<=t[i];k++){
c[j++]=(char)(i+'a');
}
}
return new String(c);
}
public static short[] sort2(String s){
//26个字母
short[] t =new short[26];
char c[]=s.toCharArray();
for(short i=0;i<c.length;t[c[i++]-'a']++) ;
return t;
}
}
class Comparable {
public short[] t;
public Comparable(String s){
t=PP.sort2(s);
}
@Override
public boolean equals(Object paramObject) {
if(paramObject==null) return false;
if(paramObject instanceof Comparable){
Comparable cast = (Comparable)paramObject;
if(cast.t.length!=this.t.length) return false;
for(int i=0;i<cast.t.length;i++){
if(cast.t[i]!=this.t[i]) return false;
}
return true;
}
return false;
}
@Override
public int hashCode() {
int r=0;
for(int i=0;i<t.length;i++){
r+=r*31+t[i];
}
return r;
}
}
[\code]

结果
1827.0
968.0
410.0
225.0
142.0
(1827+225)/(410+142)≈3.7
差不多比自己写的耗时多3.7倍

不知道大家能不能理解，利用质数方法是不错，但是字符串长度过大的话，BigInteger的性能太差，它内部其实还是数组，依次遍历相乘再进位的算法，很慢

您这个应该就是桶排序吧，不错~

我的想法是这样的：a,b,c,...z 用1，2，4, ....2的(z-a)次方来表示.
比较两个字符串是否一样：
1. 长度一样
2. 全部字符替换成数字后累加和一样， eg: sum(ab)=1+2=3,sum(ba)=2+1=3

key = length(str)+"-"+sum(str)

key一样，字符就相等.

数据结构实现 Map<String,List>
List放相同单词

代码：

package com.robin.question;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Question1 {
     
    public static Map<String,Long> letterValueMap = new HashMap();
    Question1(){
        int begin = (int)'a';
        int end = (int)'z';
        for(int i=begin;i<=end;i++){
            String str = String.valueOf((char)i);
            int j = i-begin;
            Long value = _MN(2,j);
            letterValueMap.put(str, value);
        }
    }
   
    public  void PrintGroupsWithSameLetters (String str){
        Map ret = new TreeMap<String,ArrayList>();
        if(str!=null && str.length()>0){
            String arr [] = str.split(",");
            for(int i=0;i<arr.length;i++){
                String s = arr[i];
                Long value = calStr(s);
                StringBuffer key = new StringBuffer("");
                key.append(s.length());
                key.append("-");
                key.append(value);
                if(ret.containsKey(key.toString())){
                    List strList = (List) ret.get(key.toString());
                    strList.add(s);
                }else{
                    List strList = new ArrayList();
                    strList.add(s);
                    ret.put(key.toString(), strList);
                }
            }
        }
       
        output(ret);
    }
   
    public static void output(Map ret){
        if(ret!=null && !ret.isEmpty()){
            Set<String> keys = ret.keySet();
            for(String key:keys){
              List<String> list = (List) ret.get(key);
             if(list!=null && !list.isEmpty()){
                  for(int i=0;i<list.size();i++){
                      if(i>0){
                          System.out.print(",");
                      }
                      System.out.print(list.get(i).trim());
                  }
                 
                  System.out.println();
              }
            }
        }
    }
  
   
    public static Long _MN(int m,int n){
        Long value = 1L;
        while(n>0){
            value = value * m;
            n--;
        }
       
        return value;
    }
   
    public static Long calStr(String str){
        Long value = 0l;
        str = str.toLowerCase().trim();
        char strArr[] = str.toCharArray();
        for(int i=0;i<strArr.length;i++){
            String s = String.valueOf(strArr[i]);
            value = value +letterValueMap.get(s);
        }
       
        return value;
    }
   
    public static void main(String[] args) {
        Question1 a = new Question1();
        String str = "hat, top, potter, pot, pier, ripe";
        a.PrintGroupsWithSameLetters(str);
    }

}