blocks|key|722598|text|关于你的第一个问题...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|722599|List、Map和Set具有不同的用途。我建议在http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html上阅读有关Java+Collections+Framework的内容。|offset|length|722600|更具体一点：|722601|722602|如果您需要一个类似数组的数据结构，并且需要遍历元素，请使用|unordered-list-item|722603|如果您需要字典之类的内容，请使用|722604|如果您只需要确定某项内容是否属于集合，请使用集合。|722605|722606|关于你的第二个问题...|722607|向量和ArrayList之间的主要区别是前者是同步的，后者是不同步的。您可以在Java+Concurrency+in+Practice中阅读有关同步的更多信息。|722608|哈希表(注意，T不是大写字母)和HashMap之间的区别是相似的，前者是同步的，后者是不同步的。|722609|我要说的是，没有经验法则来选择一种或另一种实现，这真的取决于你的需求。|722610|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html|1|https://rads.stackoverflow.com/amzn/click/com/0321349601^0|0|O|21|0|0|0|0|0|0|0|0|0|13|S|1|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|F|3|G|5|6|7|1D|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1F|8|@]|9|@]|A|$]]|$1|L|3|M|5|K|7|1G|8|@]|9|@]|A|$]]|$1|N|3|O|5|K|7|1H|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1K|8|@]|9|@$D|1L|E|1M|1|1N]]|A|$]]|$1|U|3|V|5|6|7|1O|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1P|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

About your first question...

List, Map and Set serve different purposes. I suggest reading about the Java Collections Framework at <a href="http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html" rel="noreferrer">http://java.sun.com/docs/books/tutorial/collections/interfaces/index.html</a>.

To be a bit more concrete:

<ul>
<li>use List if you need an array-like data structure and you need to iterate over the elements</li>
<li>use Map if you need something like a dictionary</li>
<li>use a Set if you only need to decide if something belongs to the set or not.</li>
</ul>

About your second question...

The main difference between Vector and ArrayList is that the former is synchronized, the latter is not synchronized. You can read more about synchronization in <a href="https://rads.stackoverflow.com/amzn/click/com/0321349601" rel="noreferrer" rel="nofollow noreferrer">Java Concurrency in Practice</a>.

The difference between Hashtable (note that the T is not a capital letter) and HashMap is similiar, the former is synchronized, the latter is not synchronized.

I would say that there are no rule of thumb for preferring one implementation or another, it really depends on your needs.

blocks|key|2940372|text|我总是在案例的基础上根据用例做出这些决定，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2940373|2940374|我需要保留排序吗？|unordered-list-item|2940375|我是否会有空键/值？Dups？|2940376|是否会被多线程访问|2940377|我是否需要键/值对|2940378|我是否需要随机访问？|2940379|2940380|然后我用一个简单的拿出了我方便的第5版Java，并比较了大约20个选项。它在第五章中有一些很好的小表格来帮助人们找出什么是合适的。|offset|length|style|BOLD|2940381|好吧，也许如果我即兴知道一个简单的ArrayList或HashSet就可以做到这一点，我就不会全部去查了。;)但是，如果关于我的延迟使用有任何一点复杂的东西，你可以打赌我在书中。顺便说一句，我认为Vector应该是“老式的”--我已经很多年没有用过了。|2940382|entityMap^0|0|0|0|0|0|0|0|0|J|1A|0|0|3I|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|14|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@$Q|17|R|18|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@$Q|1A|R|1B|S|T]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|X|$]]

I've always made those decisions on a case by case basis, depending on the use case, such as:

<ul>
<li>Do I need the ordering to remain?</li>
<li>Will I have null key/values? Dups?</li>
<li>Will it be accessed by multiple threads</li>
<li>Do I need a key/value pair</li>
<li>Will I need random access?</li>
</ul>

And then I break out my handy 5th edition Java in a Nutshell and compare the ~20 or so options. It has nice little tables in Chapter five to help one figure out what is appropriate. 

