blocks|key|416882|text|TreeMap对我来说似乎是不需要动脑筋的--仅仅是因为“按字母顺序”的要求。当您迭代HashMap时，它没有顺序；TreeMap以自然键的顺序迭代。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|416883|编辑:我认为康拉德的评论可能是在建议“使用HashMap，然后排序”。这很好，因为虽然我们一开始会有N次迭代，但由于重复，到最后我们会有K个<=+N个密钥。我们不妨把昂贵的比特(排序)保留到最后，当我们有更少的键时，而不是承受小但不稳定的打击，保持它的排序。|416884|话虽如此，我目前仍坚持我的答案:因为这是实现目标的最简单方法。我们真的不知道OP是否特别担心性能，但这个问题意味着他关心的是优雅和简洁。使用TreeMap让这一切变得非常简短，这对我很有吸引力。我怀疑，如果性能真的是一个问题，那么可能有比TreeMap或HashMap更好的方法来攻击它:)|416885|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/util/TreeMap.html^0|0|7|17|7|1M|7|0|7|0|0|L|7|0|1Y|7|3B|7|3J|7|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

<a href="http://java.sun.com/javase/6/docs/api/java/util/TreeMap.html" rel="nofollow noreferrer"><code>TreeMap</code></a> seems a no-brainer to me - simply because of the "in alphabetical order" requirement. <code>HashMap</code> has no ordering when you iterate through it; <code>TreeMap</code> iterates in the natural key order.

EDIT: I think Konrad's comment may have been suggesting "use <code>HashMap</code>, then sort." This is good because although we'll have N iterations initially, we'll have K &lt;= N keys by the end due to duplicates. We might as well save the expensive bit (sorting) until the end when we've got fewer keys than take the small-but-non-constant hit of keeping it sorted as we go.

Having said that, I'm sticking to my answer for the moment: because it's the simplest way of achieving the goal. We don't really know that the OP is particularly worried about performance, but the question implies that he's concerned about the elegance and brevity. Using a <code>TreeMap</code> makes this incredibly brief, which appeals to me. I suspect that if performance is really an issue, there may be a better way of attacking it than either <code>TreeMap</code> or <code>HashMap</code> :)

blocks|key|416893|text|TreeMap胜过HashMap，因为TreeMap已经为您排序了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|416894|但是，您可能希望考虑使用更合适的数据结构，即包。请参阅Commons+Collections和TreeBag类：|offset|length|416895|这有一个很好的优化的内部结构和API：|416896|bag.add("big")
bag.add("small")
bag.add("big")
int+count+=+bag.getCount("big")|code-block|syntax|javascript|416897|编辑:+HashMap和TreeMap性能的问题由Jon+-+HashMap回答，排序可能更快(试试吧！)，但TreeBag更容易。包包也是如此。除了TreeBag之外，还有一个HashBag。基于实现(使用可变整数)，bag的性能应该优于Integer的等效平面图。确定的唯一方法是测试，就像任何性能问题一样。|416898|entityMap|0|LINK|mutability|MUTABLE|url|http://commons.apache.org/collections|1|http://commons.apache.org/collections/api-3.2/org/apache/commons/collections/bag/TreeBag.html^0|0|R|J|0|1B|7|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]|$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

TreeMap beats HashMap because TreeMap is already sorted for you.

However, you might want to consider using a more appropriate data structure, a bag. See 
<a href="http://commons.apache.org/collections" rel="noreferrer">Commons Collections</a> - and the <a href="http://commons.apache.org/collections/api-3.2/org/apache/commons/collections/bag/TreeBag.html" rel="noreferrer">TreeBag</a> class:

This has a nice optimised internal structure and API:

<pre><code>bag.add("big")
bag.add("small")
bag.add("big")
int count = bag.getCount("big")
</code></pre>

EDIT: The question of HashMap vs TreeMap performance was answered by Jon - HashMap and sort may be quicker (try it!), but TreeBag is easier. The same is true for bags. There is a HashBag as well as a TreeBag. Based on the implementation (uses a mutable integer) a bag should outperform the equivalent plain map of Integer. The only way to know for sure is to test, as with any performance question.

blocks|key|3255745|text|根据速度要求的不同，您也可以使用Trie。但是如果TreeMap足够快，那么实现其中一个就没有意义了。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3255746|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Trie^0|G|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Depending on what the speed requirements are, you could also use a <a href="http://en.wikipedia.org/wiki/Trie" rel="nofollow noreferrer">Trie</a>. But there's no point in implementing one of those if a TreeMap is quick enough.

blocks|key|3255981|text|为什么不使用TreeSet|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3255982|排序概念与TreeMap相同，不同之处在于它是一个集合--根据定义，集合是“不包含重复元素的集合”。|3255983|从你的问题描述中，听起来好像你需要一个集合，我看不出你把什么键和值映射在一起。|3255984|在一个TreeMap实例的支持下，这个类实现了|3255985|接口。这个类保证排序后的集合按元素的升序排列，按照元素的自然顺序排序(参见比较)，或者按照创建集合时提供的比较器排序，具体取决于所使用的构造函数。|blockquote|3255986|3255987|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.4.2/docs/api/java/util/TreeSet.html^0|6|7|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|12|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|13|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]]]

Why not use <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/TreeSet.html" rel="nofollow noreferrer">TreeSet</a>?

Same ordering concept as a TreeMap, except it's a Set - which, by definition, is "A collection that contains no duplicate elements". 

From your problem description, it sounds as if you need a Set, I don't see what keys and values you are mapping together.

<blockquote>
 This class implements the Set interface, backed by a TreeMap instance. This class guarantees that the sorted set will be in ascending element order, sorted according to the natural order of the elements (see Comparable), or by the comparator provided at set creation time, depending on which constructor is used.
</blockquote>

blocks|key|3256047|text|不能将TreeMap<String,Number>赋给类型为Map<String,Integer>的变量。Double、Long等可以“放入”到TreeMap<String,Number>中。当我从Map<String,Integer>“获取”一个值时，它必须是一个Integer。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3256048|完全忽略任何i18n问题、内存约束和错误处理，如下所示：|3256049|class+Counter+{

++public+static+void+main(String...+argv)
++++throws+Exception
++{
++++FileChannel+fc+=+new+FileInputStream(argv[0]).getChannel();
++++ByteBuffer+bb+=+fc.map(FileChannel.MapMode.READ_ONLY,+0,+fc.size());
++++CharBuffer+cb+=+Charset.defaultCharset().decode(bb);
++++Pattern+p+=+Pattern.compile("[%5E+\t\r\n\f.,!?:;\"()']%2B");
++++Map<String,+Integer>+counts+=+new+TreeMap<String,+Integer>();
++++Matcher+m+=+p.matcher(cb);
++++while+(m.find())+{
++++++String+word+=+m.group();
++++++Integer+count+=+counts.get(word);
++++++count+=+(count+==+null)+?+1+:+count+%2B+1;
++++++counts.put(word,+count);
++++}
++++fc.close();
++++for+(Map.Entry<String,+Integer>+e+:+counts.entrySet())+{
++++++System.out.printf("%25s:+%25d%25n",+e.getKey(),+e.getValue());
++++}
++}

}|code-block|syntax|javascript|3256050|entityMap^0|3|M|U|J|1H|6|1O|4|20|M|2R|J|3P|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|N|$]]

You can't assign a <code>TreeMap&lt;String,Number&gt;</code> to a variable with the type <code>Map&lt;String,Integer&gt;</code>. <code>Double</code>, <code>Long</code>, etc. can be "put" into a <code>TreeMap&lt;String,Number&gt;</code>. When I "get" a value from a <code>Map&lt;String,Integer&gt;</code>, it must be an <code>Integer</code>.

Completely ignoring any i18n issues, memory constraints, and error handling, here goes:

<pre><code>class Counter {

 public static void main(String... argv)
 throws Exception
 {
 FileChannel fc = new FileInputStream(argv[0]).getChannel();
 ByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
 CharBuffer cb = Charset.defaultCharset().decode(bb);
 Pattern p = Pattern.compile("[^ \t\r\n\f.,!?:;\"()']+");
 Map&lt;String, Integer&gt; counts = new TreeMap&lt;String, Integer&gt;();
 Matcher m = p.matcher(cb);
 while (m.find()) {
 String word = m.group();
 Integer count = counts.get(word);
 count = (count == null) ? 1 : count + 1;
 counts.put(word, count);
 }
 fc.close();
 for (Map.Entry&lt;String, Integer&gt; e : counts.entrySet()) {
 System.out.printf("%s: %d%n", e.getKey(), e.getValue());
 }
 }

}
</code></pre>

blocks|key|3256059|text|散列映射应该要快得多。您不应该根据希望项目最终如何排列来选择容器；只需对末尾的(单词、频率)-pairs列表进行排序即可。要排序的此类对通常比文件中的单词要少，因此使用散列映射的渐近(和实际)性能会更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3256060|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Hash map should be much faster. You should not choose a container based on how you want the items to be arranged eventually; Just sort the list of (word, frequency)-pairs at the end. There will usually be less such pairs to be sorted than words in the files, so asymptotic (and real) performance with a hash map will be better.

blocks|key|3256070|text|我肯定会选择TreeMap：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3256071|3256072|TreeMap在插入时自动对新键进行排序，以后不需要排序。|unordered-list-item|3256073|如果键已经存在，则它具有与HashMap相同的性能。|3256074|3256075|TreeSet在内部使用TreeMap，那么为什么不直接使用TreeMap呢？|3256076|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|P|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|L|$]]

