1

我对Java不是很熟悉，我有点不确定如何将它从c#翻译成java。

Dictionary<string, int> myDictionary = GetDictionary();
int N = 10;

myDictionary
         .OrderByDescending(dictionaryEntry => dictionaryEntry.Value)
         .Take(N)
         .Select(dictionaryEntry => dictionaryEntry.Key)
         .ToList();

现在，我知道字典本身没有被排序，它只是一个新的 IEnumberable，没关系。

谢谢！

4

3 回答 3

1

我不是 C# 人，我从来没有使用过它，但如果我应该猜测一下，您似乎正在按其值按降序对地图进行排序，检索前 10 个元素，然后转换那些的键10 个元素到一个列表中。

如果已知这些值是不同的，那么这很简单——您只需转换为带有交换键和值的 SortedMap。所以我假设这些值不是不同的，即相同的数字可能会出现多次。

在那种情况下，它并不像您的 C# 示例那么简单，而且绝对不像您的 C# 示例那么简单。我的第一个想法是使用自定义比较器创建一个排序集，其中集合中的每个元素都是地图中的 Map.Entry，其中键和值被交换。

这实际上需要相当多的 Java 代码。这是一种尝试：

// Create a SortedSet of the reversed entry set, with a custom comparator for sorting
SortedSet<Map.Entry<Integer, String>> sortedSet = new TreeSet<Map.Entry<Integer, String>>(
        new Comparator<Map.Entry<Integer, String>>() {
    public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
        // sort by key, then by value --> in descending order
        int keyCompareResult = -o1.getKey().compareTo(o2.getKey()); // negate --> descending
        int valueCompareResult = o1.getValue().compareTo(o2.getValue());
        return keyCompareResult == 0 ? valueCompareResult : -keyCompareResult;
    }
});

// Add all entries of the map to the sorted set
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    Map.Entry<Integer, String> reversedEntry = new AbstractMap.SimpleEntry<Integer, String>(entry.getValue(), entry.getKey());
    sortedSet.add(reversedEntry);
}

// Convert the 10 first elements to the resulting list
int N = 10;
List<String> result = new ArrayList<String>(N);
Iterator<Map.Entry<Integer,String>> iterator = sortedSet.iterator();
while (iterator.hasNext() && result.size() < N) {
    Map.Entry<Integer, String> entry = iterator.next();
    result.add(entry.getValue());
}
于 2013-11-08T03:24:09.930 回答
0

我想出了与 Steinar 建议的几乎相同的东西，如果您知道更多 LINQ-y/功能性的方法，请也添加您的答案！

//Convert to List of Map.Entry
ArrayList<Map.Entry<String,Integer>> myArrayList = ArrayList<Map.Entry<String,Integer>>(myHashMap.entrySet());

//Natural order is ascending, so we reverse the comparator to get it Descending.
Collections.sort(myArrayList , Collections.reverseOrder(new EntryComparator()));

//Create list and add Keys

List<String> topNStrings =  new ArrayList<String>();

for (int i = 0; i < N && i < myArrayList.size(); i++)
{
  topNStrings.add(myArrayList.get(i).getKey());
}

并有一个单独的小比较器类

private class EntryComparator implements Comparator<Map.Entry<String,Integer>>
    {
    @Override
    public int compare(Map.Entry<String,Integer> x, Map.Entry<String,Integer> y)
    {
        return compare(x.getValue(), y.getValue());
    }

    private int compare(Integer a, Integer b)
    {
        return a < b ? -1
                : a > b ? 1
                : 0;
    }
}
于 2013-11-08T04:53:14.383 回答
-1

让我们从您以某种方式获得的任意 HashMap 开始HashMap<String, Integer> map。

我们想要对值进行排序，然后获取第一个N值。

int N = 10;

List<Integer> values = new ArrayList<Integer>( map.values() );
Collections.sort(values);
List<Integer> N_values = values.subList(0, N);
于 2013-11-08T03:00:23.660 回答