Ok, maybe if I know off the cuff that a simple ArrayList or HashSet will do the trick I won't look it all up. ;) but if there is anything remotely complex about my indended use, you bet I'm in the book. BTW, I though Vector is supposed to be 'old hat'--I've not used on in years.

blocks|key|3785291|text|List允许重复项，而Set只允许一个实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3785292|每当我需要执行查找时，我都会使用Map。|3785293|对于特定的实现，有保留顺序的Map和Set的变体，但很大程度上取决于速度。我倾向于将ArrayList用于相当小的列表，HashSet用于相当小的集合，但有许多实现(包括您自己编写的任何实现)。HashMap对于Map来说是非常常见的。任何超过“合理的小”，你必须开始担心内存，所以这将是更具体的算法。|3785294|如果你对硬数字感兴趣，This+page有很多动画图像的lots，以及测试LinkedList和ArrayList的示例代码。|offset|length|style|BOLD|3785295|EDIT:我希望下面的链接说明这些东西实际上只是工具箱中的项目，你只需要考虑你的需求是什么:参见Map，List和Set的通用集合版本。|3785296|entityMap|0|LINK|mutability|MUTABLE|url|http://www.roseindia.net/javatutorials/linkedlistvsarraylist.shtml|1|http://commons.apache.org/collections/api-release/org/apache/commons/collections/map/package-summary.html|2|http://commons.apache.org/collections/api-release/org/apache/commons/collections/list/package-summary.html|3|http://commons.apache.org/collections/api-release/org/apache/commons/collections/set/package-summary.html^0|0|0|0|S|4|B|9|0|0|0|5|1C|3|1|1G|4|2|1L|3|3|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|14|8|@$H|15|I|16|J|K]]|9|@$H|17|I|18|1|19]]|A|$]]|$1|L|3|M|5|6|7|1A|8|@$H|1B|I|1C|J|K]]|9|@$H|1D|I|1E|1|1F]|$H|1G|I|1H|1|1I]|$H|1J|I|1K|1|1L]]|A|$]]|$1|N|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]|V|$5|Q|R|S|A|$T|W]]|X|$5|Q|R|S|A|$T|Y]]|Z|$5|Q|R|S|A|$T|10]]]]

Lists allow duplicate items, while Sets allow only one instance.

I'll use a Map whenever I'll need to perform a lookup.

For the specific implementations, there are order-preserving variations of Maps and Sets but largely it comes down to speed. I'll tend to use ArrayList for reasonably small Lists and HashSet for reasonably small sets, but there are many implementations (including any that you write yourself). HashMap is pretty common for Maps. Anything more than 'reasonably small' and you have to start worrying about memory so that'll be way more specific algorithmically.

<a href="http://www.roseindia.net/javatutorials/linkedlistvsarraylist.shtml" rel="nofollow noreferrer">This page</a> has lots of animated images along with sample code testing LinkedList vs. ArrayList if you're interested in hard numbers.

EDIT: I hope the following links demonstrate how these things are really just items in a toolbox, you just have to think about what your needs are: See Commons-Collections versions of <a href="http://commons.apache.org/collections/api-release/org/apache/commons/collections/map/package-summary.html" rel="nofollow noreferrer">Map</a>, <a href="http://commons.apache.org/collections/api-release/org/apache/commons/collections/list/package-summary.html" rel="nofollow noreferrer">List</a> and <a href="http://commons.apache.org/collections/api-release/org/apache/commons/collections/set/package-summary.html" rel="nofollow noreferrer">Set</a>.