I would definitely choose a TreeMap:

<ul>
<li>TreeMap automatically sorts new keys on insertion, no sorting afterwards is needed.</li>
<li>When a key already exists it has the same performance as a HashMap.</li>
</ul>

A TreeSet internally uses a TreeMap so why not use TreeMap directly.

blocks|key|411303|text|“当一个键已经存在时，它具有与HashMap相同的性能。”--这是完全错误的。HashMap具有O(1)插入和TreeMap+O(+n+)。它至少需要n次log+n次检查才能确定它是否在表中！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|411304|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

"When a key already exists it has the same performance as a HashMap." - That is just plain wrong. HashMap has O(1) insertion and TreeMap O(n log n). It'll take at least n log n checks to find out if it's in the table!

blocks|key|411306|text|考虑对数据结构进行添加或删除的频率。如果它很高，TreeMap将不是理想的。除了搜索现有的条目nLn之外，它还经历了频繁的重新平衡。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|411307|另一方面，Hash结构在内存上有点华丽(过度分配)。如果你能咬紧牙关，那么就使用散列结构，并在需要的时候进行排序。|411308|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

consider the frequency of addition or deletion to the data structure. TreeMap would not be ideal if it is high. Apart from the search for existing entry nLn it also undergoes frequent rebalancing.

on the other hand Hash structures are bit flamboyant on memory (over allocates). If you can bite that bullet then go for hash structure and sort when required.

blocks|key|411310|text|基本上，它取决于需求。有时哈希映射很好，有时是树映射。但哈希映射最好只使用他们的一些限制开销来排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|411311|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Basically it depend on the requirement. Sometimes hash map is good sometimes treemap. but hash map is better to use only their is some constraint for overhead to sort it.

blocks|key|411313|text|我看到不少人说"TreeMap+look-up+takes+O(n+log+n)"！怎么会这样?|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|411314|我不知道它是如何实现的，但在我的脑海中，它需要O(log+n)。|411315|这是因为在树中的查找可以在O(log+n)中完成。并不是每次在树中插入项目时都对整个树进行排序。这就是使用树的全部想法！|411316|因此，回到原来的问题，可作比较的数字如下：|411317|HashMap方法：+O(n+%2B+k+log+k)平均情况，最坏情况可能更大|BOLD|411318|TreeMap方法：+O(k+%2B+n+log+k)最坏情况|411319|其中n=文本中的单词数量，k=文本中不同单词的数量。|411320|entityMap^0|U|A|0|N|8|0|D|8|0|0|0|A|B|E|0|0|A|B|E|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|13|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|14|8|@$9|15|A|16|B|N]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|19|8|@$9|1A|A|1B|B|N]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1E|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|T|$]]

I see quite a few people saying "TreeMap look-up takes <code>O(n log n)</code>"!! How come? 

I don't know how it has been implemented but in my head it takes <code>O(log n)</code>. 

This is because look-up in a tree can be done in <code>O(log n)</code>. You don't sort the entire tree every time you insert an item in it. That's the whole idea of using a tree!

Hence, going back to the original question, the figures for comparison turn out to be:

HashMap approach: <code>O(n + k log k)</code> average case, worst case could be much larger

TreeMap approach: <code>O(k + n log k)</code> worst case

where n = number of words in the text , k = number of distinct words in the text.

blocks|key|411325|text|import+java.io.BufferedReader;
import+java.io.DataInputStream;
import+java.io.FileInputStream;
import+java.io.FileNotFoundException;
import+java.io.IOException;
import+java.io.InputStreamReader;
import+java.io.ObjectInputStream.GetField;
import+java.util.Iterator;
import+java.util.Map;
import+java.util.StringTokenizer;
import+java.util.TreeMap;

