Question

以免我说我有字符串：

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

我想做的是像这样创建String数组：

 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()方法将单个字符串拆分为字符串数组。从那里，您可以找到唯一的字符串（通过手动检查或将它们全部添加到一个集合，这将检查重复）。每次添加元素时跟踪（并增加每个唯一字符串唯一的计数器），它不是集合的一部分。然后创建一个基于此计数排序的数组。

映射是保存字符串/计数的理想选择，因为它会将唯一字符串集保存为键，并将每个字符串的计数作为值。

通过出现降序的子串 - Java

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

4 个答案: