按出现次数对子字符串进行降序排序 - Java

Question

免得说我有字符串：

 String test= "AA BB CC BB BB CC BB";

我想做的是创建这样的字符串数组：

 String[]{"BB", "CC", "AA"}

因为 B 出现了 4 次，C 出现了 2 次，A 只出现了 1 次。

这个问题的解决方案是什么样的？

Answer 1

String test = "AA BB CC BB BB CC BB";
System.out.println(Arrays.deepToString(sort(test)));

输出：[BB, CC, AA]

代码：

public static String[] sort(String test) {
    String[] strings = test.split(" ");
    HashMap<String,Integer> map = new HashMap<String,Integer>();
    for (String s : strings) {
        Integer i = map.get(s);
        if (i != null) {
            map.put(s, i+1);
        } else {
            map.put(s, 1);
        }
    }

    TreeMap<Integer,String> sort = new TreeMap<Integer,String>(Collections.reverseOrder());
    for (Entry<String,Integer> e : map.entrySet()) {
        sort.put(e.getValue(), e.getKey());
    }

    return sort.values().toArray(new String[0]);
}

Answer 2

你可以做的是这样的（粗略的代码）：

String[] myOccurences = test.split(" ");

然后：

HashMap<String,Integer> occurencesMap = new HashMap<String,Integer>()

for( String s : myOccurences ){
    if( occurencesMap.get( s ) == null ){
        occurencesMap.put(s, 1);
    } else {
        occurencesMap.put(s, occurencesMap.get(s)++ );
    }
}

编辑：实际的排序（再次粗略的代码和未经检查）：

List<String> mapKeys = new ArrayList<String>(occurencesMap.keySet()); // Keys
List<Integer> mapValues = new ArrayList<Integer>(occurencesMap.values()); // Values

TreeSet<Integer> sortedSet = new TreeSet( mapValues ); // Sorted according to natural order                
Integer[] sortedValuesArray = sortedSet.toArray();

HashMap<String,Integer> lhMap = new LinkedHashMap<String,Integer>(); // LinkedHashMaps conserve order

for (int i=0; i<size; i++){
    lhMap.put(mapKeys.get(mapValues.indexOf(sortedArray[i])), sortedValuesArray[i]);
}

mapKeys = new ArrayList<String>(occurencesMap.keySet()); // Keys again, this time sorted
Collections.sort(mapKeys, Collections.reverseOrder()); // Reverse since original ascending

String[] occurencesSortedByDescendingArray = mapKeys.toArray();

随意评论。

Answer 3

如果你想使用番石榴：

Lists.transform(
  Ordering
    .natural()
    .onResultOf(new Function<Multiset.Entry<String>, Integer>() {
        public Integer apply(Multiset.Entry<String> entry) {
          return entry.getCount();
        }
      })
    .reverse()
    .sortedCopy(
        ImmutableMultiset.copyOf( Splitter.onPattern("\\s+").split(test) ).entrySet()
      ),
  new Function<Multiset.Entry<String>, String>() {
    public String apply(Multiset.Entry<String> entry) {
      return entry.getElement();
    }
  }
);

Answer 4

我不确定是否存在用于此确切目的的方法。

但是，您可以使用 String.split() 方法将单个字符串拆分为字符串数组。从那里，您可以找到唯一的字符串（通过手动检查或将它们全部添加到集合中，这将检查重复项）。每次添加元素但它不属于集合时，都会跟踪（并增加每个唯一字符串唯一的计数器）。然后创建一个根据此计数排序的数组。

映射非常适合保存字符串/计数，因为它将维护唯一字符串集作为键，并将每个字符串的计数作为值。