public+class+TreeMapExample+{

++++public+static+void+main+(String+args[]){
++++++++Map<String,Integer>+tm+=+new+TreeMap<String,Integer>();
++++++++try+{

++++++++++++FileInputStream+fis+=+new+FileInputStream("Test.txt");
++++++++++++DataInputStream+in+=+new+DataInputStream(fis);
++++++++++++BufferedReader+br+=+new+BufferedReader(new+InputStreamReader(in));
++++++++++++String+line;
++++++++++++int+countValue+=+1;
++++++++++++while((line+=+br.readLine())!=+null+){
++++++++++++++++line+=+line.replaceAll("[-%2B.%5E:;,()\"\\[\\]]","");
++++++++++++++++StringTokenizer+st+=+new+StringTokenizer(line,+"+");++++
++++++++++++++++while(st.hasMoreTokens()){
++++++++++++++++++++String+nextElement+=+(String)+st.nextElement();

++++++++++++++++++++if(tm.size()>0+&&+tm.containsKey(nextElement)){
++++++++++++++++++++++++int+val+=+0;
++++++++++++++++++++++++if(tm.get(nextElement)!=+null){
++++++++++++++++++++++++val+=+(Integer)+tm.get(nextElement);
++++++++++++++++++++++++val+=+val%2B1;
++++++++++++++++++++++++}
++++++++++++++++++++++++tm.put(nextElement,+val);
++++++++++++++++++++}else{
++++++++++++++++++++tm.put(nextElement,+1);
++++++++++++++++++++}

++++++++++++++++}
++++++++++++}
++++++++++++for(Map.Entry<String,Integer>+entry+:+tm.entrySet())+{
++++++++++++System.out.println(entry.getKey()+%2B+"+:+"+%2B+entry.getValue());
++++++++++++}

++++++++}+catch+(FileNotFoundException+e)+{
++++++++++++//+TODO+Auto-generated+catch+block
++++++++++++e.printStackTrace();
++++++++}+catch+(IOException+e)+{
++++++++++++//+TODO+Auto-generated+catch+block
++++++++++++e.printStackTrace();
++++++++}
++++}

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|411326|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream.GetField;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class TreeMapExample {

 public static void main (String args[]){
 Map&lt;String,Integer&gt; tm = new TreeMap&lt;String,Integer&gt;();
 try {

 FileInputStream fis = new FileInputStream("Test.txt");
 DataInputStream in = new DataInputStream(fis);
 BufferedReader br = new BufferedReader(new InputStreamReader(in));
 String line;
 int countValue = 1;
 while((line = br.readLine())!= null ){
 line = line.replaceAll("[-+.^:;,()\"\\[\\]]","");
 StringTokenizer st = new StringTokenizer(line, " "); 
 while(st.hasMoreTokens()){
 String nextElement = (String) st.nextElement();

 if(tm.size()&gt;0 &amp;&amp; tm.containsKey(nextElement)){
 int val = 0;
 if(tm.get(nextElement)!= null){
 val = (Integer) tm.get(nextElement);
 val = val+1;
 }
 tm.put(nextElement, val);
 }else{
 tm.put(nextElement, 1);
 }

 }
 }
 for(Map.Entry&lt;String,Integer&gt; entry : tm.entrySet()) {
 System.out.println(entry.getKey() + " : " + entry.getValue());
 }

 } catch (FileNotFoundException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 } catch (IOException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }
 }

}
</code></pre>

blocks|key|3469346|text|这是一个读取文本文件的java示例，根据键排序，然后根据值排序；这取决于文件中单词出现的次数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3469347|public+class+SortFileWords+{

++++public+static+void+main(String[]+args)+{
++++++++HashMap<String,+Integer>+map+=+new+HashMap<String,+Integer>();
++++++++ValueCompare+vc+=+new+ValueCompare(map);
++++++++TreeMap<String,+Integer>+sorted_map+=+new+TreeMap<String,+Integer>(map);
++++++++List<String>+list+=+new+ArrayList<>();
++++++++Scanner+sc;
++++++++try+{
++++++++++++sc+=+new+Scanner(new+File("c:\\ReadMe1.txt"));
++++++++++++while+(sc.hasNext())+{
++++++++++++++++list.add(sc.next());
++++++++++++}
++++++++++++sc.close();
++++++++}+catch+(FileNotFoundException+e)+{
++++++++++++e.printStackTrace();
++++++++}

++++++++for+(String+s+:+list)+{
++++++++++++if+(map.containsKey(s))+{
++++++++++++++++map.put(s,+map.get(s)+%2B+1);
++++++++++++}+else
++++++++++++++++map.put(s,+1);
++++++++}

++++++++System.out.println("Unsorted+map:+"+%2B+map);
++++++++sorted_map.putAll(map);
++++++++System.out.println("Sorted+map+on+keys:+"+%2B+sorted_map);

++++++++TreeMap<String,+Integer>+sorted_value_map+=+new+TreeMap<>(vc);
++++++++sorted_value_map.putAll(map);
++++++++System.out.println("Sorted+map+on+values:+"+%2B+sorted_value_map);
++++}
}

class+ValueCompare+implements+Comparator<String>+{

++++Map<String,+Integer>+map;

++++public+ValueCompare(Map<String,+Integer>+map)+{
++++++++this.map+=+map;
++++}

++++@Override
++++public+int+compare(String+s1,+String+s2)+{
++++++++if+(map.get(s1)+>=+map.get(s2))
++++++++++++return+-1;
++++++++else
++++++++++++return+1;
++++}
}|code-block|syntax|javascript|3469348|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the java example for reading a text file, sorting based on key, then upon values; depending on the number of occurrence of a words in the file.

<pre><code>public class SortFileWords {

 public static void main(String[] args) {
 HashMap&lt;String, Integer&gt; map = new HashMap&lt;String, Integer&gt;();
 ValueCompare vc = new ValueCompare(map);
 TreeMap&lt;String, Integer&gt; sorted_map = new TreeMap&lt;String, Integer&gt;(map);
 List&lt;String&gt; list = new ArrayList&lt;&gt;();
 Scanner sc;
 try {
 sc = new Scanner(new File("c:\\ReadMe1.txt"));
 while (sc.hasNext()) {
 list.add(sc.next());
 }
 sc.close();
 } catch (FileNotFoundException e) {
 e.printStackTrace();
 }

 for (String s : list) {
 if (map.containsKey(s)) {
 map.put(s, map.get(s) + 1);
 } else
 map.put(s, 1);
 }

 System.out.println("Unsorted map: " + map);
 sorted_map.putAll(map);
 System.out.println("Sorted map on keys: " + sorted_map);

 TreeMap&lt;String, Integer&gt; sorted_value_map = new TreeMap&lt;&gt;(vc);
 sorted_value_map.putAll(map);
 System.out.println("Sorted map on values: " + sorted_value_map);
 }
}

class ValueCompare implements Comparator&lt;String&gt; {

 Map&lt;String, Integer&gt; map;

 public ValueCompare(Map&lt;String, Integer&gt; map) {
 this.map = map;
 }

 @Override
 public int compare(String s1, String s2) {
 if (map.get(s1) &gt;= map.get(s2))
 return -1;
 else
 return 1;
 }
}
</code></pre>

blocks|key|414859|text|对于这种方式，在我看来，最好使用Apache+Commons+Collections中的HashBag或Guava中的HashMultiset或Eclipse+Collections中的HashBag+(正式的GS+Collections)或任何以下类：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|414860|++++Order++++%7C++Guava+++++++++++%7C+++Apache++%7C+Eclipse(GS)+%7C+JDK+analog
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Not+define+++%7C+HashMultiset+++++%7C+++HashBag+%7C+HashBag+++++%7C+HashMap<String,+Integer>
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Sorted+++++++%7C+TreeMultiset+++++%7C+++TreeBag+%7C+TreeBag+++++%7C+TreeMap<String,+Integer>
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Linked+++++++%7CLinkedHashMultiset%7C+++++-+++++%7C+++++-+++++++%7C+LinkedHashMap<String,+Integere>
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Concurrent+&+%7C+ConcurrentHash-++%7CSynchroniz-%7CSynchroniz-++%7C+Collections.synchronizedMap(
not+define+++%7C+Multiset+++++++++%7C+++edBag+++%7C+edBag+++++++%7C+++++++HashMap<String,+Integer>)
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Concurrent+++%7C+++++++++-++++++++%7CSynchroniz-%7CSynchroniz-++%7C+Collections.synchronizedSorted-
and+sorted+++%7C++++++++++++++++++%7CedSortedBag%7C+edSortedBag+%7C+++++++Map(TreeMap<>))
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Immutable+and%7C+ImmutableMultiset%7CUnmodifiab-%7CUnmodifiab-++%7C+Collections.unmodifiableMap(
not+define+++%7C++++++++++++++++++%7C+++leBag+++%7C+leBag+++++++%7C+HashMap<String,+Integer>)
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Immutable+and%7C+ImmutableSorted-+%7CUnmodifiab-%7CUnmodifiab-++%7C+Collections.unmodifiableSorted-
sorted+++++++%7C+Multiset+++++++++%7CleSortedBag%7C+leSortedBag+%7C+Map(TreeMap<String,+Integer>))
────────────────────────────────────────────────────────────────────────|code-block|syntax|javascript|414861|示例：|414862|1.+Using+SynchronizedSortedBag+from+Apache|414863|++++//+Parse+text+to+separate+words
++++String+INPUT_TEXT+=+"Hello+World!+Hello+All!+Hi+World!";
++++//+Create+Multiset
++++Bag+bag+=+SynchronizedSortedBag.synchronizedBag(new+TreeBag(Arrays.asList(INPUT_TEXT.split("+"))));