blocks|key|727591|text|我假设你从上面的答案中知道List，Set和Map之间的区别。为什么你会在他们的实现类之间做出选择是另一回事。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|727592|列表|offset|length|style|BOLD|727593|727594|ArrayList的检索速度很快，但插入速度很慢。对于读取大量数据但不会大量插入/删除的实现来说，这是很好的。它将数据保存在一个连续的内存块中，所以每次需要扩展时，它都会复制整个array.|ordered-list-item|727595|LinkedList，检索速度很慢，但插入速度很快。这对于插入/删除了很多东西但读起来不多的实现来说是很好的。它不会将整个数组保存在一个连续的内存块中。|727596|727597|集：|727598|727599|HashSet不保证迭代的顺序，因此是最快的集合。它有很高的开销，而且比ArrayList慢，所以你不应该使用它，除非当它的散列速度变得很快时，有大量的数据。factor.|727600|TreeSet保持了数据的有序性，因此比HashSet慢。|727601|727602|映射：+HashMap和TreeMap的性能和行为与Set实现是平行的。|727603|不应使用Vector和Hashtable。它们是同步实现，在发布新的Collection+hierarchy之前，因此速度很慢。如果需要同步，请使用Collections.synchronizedCollection()。|727604|entityMap^0|0|0|2|0|0|0|9|0|0|A|0|0|0|2|0|0|0|7|0|0|7|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|L|3|M|5|K|7|1A|8|@$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|R|3|S|5|K|7|1I|8|@$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|T|3|U|5|K|7|1L|8|@$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1P|8|@$D|1Q|E|1R|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1S|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|11|$]]

I'll assume you know the difference between a List, Set and Map from the above answers. Why you would choose between their implementing classes is another thing. For example:

List:

<ol>
<li>ArrayList is quick on retrieving, but slow on inserting. It's good for an implementation that reads a lot but doesn't insert/remove a lot. It keeps its data in one continuous block of memory, so every time it needs to expand, it copies the whole array.</li>
<li>LinkedList is slow on retrieving, but quick on inserting. It's good for an implementation that inserts/removes a lot but doesn't read a lot. It doesn't keep the entire array in one continuous block of memory.</li>
</ol>

Set:

<ol>
<li>HashSet doesn't guarantee the order of iteration, and therefore is fastest of the sets. It has high overhead and is slower than ArrayList, so you shouldn't use it except for a large amount of data when its hashing speed becomes a factor.</li>
<li>TreeSet keeps the data ordered, therefore is slower than HashSet.</li>
</ol>

Map: The performance and behavior of HashMap and TreeMap are parallel to the Set implementations.

Vector and Hashtable should not be used. They are synchronized implementations, before the release of the new Collection hierarchy, thus slow. If synchronization is needed, use Collections.synchronizedCollection().

blocks|key|3785347|text|我发现Bruce+Eckel的Java思想非常有帮助。他很好地比较了不同的收藏品。我过去经常保存他发布的一张图表，在我的立方体墙上显示继承继承人，作为快速参考。我建议你做的一件事是牢记线程的安全性。性能通常意味着线程不安全。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3785348|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|$]]

I found Bruce Eckel's Thinking in Java to be very helpful. He compares the different collections very well. I used to keep a diagram he published showing the inheritance heirachy on my cube wall as a quick reference. One thing I suggest you do is keep in mind thread safety. Performance usually means not thread safe.

blocks|key|3785404|text|对于非排序的最好选择，十有八九是:+ArrayList、HashMap、HashSet。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3785405|Vector和Hashtable是同步的，因此可能会慢一点。你很少会想要同步的实现，而且当你这样做的时候，它们的接口还不够丰富，所以它们的同步是有用的。在映射的情况下，ConcurrentMap添加了额外的操作来使接口有用。ConcurrentHashMap是ConcurrentMap的一个很好的实现。|3785406|LinkedList几乎从来都不是一个好主意。即使您正在执行大量的插入和删除操作，如果您使用索引来指示位置，则需要遍历列表以找到正确的节点。ArrayList几乎总是更快。|3785407|对于Map和Set，散列变量将比树/排序更快。散列算法往往具有O(1)的性能，而树的性能将是O(log+)。|3785408|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

For non-sorted the best choice, more than nine times out of ten, will be: ArrayList, HashMap, HashSet.