++++//+Print+count+words
++++System.out.println(bag);+//+print+[1:All!,2:Hello,1:Hi,2:World!]-+in+natural+(alphabet)+order
++++//+Print+all+unique+words
++++System.out.println(bag.uniqueSet());++++//+print+[All!,+Hello,+Hi,+World!]-+in+natural+(alphabet)+order


++++//+Print+count+occurrences+of+words
++++System.out.println("Hello+=+"+%2B+bag.getCount("Hello"));++++//+print+2
++++System.out.println("World+=+"+%2B+bag.getCount("World!"));++++//+print+2
++++System.out.println("All+=+"+%2B+bag.getCount("All!"));++++//+print+1
++++System.out.println("Hi+=+"+%2B+bag.getCount("Hi"));++++//+print+1
++++System.out.println("Empty+=+"+%2B+bag.getCount("Empty"));++++//+print+0

++++//+Print+count+all+words
++++System.out.println(bag.size());++++//print+6

++++//+Print+count+unique+words
++++System.out.println(bag.uniqueSet().size());++++//print+4|414864|2.+Using+TreeBag+from+Eclipse(GC)|414865|++++//+Parse+text+to+separate+words
++++String+INPUT_TEXT+=+"Hello+World!+Hello+All!+Hi+World!";
++++//+Create+Multiset
++++MutableSortedBag<String>+bag+=++TreeBag.newBag(Arrays.asList(INPUT_TEXT.split("+")));

++++//+Print+count+words
++++System.out.println(bag);+//+print+[All!,+Hello,+Hello,+Hi,+World!,+World!]-+in+natural+order
++++//+Print+all+unique+words
++++System.out.println(bag.toSortedSet());++++//+print+[All!,+Hello,+Hi,+World!]-+in+natural+order

++++//+Print+count+occurrences+of+words
++++System.out.println("Hello+=+"+%2B+bag.occurrencesOf("Hello"));++++//+print+2
++++System.out.println("World+=+"+%2B+bag.occurrencesOf("World!"));++++//+print+2
++++System.out.println("All+=+"+%2B+bag.occurrencesOf("All!"));++++//+print+1
++++System.out.println("Hi+=+"+%2B+bag.occurrencesOf("Hi"));++++//+print+1
++++System.out.println("Empty+=+"+%2B+bag.occurrencesOf("Empty"));++++//+print+0

++++//+Print+count+all+words
++++System.out.println(bag.size());++++//print+6

++++//+Print+count+unique+words
++++System.out.println(bag.toSet().size());++++//print+4|414866|3.+Using+LinkedHashMultiset+from+Guava|414867|++++//+Parse+text+to+separate+words
++++String+INPUT_TEXT+=+"Hello+World!+Hello+All!+Hi+World!";
++++//+Create+Multiset
++++Multiset<String>+multiset+=+LinkedHashMultiset.create(Arrays.asList(INPUT_TEXT.split("+")));

++++//+Print+count+words
++++System.out.println(multiset);+//+print+[Hello+x+2,+World!+x+2,+All!,+Hi]-+in+predictable+iteration+order
++++//+Print+all+unique+words
++++System.out.println(multiset.elementSet());++++//+print+[Hello,+World!,+All!,+Hi]+-+in+predictable+iteration+order

++++//+Print+count+occurrences+of+words
++++System.out.println("Hello+=+"+%2B+multiset.count("Hello"));++++//+print+2
++++System.out.println("World+=+"+%2B+multiset.count("World!"));++++//+print+2
++++System.out.println("All+=+"+%2B+multiset.count("All!"));++++//+print+1
++++System.out.println("Hi+=+"+%2B+multiset.count("Hi"));++++//+print+1
++++System.out.println("Empty+=+"+%2B+multiset.count("Empty"));++++//+print+0

++++//+Print+count+all+words
++++System.out.println(multiset.size());++++//print+6

++++//+Print+count+unique+words
++++System.out.println(multiset.elementSet().size());++++//print+4|414868|More+examples+you+can+find+in+my+github+projects|414869|entityMap|0|LINK|mutability|MUTABLE|url|https://commons.apache.org/proper/commons-collections/|1|http://commons.apache.org/proper/commons-collections/javadocs/api-3.2.1/org/apache/commons/collections/bag/HashBag.html|2|https://github.com/google/guava|3|http://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/HashMultiset.html|4|https://projects.eclipse.org/proposals/eclipse-collections|5|http://www.goldmansachs.com/gs-collections/javadoc/6.1.0/com/gs/collections/impl/bag/mutable/HashBag.html|6|https://github.com/goldmansachs/gs-collections|7|http://www.goldmansachs.com/gs-collections/javadoc/6.1.0/com/gs/collections/impl/bag/sorted/mutable/SynchronizedSortedBag.html|8|http://www.goldmansachs.com/gs-collections/javadoc/6.1.0/com/gs/collections/impl/bag/sorted/mutable/TreeBag.html|9|10|https://github.com/Vedenin/java_in_examples/tree/master/collections/src/com/github/vedenin/eng/collections/multiset^0|G|Q|0|18|7|1|1G|5|2|1N|C|3|20|J|4|2L|7|5|2X|E|6|0|0|0|3|13|7|0|0|0|X|8|0|0|3|Z|9|0|0|0|1C|A|0^^$0|@$1|2|3|4|5|6|7|1P|8|@]|9|@$A|1Q|B|1R|1|1S]|$A|1T|B|1U|1|1V]|$A|1W|B|1X|1|1Y]|$A|1Z|B|20|1|21]|$A|22|B|23|1|24]|$A|25|B|26|1|27]|$A|28|B|29|1|2A]]|C|$]]|$1|D|3|E|5|F|7|2B|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|2C|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|2D|8|@]|9|@$A|2E|B|2F|1|2G]]|C|$]]|$1|M|3|N|5|F|7|2H|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|2I|8|@]|9|@$A|2J|B|2K|1|2L]]|C|$]]|$1|Q|3|R|5|F|7|2M|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|2N|8|@]|9|@$A|2O|B|2P|1|2Q]]|C|$]]|$1|U|3|V|5|F|7|2R|8|@]|9|@]|C|$G|H]]|$1|W|3|X|5|6|7|2S|8|@]|9|@$A|2T|B|2U|1|2V]]|C|$]]|$1|Y|3|-4|5|6|7|2W|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|17]]|18|$5|11|12|13|C|$14|19]]|1A|$5|11|12|13|C|$14|1B]]|1C|$5|11|12|13|C|$14|1D]]|1E|$5|11|12|13|C|$14|1F]]|1G|$5|11|12|13|C|$14|1H]]|1I|$5|11|12|13|C|$14|1J]]|1K|$5|11|12|13|C|$14|1L]]|1M|$5|11|12|13|C|$14|1J]]|1N|$5|11|12|13|C|$14|1O]]]]