Vector and Hashtable are synchronised and therefore might be a bit slower. It's rare that you would want synchronised implementations, and when you do their interfaces are not sufficiently rich for thier synchronisation to be useful. In the case of Map, ConcurrentMap adds extra operations to make the interface useful. ConcurrentHashMap is a good implementation of ConcurrentMap.

LinkedList is almost never a good idea. Even if you are doing a lot of insertions and removal, if you are using an index to indicate position then that requires iterating through the list to find the correct node. ArrayList is almost always faster.

For Map and Set, the hash variants will be faster than tree/sorted. Hash algortihms tend to have O(1) performance, whereas trees will be O(log n).

blocks|key|2940751|text|从理论上讲，有一些有用的Big-Oh权衡，但在实践中，这些几乎都不重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2940752|在现实世界的基准测试中，即使使用大列表和“大量靠近前端的插入”这样的操作，ArrayList的性能也优于LinkedList。学者们忽略了这样一个事实，即真实算法具有可以压倒渐近曲线的恒定因素。例如，链表需要为每个节点分配额外的对象，这意味着创建节点的速度更慢，内存访问特性也更差。|style|CODE|2940753|我的规则是：|2940754|2940755|始终以ArrayList、HashSet和HashMap开头(即不是LinkedList或TreeMap)。|ordered-list-item|2940756|类型声明应该始终是一个接口(即List、Set、Map)，因此如果探查器或代码审查证明不是这样，您可以在不破坏任何内容的情况下更改实现。|2940757|2940758|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Big_O_notation^0|C|6|0|0|11|9|1G|A|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]|$A|15|B|16|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|17|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|19|8|@]|9|@]|C|$]]|$1|N|3|O|5|M|7|1A|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Theoretically there are useful <a href="http://en.wikipedia.org/wiki/Big_O_notation" rel="noreferrer">Big-Oh</a> tradeoffs, but in practice these almost never matter.

In real-world benchmarks, <code>ArrayList</code> out-performs <code>LinkedList</code> even with big lists and with operations like "lots of insertions near the front." Academics ignore the fact that real algorithms have constant factors that can overwhelm the asymptotic curve. For example, linked-lists require an additional object allocation for every node, meaning slower to create a node and vastly worse memory-access characteristics.

My rule is:

<ol>
<li>Always start with ArrayList and HashSet and HashMap (i.e. not LinkedList or TreeMap).</li>
<li>Type declarations should always be an interface (i.e. List, Set, Map) so if a profiler or code review proves otherwise you can change the implementation without breaking anything.</li>
</ol>

blocks|key|2940922|text|我真的很喜欢这篇来自Sergiy+Kovalchuk的blog+entry的小抄|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2940923|​|2940924|📷|atomic|2940925|2940926|更详细的是Alexander+Zagniotov的流程图，但不幸的是它是离线的。但是，Wayback+Machine有a+copy+of+the+blog|2940927|2940928|2940929|2940930|摘自博客中关于评论中提出的问题的摘录：“本小抄不包括很少使用的类，如WeakHashMap、LinkedList等，因为它们是为非常具体或奇异的任务而设计的，在99%25的情况下不应该选择它们。”|2940931|entityMap|0|LINK|mutability|MUTABLE|url|http://www.sergiy.ca/guide-to-selecting-appropriate-map-collection-in-java/|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/e353f22eb857b74326ddae5ed9605e47.gif|imageAlt|2|https://web.archive.org/web/20130424223516/http://initbinder.com/articles/cheat-sheet-for-selecting-maplistset-in-java.html|3|https://ask.qcloudimg.com/http-save/yehe-900000/741fe1d7babaad2165ad90f6d8c3b65b.png^0|R|A|0|0|0|0|1|1|0|0|1N|I|2|0|0|0|1|3|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|I|3|E|5|6|7|1H|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|L|3|E|5|6|7|1M|8|@]|9|@]|C|$]]|$1|M|3|G|5|H|7|1N|8|@]|9|@$A|1O|B|1P|1|1Q]]|C|$]]|$1|N|3|E|5|6|7|1R|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1S|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1T|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|Z|U|10|C|$11|12|13|-4]]|14|$5|T|U|V|C|$W|15]]|16|$5|Z|U|10|C|$11|17|13|-4]]]]