For this way, in my opinion, better use <a href="http://commons.apache.org/proper/commons-collections/javadocs/api-3.2.1/org/apache/commons/collections/bag/HashBag.html" rel="nofollow">HashBag</a> from <a href="https://commons.apache.org/proper/commons-collections/" rel="nofollow">Apache Commons Collections</a> or <a href="http://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/HashMultiset.html" rel="nofollow">HashMultiset</a> from <a href="https://github.com/google/guava" rel="nofollow">Guava</a> or <a href="http://www.goldmansachs.com/gs-collections/javadoc/6.1.0/com/gs/collections/impl/bag/mutable/HashBag.html" rel="nofollow">HashBag</a> from <a href="https://projects.eclipse.org/proposals/eclipse-collections" rel="nofollow">Eclipse Collections</a> (formaly <a href="https://github.com/goldmansachs/gs-collections" rel="nofollow">GS Collections</a>) or any following classes:

<pre><code> Order | Guava | Apache | Eclipse(GS) | JDK analog
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Not define | HashMultiset | HashBag | HashBag | HashMap&lt;String, Integer&gt;
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Sorted | TreeMultiset | TreeBag | TreeBag | TreeMap&lt;String, Integer&gt;
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Linked |LinkedHashMultiset| - | - | LinkedHashMap&lt;String, Integere&gt;
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Concurrent &amp; | ConcurrentHash- |Synchroniz-|Synchroniz- | Collections.synchronizedMap(
not define | Multiset | edBag | edBag | HashMap&lt;String, Integer&gt;)
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Concurrent | - |Synchroniz-|Synchroniz- | Collections.synchronizedSorted-
and sorted | |edSortedBag| edSortedBag | Map(TreeMap&lt;&gt;))
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Immutable and| ImmutableMultiset|Unmodifiab-|Unmodifiab- | Collections.unmodifiableMap(
not define | | leBag | leBag | HashMap&lt;String, Integer&gt;)
─────────────┼──────────────────┼───────────┼─────────────┼─────────────
Immutable and| ImmutableSorted- |Unmodifiab-|Unmodifiab- | Collections.unmodifiableSorted-
sorted | Multiset |leSortedBag| leSortedBag | Map(TreeMap&lt;String, Integer&gt;))
────────────────────────────────────────────────────────────────────────
</code></pre>

Examples:

<h3>1. <a href="http://www.goldmansachs.com/gs-collections/javadoc/6.1.0/com/gs/collections/impl/bag/sorted/mutable/SynchronizedSortedBag.html" rel="nofollow">Using SynchronizedSortedBag from Apache</a>:</h3>

<pre><code> // Parse text to separate words
 String INPUT_TEXT = "Hello World! Hello All! Hi World!";
 // Create Multiset
 Bag bag = SynchronizedSortedBag.synchronizedBag(new TreeBag(Arrays.asList(INPUT_TEXT.split(" "))));

 // Print count words
 System.out.println(bag); // print [1:All!,2:Hello,1:Hi,2:World!]- in natural (alphabet) order
 // Print all unique words
 System.out.println(bag.uniqueSet()); // print [All!, Hello, Hi, World!]- in natural (alphabet) order


 // Print count occurrences of words
 System.out.println("Hello = " + bag.getCount("Hello")); // print 2
 System.out.println("World = " + bag.getCount("World!")); // print 2
 System.out.println("All = " + bag.getCount("All!")); // print 1
 System.out.println("Hi = " + bag.getCount("Hi")); // print 1
 System.out.println("Empty = " + bag.getCount("Empty")); // print 0

 // Print count all words
 System.out.println(bag.size()); //print 6

 // Print count unique words
 System.out.println(bag.uniqueSet().size()); //print 4