I really like this cheat sheet from Sergiy Kovalchuk's <a href="http://www.sergiy.ca/guide-to-selecting-appropriate-map-collection-in-java/" rel="nofollow noreferrer">blog entry</a>:
<img src="https://i.stack.imgur.com/EmzXy.gif" alt="Java Map/Collection Cheat Sheet" />
More detailed was Alexander Zagniotov's flowchart, but unfortunately it is offline. However, the Wayback Machine has <a href="https://web.archive.org/web/20130424223516/http://initbinder.com/articles/cheat-sheet-for-selecting-maplistset-in-java.html" rel="nofollow noreferrer">a copy of the blog</a>:
<a href="https://i.stack.imgur.com/GfpyN.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/GfpyN.png" alt="Alexander Zaniotov's flowchart for choosing Collection implementations" /></a>
Excerpt from the blog on concerns raised in comments:
&quot;This cheat sheet doesn't include rarely used classes like WeakHashMap, LinkedList, etc. because they are designed for very specific or exotic tasks and shouldn't be chosen in 99% cases.&quot;

blocks|key|2941013|text|正如在其他答案中所建议的那样，根据用例的不同，有不同的场景来使用正确的集合。我列出了几点，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2941014|ArrayList:|offset|length|style|BOLD|2941015|2941016|大多数情况下，你只需要存储或迭代“一堆东西”，然后再迭代它们。迭代速度更快，因为它的索引创建一个ArrayList，分配给它一个固定数量的内存，一旦超出，它就会复制整个数组|unordered-list-item|2941017|2941018|LinkedList:|2941019|2941020|它使用双向链表，因此插入和删除操作将很快，因为它只会添加或删除节点，速度很慢，因为它必须遍历节点。|2941021|2941022|HashSet:|2941023|2941024|对某一项目做出其他是非决定，例如“该项目是英语单词吗？”、“该项目是否在数据库中？”、“该项目是否属于该类别？”等。|2941025|2941026|2941027|记住“你已经处理了哪些项目”，例如在进行网络爬网时；|2941028|2941029|HashMap:|2941030|在需要说“对于给定的X，Y是什么”的情况下使用|2941031|？它通常用于实现内存中的缓存或索引，即键值对，例如:对于给定的用户ID，其缓存的名称/用户object?.|2941032|Always是什么?使用HashMap执行查找。|2941033|2941034|向量和哈希表是同步的，因此有点慢，如果需要同步，可以使用Collections.synchronizedCollection()。检查排序集合的This。希望这是真的。|2941035|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/18760752/difference-between-collections-sort-and-getting-a-sorted-collection-by-adding^0|0|0|A|0|0|0|0|0|B|0|0|0|0|0|8|0|0|0|0|0|0|0|0|8|0|0|0|0|0|20|4|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1M|8|@$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1Q|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1S|8|@$D|1T|E|1U|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]|$1|P|3|Q|5|K|7|1W|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1Y|8|@$D|1Z|E|20|F|G]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|V|3|W|5|K|7|22|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|Z|3|10|5|K|7|25|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|26|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|27|8|@$D|28|E|29|F|G]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2A|8|@]|9|@]|A|$]]|$1|16|3|17|5|K|7|2B|8|@]|9|@]|A|$]]|$1|18|3|19|5|K|7|2C|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2E|8|@]|9|@$D|2F|E|2G|1|2H]]|A|$]]|$1|1D|3|-4|5|6|7|2I|8|@]|9|@]|A|$]]]|1E|$1F|$5|1G|1H|1I|A|$1J|1K]]]]

As suggested in other answers, there are different scenarios to use correct collection depending on use case. I am listing few points,
ArrayList:
<ul>
<li>Most cases where you just need to store or iterate through a &quot;bunch of things&quot; and later iterate through them. Iterating is faster as its index based.</li>
<li>Whenever you create an ArrayList, a fixed amount of memory is allocated to it and once exceeded, it copies the whole array</li>
</ul>
LinkedList:
<ul>
<li>It uses doubly linked list so insertion and deletion operation will be fast as it will only add or remove a node.</li>
<li>Retrieving is slow as it will have to iterate through the nodes.</li>
</ul>
HashSet:
<ul>
<li>Making other yes-no decisions about an item, e.g. &quot;is the item a word of English&quot;, &quot;is the item in the database?&quot; , &quot;is the item in this category?&quot; etc.
</li>
<li>Remembering &quot;which items you've already processed&quot;, e.g. when doing a web crawl;
</li>
</ul>
HashMap:
<ul>
<li>Used in cases where you need to say &quot;for a given X, what is the Y&quot;? It is often useful for implementing in-memory caches or indexes i.e key value pairs For example:
For a given user ID, what is their cached name/User object?.</li>
<li>Always go with HashMap to perform a lookup.</li>
</ul>
Vector and Hashtable are synchronized and therefore bit slower and If synchronization is needed, use Collections.synchronizedCollection().
Check <a href="https://stackoverflow.com/questions/18760752/difference-between-collections-sort-and-getting-a-sorted-collection-by-adding">This</a> for sorted collections.
Hope this hepled.

blocks|key|2941125|text|嗯，这取决于你需要什么。一般的指导原则是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2941126|List是一个集合，其中数据按插入顺序保存，每个元素都有索引。|offset|length|style|BOLD|2941127|Set是一个没有重复的元素包(如果您重新插入相同的元素，它将不会被添加)。数据没有顺序的概念。|2941128|Map您可以通过数据元素的键来访问和写入数据元素，键可以是任何可能的对象。|2941129|​|2941130|📷|atomic|2941131|归属：https://stackoverflow.com/a/21974362/2811258|2941132|有关Java+Collections的更多信息，请访问check+out+this+article。|2941133|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/08ca2e0b44d42404cd6628021666f834.png|imageAlt|1|LINK|MUTABLE|url|https://stackoverflow.com/a/21974362/2811258|2|https://javatutorial.net/java-collection-tutorial^0|0|0|4|0|0|3|0|0|3|0|0|0|1|0|0|3|18|1|0|R|M|2|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1H|8|@$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1K|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1L|8|@]|9|@$D|1M|E|1N|1|1O]]|A|$]]|$1|Q|3|R|5|6|7|1P|8|@]|9|@$D|1Q|E|1R|1|1S]]|A|$]]|$1|S|3|T|5|6|7|1T|8|@]|9|@$D|1U|E|1V|1|1W]]|A|$]]|$1|U|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11|12|-4]]|13|$5|14|Y|15|A|$16|17]]|18|$5|14|Y|15|A|$16|19]]]]

Well, it depends on what you need. The general guidelines are:

List is a collection where data is kept in order of insertion and each element got index.