</code></pre>

<h3><a href="http://www.goldmansachs.com/gs-collections/javadoc/6.1.0/com/gs/collections/impl/bag/sorted/mutable/TreeBag.html" rel="nofollow">2. Using TreeBag from Eclipse(GC)</a>:</h3>

<pre><code> // Parse text to separate words
 String INPUT_TEXT = "Hello World! Hello All! Hi World!";
 // Create Multiset
 MutableSortedBag&lt;String&gt; bag = TreeBag.newBag(Arrays.asList(INPUT_TEXT.split(" ")));

 // Print count words
 System.out.println(bag); // print [All!, Hello, Hello, Hi, World!, World!]- in natural order
 // Print all unique words
 System.out.println(bag.toSortedSet()); // print [All!, Hello, Hi, World!]- in natural order

 // Print count occurrences of words
 System.out.println("Hello = " + bag.occurrencesOf("Hello")); // print 2
 System.out.println("World = " + bag.occurrencesOf("World!")); // print 2
 System.out.println("All = " + bag.occurrencesOf("All!")); // print 1
 System.out.println("Hi = " + bag.occurrencesOf("Hi")); // print 1
 System.out.println("Empty = " + bag.occurrencesOf("Empty")); // print 0

 // Print count all words
 System.out.println(bag.size()); //print 6

 // Print count unique words
 System.out.println(bag.toSet().size()); //print 4
</code></pre>

<h3>3. <a href="http://www.goldmansachs.com/gs-collections/javadoc/6.1.0/com/gs/collections/impl/bag/sorted/mutable/SynchronizedSortedBag.html" rel="nofollow">Using LinkedHashMultiset from Guava</a>:</h3>

<pre><code> // Parse text to separate words
 String INPUT_TEXT = "Hello World! Hello All! Hi World!";
 // Create Multiset
 Multiset&lt;String&gt; multiset = LinkedHashMultiset.create(Arrays.asList(INPUT_TEXT.split(" ")));

 // Print count words
 System.out.println(multiset); // print [Hello x 2, World! x 2, All!, Hi]- in predictable iteration order
 // Print all unique words
 System.out.println(multiset.elementSet()); // print [Hello, World!, All!, Hi] - in predictable iteration order

 // Print count occurrences of words
 System.out.println("Hello = " + multiset.count("Hello")); // print 2
 System.out.println("World = " + multiset.count("World!")); // print 2
 System.out.println("All = " + multiset.count("All!")); // print 1
 System.out.println("Hi = " + multiset.count("Hi")); // print 1
 System.out.println("Empty = " + multiset.count("Empty")); // print 0

 // Print count all words
 System.out.println(multiset.size()); //print 6

 // Print count unique words
 System.out.println(multiset.elementSet().size()); //print 4
</code></pre>

<h2><a href="https://github.com/Vedenin/java_in_examples/tree/master/collections/src/com/github/vedenin/eng/collections/multiset" rel="nofollow">More examples you can find in my github projects</a></h2>

Description | A Java program to read a text file and print each of the unique words in alphabetical order together with the number of times the word occurs in the text. 

The program should declare a variable of type <code>Map&lt;String, Integer&gt;</code> to store the words and corresponding frequency of occurrence. Which concrete type, though? <code>TreeMap&lt;String, Number&gt;</code> or <code>HashMap&lt;String, Number&gt;</code> ?

The input should be converted to lower case.

A word does not contain any of these characters: <code>\t\t\n]f.,!?:;\"()'</code>

Example output | 

<pre><code> Word Frequency
 a 1
 and 5
 appearances 1
 as 1
 .
 .
 .
</code></pre>

Remark | I know, I've seen elegant solutions to this in Perl with roughly two lines of code. However, I want to see it in Java. 

Edit: Oh yeah, it be helpful to show an implementation using one of these structures (in Java).

Which data structure would you use: TreeMap or HashMap? (Java)

数据结构

Eclipse

容器

Java

Perl

说明|一个Java程序，用于读取文本文件并按字母顺序打印每个唯一的单词以及单词在文本中出现的次数。程序应该声明一个Map<String, Integer>类型的变量来存储单词和相应的出现频率。具体是哪种类型？TreeMap<String, Number>还是HashMap<String, Number>？输入应转换为小...

问你会使用哪种数据结构: TreeMap还是HashMap？(Java)
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你会使用哪种数据结构: TreeMap还是HashMap？(Java)EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你会使用哪种数据结构: TreeMap还是HashMap？(Java)
EN