Set is a bag of elements without duplication (if you reinsert the same element, it won't be added). Data doesn't have the notion of order.

Map You access and write your data elements by their key, which could be any possible object.

<a href="https://i.stack.imgur.com/0g5VZ.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/0g5VZ.png" alt="enter image description here"></a>
Attribution: <a href="https://stackoverflow.com/a/21974362/2811258">https://stackoverflow.com/a/21974362/2811258</a>

For more information about Java Collections, <a href="https://javatutorial.net/java-collection-tutorial" rel="nofollow noreferrer">check out this article</a>.

blocks|key|5196558|text|使用Map进行键值配对|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5196559|对于key-value跟踪，请使用Map实现。|5196560|例如，跟踪哪个人正在报道周末的哪一天。因此，我们希望将一个DayOfWeek对象映射到一个Employee对象。|5196561|Map+<+DayOfWeek+,+Employee+>+weekendWorker+=+
++++Map.of(+
++++++++DayOfWeek.SATURDAY+,+alice+,
++++++++DayOfWeek.SUNDAY+,+bob
++++)
;|code-block|syntax|javascript|5196562|在选择Map实现之一时，有几个方面需要考虑。这些包括:并发性，对键和/或值中空值的容忍度，迭代键时的顺序，通过引用跟踪与内容跟踪，以及文字语法的便利性。|5196563|下面是我制作的一个图表，显示了与Java11捆绑在一起的10个Map实现中的每一个的各个方面。|5196564|​|5196565|📷|atomic|5196566|5196567|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Attribute%25E2%2580%2593value_pair|1|https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html|2|https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/DayOfWeek.html|3|4|5|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/584ecdcb8d0139418fe045365790ed91.png|imageAlt^0|2|3|0|H|3|2|9|0|H|3|1|0|T|9|19|8|T|9|2|0|0|3|3|3|3|3|0|V|3|V|3|4|0|0|0|1|5|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@$9|1O|A|1P|1|1Q]|$9|1R|A|1S|1|1T]]|E|$]]|$1|H|3|I|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@$9|1Z|A|20|1|21]]|E|$]]|$1|J|3|K|5|L|7|22|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|23|8|@$9|24|A|25|B|C]]|D|@$9|26|A|27|1|28]]|E|$]]|$1|Q|3|R|5|6|7|29|8|@$9|2A|A|2B|B|C]]|D|@$9|2C|A|2D|1|2E]]|E|$]]|$1|S|3|T|5|6|7|2F|8|@]|D|@]|E|$]]|$1|U|3|V|5|W|7|2G|8|@]|D|@$9|2H|A|2I|1|2J]]|E|$]]|$1|X|3|T|5|6|7|2K|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]|16|$5|11|12|13|E|$14|17]]|18|$5|11|12|13|E|$14|19]]|1A|$5|11|12|13|E|$14|17]]|1B|$5|11|12|13|E|$14|17]]|1C|$5|1D|12|1E|E|$1F|1G|1H|-4]]]]

<h1>Use <code>Map</code> for key-value pairing</h1>

For <a href="https://en.wikipedia.org/wiki/Attribute%E2%80%93value_pair" rel="nofollow noreferrer">key-value</a> tracking, use <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" rel="nofollow noreferrer"><code>Map</code></a> implementation.

For example, tracking which person is covering which day of the weekend. So we want to map a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/DayOfWeek.html" rel="nofollow noreferrer"><code>DayOfWeek</code></a> object to an <code>Employee</code> object.

<pre><code>Map &lt; DayOfWeek , Employee &gt; weekendWorker = 
 Map.of( 
 DayOfWeek.SATURDAY , alice ,
 DayOfWeek.SUNDAY , bob
 )
;
</code></pre>

When choosing one of the <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" rel="nofollow noreferrer"><code>Map</code></a> implementations, there are several aspects to consider. These include: concurrency, tolerance for NULL values in key and/or value, order when iterating keys, tracking by reference versus content, and convenience of literals syntax.

Here is a chart I made showing the various aspects of each of the ten <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" rel="nofollow noreferrer"><code>Map</code></a> implementations bundled with Java 11.

<a href="https://i.stack.imgur.com/ThFKw.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/ThFKw.png" alt="Table of map implementations in Java 11, comparing their features"></a>

Anyone have a good rule of thumb for choosing between different implementations of Java Collection interfaces like List, Map, or Set?

For example, generally why or in what cases would I prefer to use a Vector or an ArrayList, a Hashtable or a HashMap?

Rule of thumb for choosing an implementation of a Java Collection?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有人有一个好的经验法则，可以在不同的Java Collection接口实现之间进行选择，比如List、Map或Set？例如，通常我为什么或在什么情况下更喜欢使用向量、ArrayList、Hashtable或HashMap？

问选择Java集合实现的经验法则？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问选择Java集合实现的经验法则？EN