blocks|key|1589136|text|如果你事先知道数据有多大，那么数组会更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589137|列表更加灵活。您可以使用由数组支持的ArrayList。|1589138|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|$]]

If you know in advance how large the data is then an array will be faster.

A List is more flexible. You can use an ArrayList which is backed by an array.

blocks|key|1589224|text|不，因为从技术上讲，数组只存储对字符串的引用。字符串本身被分配到不同的位置。对于一千个项目，我会说列表会更好，它更慢，但它提供了更多的灵活性，更容易使用，特别是如果你要调整它们的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589225|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|$]]

No, because technically, the array only stores the reference to the strings. The strings themselves are allocated in a different location. For a thousand items, I would say a list would be better, it is slower, but it offers more flexibility and it's easier to use, especially if you are going to resize them.

blocks|key|1589257|text|list比arrays.If慢，你需要高效使用arrays.If，你需要灵活使用list。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589258|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|$]]

list is slower than arrays.If you need efficiency use arrays.If you need flexibility use list.

blocks|key|1589289|text|列表更灵活……所以列表比数组更好|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589290|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|$]]

A List is more flexible.... so better to List than array

blocks|key|1374224|text|如果没有适当的基准测试，不要陷入优化的陷阱。正如其他人所建议的那样，在进行任何假设之前，请使用分析器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1374225|您列举的不同数据结构有不同的用途。list在开始和结尾插入元素时非常有效，但在访问随机元素时会受到很大影响。阵列具有固定的存储空间，但提供快速的随机访问。最后，ArrayList通过允许数组的增长改进了数组的接口。通常，要使用的数据结构应该由如何访问或添加存储的数据来决定。|1374226|关于内存消耗。你好像把一些东西混在一起了。一个数组只会为你所拥有的数据类型提供一个连续的内存块。不要忘记java有一个固定的数据类型:+boolean、char、int、long、float和Object+(这包括所有对象，甚至一个数组也是一个对象)。这意味着如果你声明一个字符串数组1000或MyObject+myObjects+1000，你只能得到1000个足以存储对象位置(引用或指针)的内存盒。你不会得到足够大的1000个内存盒来容纳对象的大小。别忘了你的对象首先是用"new“创建的。这是当内存分配完成之后，一个引用(它们的内存地址)被存储在数组中。对象不会被复制到数组中，只是它的引用。|1374227|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Don't get into the trap of optimizing without proper benchmarking. As others have suggested use a profiler before making any assumption.

The different data structures that you have enumerated have different purposes. A list is very efficient at inserting elements in the beginning and at the end but suffers a lot when accessing random elements. An array has fixed storage but provides fast random access. Finally an ArrayList improves the interface to an array by allowing it to grow. Normally the data structure to be used should be dictated by how the data stored will be access or added.

About memory consumption. You seem to be mixing some things. An array will only give you a continuous chunk of memory for the type of data that you have. Don't forget that java has a fixed data types: boolean, char, int, long, float and Object (this include all objects, even an array is an Object). It means that if you declare an array of String strings [1000] or MyObject myObjects [1000] you only get a 1000 memory boxes big enough to store the location (references or pointers) of the objects. You don't get a 1000 memory boxes big enough to fit the size of the objects. Don't forget that your objects are first created with "new". This is when the memory allocation is done and later a reference (their memory address) is stored in the array. The object doesn't get copied into the array only it's reference.

blocks|key|1589440|text|“数千”不是一个很大的数字。几千个段落长度的字符串的大小约为几兆字节。如果你想做的就是串行地访问它们，那就使用an+immutable+singly-linked+List。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1589441|entityMap|0|LINK|mutability|MUTABLE|url|http://www.functionaljava.org/javadoc/4.5/functionaljava/fj/data/List.html^0|1J|V|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]]]]

"Thousands" is not a large number. A few thousand paragraph-length strings are on the order of a couple of megabytes in size. If all you want to do is access these serially, use <a href="http://www.functionaljava.org/javadoc/4.5/functionaljava/fj/data/List.html" rel="nofollow noreferrer">an immutable singly-linked List</a>.

blocks|key|1374365|text|请记住，ArrayList封装了一个数组，因此与使用原始数组相比没有什么不同(除了在java中使用List要容易得多)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1374366|几乎唯一有意义的情况是，在存储原语时，优先选择数组而不是ArrayList，即字节、整数等，并且需要通过使用原语数组获得的空间效率。|1374367|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|$]]

Remember that an ArrayList encapsulates an array, so there is little difference compared to using a primitive array (except for the fact that a List is much easier to work with in java).

The pretty much the only time it makes sense to prefer an array to an ArrayList is when you are storing primitives, i.e. byte, int, etc and you need the particular space-efficiency you get by using primitive arrays.

blocks|key|1589601|text|我猜最初的海报来自于C%2B%2B/STL背景，这造成了一些混乱。在C%2B%2B中，std::list是一个双向链表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1589602|在Java语言中，[java.util.]List是一个无需实现的接口(+C%2B%2B术语中的纯抽象类)。List可以是一个双向链表-提供了java.util.LinkedList。然而，当你想创建一个新的List时，有99次你想要改用java.util.ArrayList，这大致相当于C%2B%2B+std::vector。还有其他的标准实现，比如由java.util.Collections.emptyList()和java.util.Arrays.asList()返回的那些。|1589603|从性能的角度来看，必须通过一个接口和一个额外的对象会有很小的影响，然而运行时内联意味着这几乎没有任何意义。还要记住，String通常是一个对象加数组。因此，对于每个条目，您可能有另外两个对象。在C%2B%2B+std::vector<std::string>中，尽管按值复制时没有这样的指针，但字符数组将形成字符串的对象(这些对象通常不会共享)。|1589604|如果这段代码对性能非常敏感，那么可以为所有字符串的所有字符创建一个char[]数组(甚至是byte[])，然后创建一个偏移量数组。IIRC，这就是javac的实现方式。|1589605|entityMap^0|Z|9|0|9|G|1E|4|1V|K|2S|4|37|J|41|B|4Q|X|5O|P|0|1M|6|2T|O|0|X|6|19|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$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]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|M|$]]

I'm guessing the original poster is coming from a C++/STL background which is causing some confusion. In C++ <code>std::list</code> is a doubly linked list.

In Java <code>[java.util.]List</code> is an implementation-free interface (pure abstract class in C++ terms). <code>List</code> can be a doubly linked list - <code>java.util.LinkedList</code> is provided. However, 99 times out of 100 when you want a make a new <code>List</code>, you want to use <code>java.util.ArrayList</code> instead, which is the rough equivalent of C++ <code>std::vector</code>. There are other standard implementations, such as those returned by <code>java.util.Collections.emptyList()</code> and <code>java.util.Arrays.asList()</code>.

From a performance standpoint there is a very small hit from having to go through an interface and an extra object, however runtime inlining means this rarely has any significance. Also remember that <code>String</code> are typically an object plus array. So for each entry, you probably have two other objects. In C++ <code>std::vector&lt;std::string&gt;</code>, although copying by value without a pointer as such, the character arrays will form an object for string (and these will not usually be shared).

If this particular code is really performance-sensitive, you could create a single <code>char[]</code> array (or even <code>byte[]</code>) for all the characters of all the strings, and then an array of offsets. IIRC, this is how javac is implemented.

blocks|key|1589627|text|阵列速度更快-所有内存都是预先分配的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589628|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|$]]

Array is faster - all memory is pre-allocated in advance.

blocks|key|1589703|text|如果你有数千个，考虑使用trie。trie是一种树状结构，它合并了存储字符串的公共前缀。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589704|例如，如果字符串是|1589705|intern
international
internationalize
internet
internets|code-block|syntax|javascript|1589706|trie将存储：|1589707|intern
+->+\0
+international
+->+\0
+->+ize\0
+net
+->\0
+->s\0|1589708|字符串需要57个字符(包括空终止符'\0')进行存储，外加保存它们的String对象的大小。(事实上，我们可能应该将所有大小四舍五入到16的倍数，但是...)粗略地称其为57+%2B5=+62字节。|1589709|trie需要29个(包括空终止符'\0')用于存储，加上trie节点的大小，这是对一个数组和一个子trie节点列表的引用。|1589710|对于这个例子，这可能是相同的；对于数千人来说，只要你有共同的前缀，它可能就会变得更少。|1589711|现在，当在其他代码中使用trie时，您必须转换为字符串，可能需要使用StringBuffer作为中介。如果许多字符串同时作为字符串在trie之外使用，这是一种损失。|1589712|但是，如果您当时只使用了几个--比方说，在字典中查找单词--+trie可以为您节省大量空间。绝对比在HashSet中存储它们的空间要小。|1589713|你说你“连续”地访问它们--如果这意味着按字母顺序，那么trie显然也会免费给你字母顺序，如果你先深度迭代它的话。|1589714|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

If you have thousands, consider using a trie. A trie is a tree-like structure that merges the common prefixes of the stored string.

For example, if the strings were 

<pre><code>intern
international
internationalize
internet
internets
</code></pre>

The trie would store:

<pre><code>intern
 -&gt; \0
 international
 -&gt; \0
 -&gt; ize\0
 net
 -&gt;\0
 -&gt;s\0
</code></pre>

The strings requires 57 characters (including the null terminator, '\0') for storage, plus whatever the size of the String object that holds them. (In truth, we should probably round all sizes up to multiples of 16, but...) Call it 57 + 5 = 62 bytes, roughly.

The trie requires 29 (including the null terminator, '\0') for storage, plus sizeof the trie nodes, which are a ref to an array and a list of child trie nodes.

For this example, that probably comes out about the same; for thousands, it probably comes out less as long as you do have common prefixes.

Now, when using the trie in other code, you'll have to convert to String, probably using a StringBuffer as an intermediary. If many of the strings are in use at once as Strings, outside the trie, it's a loss.

But if you're only using a few at the time -- say, to look up things in a dictionary -- the trie can save you a lot of space. Definitely less space than storing them in a HashSet.

You say you're accessing them "serially" -- if that means sequentially an alphabetically, the trie also obviously gives you alphabetical order for free, if you iterate it depth-first.

blocks|key|1589749|text|具体取决于实现方式。基元类型的数组可能会比ArrayList更小、更有效。这是因为数组将值直接存储在连续的内存块中，而最简单的ArrayList实现将存储指向每个值的指针。特别是在64位平台上，这可能会产生巨大的差异。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589750|当然，对于这种情况，jvm实现也可能有一个特殊情况，在这种情况下，性能将是相同的。|1589751|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|$]]

Depending on the implementation. it's possible that an array of primitive types will be smaller and more efficient than ArrayList. This is because the array will store the values directly in a contiguous block of memory, while the simplest ArrayList implementation will store pointers to each value. On a 64-bit platform especially, this can make a huge difference.

Of course, it's possible for the jvm implementation to have a special case for this situation, in which case the performance will be the same.

blocks|key|1374551|text|这取决于您必须如何访问它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1374552|在存储之后，如果你主要想做搜索操作，只需要很少的插入/删除操作，那么就去找数组(因为搜索是在数组中的O(1)中完成的，而添加/删除可能需要重新排序元素)。|1374553|在存储之后，如果你的主要目的是添加/删除字符串，只有很少的搜索操作或没有搜索操作，那么去List。|1374554|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It depends on how you have to access it.

After storing, if you mainly want to do search operation, with little or no insert/delete, then go for Array (as search is done in O(1) in arrays, whereas add/delete may need re-ordering of the elements).

After storing, if your main purpose is to add/delete strings, with little or no search operation, then go for List.

blocks|key|1589791|text|如果你可以接受一个固定的大小，数组将会更快，并且需要更少的内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589792|如果您需要添加和删除元素的List接口的灵活性，那么问题仍然是您应该选择哪种实现。通常建议在任何情况下都使用ArrayList，但如果必须删除或插入列表开头或中间的元素，ArrayList也会出现性能问题。|1589793|因此，您可能想看看引入GapList的http://java.dzone.com/articles/gaplist-%25E2%2580%2593-lightning-fast-list。这种新的list实现结合了ArrayList和LinkedList的优点，为几乎所有操作带来了非常好的性能。|offset|length|1589794|entityMap|0|LINK|mutability|MUTABLE|url|http://java.dzone.com/articles/gaplist-%25E2%2580%2593-lightning-fast-list^0|0|0|J|1W|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

It you can live with a fixed size, arrays will will be faster and need less memory.

If you need the flexibility of the List interface with adding and removing elements, the question remains which implementation you should choose. Often ArrayList is recommended and used for any case, but also ArrayList has its performance problems if elements at the beginning or in the middle of the list must be removed or inserted.

You therefore may want to have a look at <a href="http://java.dzone.com/articles/gaplist-%E2%80%93-lightning-fast-list" rel="nofollow">http://java.dzone.com/articles/gaplist-%E2%80%93-lightning-fast-list</a> which introduces GapList. This new list implementation combines the strengths of both ArrayList and LinkedList resulting in very good performance for nearly all operations.

blocks|key|1374592|text|List是java1.5及更高版本的首选方式，因为它可以使用泛型。数组不能有泛型。另外，数组有一个预定义的长度，不能动态增长。初始化一个大尺寸的数组不是一个好主意。ArrayList是使用泛型声明数组的方法，它可以动态增长。但是如果delete和insert的使用频率更高，那么链表就是最快的数据结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1374593|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|$]]

List is the preferred way in java 1.5 and beyond as it can use generics. Arrays cannot have generics. Also Arrays have a pre defined length, which cannot grow dynamically. Initializing an array with a large size is not a good idea.
ArrayList is the the way to declare an array with generics and it can dynamically grow.
But if delete and insert is used more frequently, then linked list is the fastest data structure to be used.

blocks|key|1374612|text|建议在任何地方使用数组，而不是列表，特别是在你知道项的数量和大小不会改变的情况下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1374613|请参阅Oracle+Java最佳实践：http://docs.oracle.com/cd/A97688_16/generic.903/bp/java.htm#1007056|offset|length|1374614|当然，如果您需要多次从集合中添加和删除对象，请使用易用列表。|1374615|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/cd/A97688_16/generic.903/bp/java.htm#1007056^0|0|J|1V|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Arrays recommended everywhere you may use them instead of list, especially in case if you know items count and size would not be changing. 

See Oracle Java best practice: <a href="http://docs.oracle.com/cd/A97688_16/generic.903/bp/java.htm#1007056" rel="nofollow">http://docs.oracle.com/cd/A97688_16/generic.903/bp/java.htm#1007056</a>

Of course, if you need add and remove objects from collection many times easy use lists.

blocks|key|1374648|text|这里给出的许多微基准测试发现，数组/ArrayList读取的时间为几纳秒。如果所有内容都在L1缓存中，这是非常合理的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1374649|更高级别的缓存或主存访问可以具有类似10nS-100nS的数量级，而对于L1缓存，则更像是1nS。访问ArrayList有额外的内存间接性，在实际的应用程序中，根据代码在两次访问之间所做的事情，您可能会付出任何代价，从几乎从不到每次都是如此。当然，如果你有很多小的ArrayLists，这可能会增加你的内存使用，并使你更有可能有缓存未命中。|1374650|原始的海报似乎只使用了一个，并且在短时间内访问了很多内容，所以应该不会有太大的困难。但对于其他人来说可能会有所不同，在解释微基准时应该小心。|1374651|然而，Java+string是非常浪费的，特别是当您存储大量小字符串时(只要用内存分析器查看它们，对于几个字符的字符串，它似乎大于60个字节)。一个字符串数组间接指向String对象，另一个间接指向包含字符串本身的char[]。如果有什么东西要炸掉你的L1缓存的话，那就是这个，再加上成千上万的字符串。所以，如果你是认真的-真的认真的-要尽可能多地提高性能，那么你可以考虑用不同的方式来做。比方说，您可以保存两个数组，一个包含所有字符串的char[]一个接一个，另一个int[]包含到开头的偏移量。这将是一个可以用来做任何事情的PITA，而且几乎可以肯定你不需要它。如果你这样做了，你就选择了错误的语言。|1374652|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|$]]

A lot of microbenchmarks given here have found numbers of a few nanoseconds for things like array/ArrayList reads. This is quite reasonable if everything is in your L1 cache.

A higher level cache or main memory access can have order of magnitude times of something like 10nS-100nS, vs more like 1nS for L1 cache. Accessing an ArrayList has an extra memory indirection, and in a real application you could pay this cost anything from almost never to every time, depending on what your code is doing between accesses. And, of course, if you have a lot of small ArrayLists this might add to your memory use and make it more likely you'll have cache misses.

The original poster appears to be using just one and accessing a lot of contents in a short time, so it should be no great hardship. But it might be different for other people, and you should watch out when interpreting microbenchmarks.

Java Strings, however, are appallingly wasteful, especially if you store lots of small ones (just look at them with a memory analyzer, it seems to be > 60 bytes for a string of a few characters). An array of strings has an indirection to the String object, and another from the String object to a char[] which contains the string itself. If anything's going to blow your L1 cache it's this, combined with thousands or tens of thousands of Strings. So, if you're serious - really serious - about scraping out as much performance as possible then you could look at doing it differently. You could, say, hold two arrays, a char[] with all the strings in it, one after another, and an int[] with offsets to the starts. This will be a PITA to do anything with, and you almost certainly don't need it. And if you do, you've chosen the wrong language.

blocks|key|1589902|text|数组-当我们必须实现更快的结果获取时，它总是更好|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589903|列表-执行插入和删除的结果，因为它们可以在O(1)中完成，这也提供了轻松添加、获取和删除数据的方法。使用起来容易多了。|1589904|但请始终记住，当存储数据的数组中的索引位置已知时，获取数据的速度会更快。|1589905|这可以通过对数组进行排序来很好地实现。因此，这增加了获取数据的时间(即，存储数据%2B排序数据%2B查找找到数据的位置)。因此，这增加了从数组获取数据的额外延迟，即使它们可能擅长更快地获取数据。|1589906|因此，这可以用trie数据结构或三元数据结构来解决。如上所述，trie数据结构在搜索数据方面将非常有效，对特定单词的搜索可以在O(1)量级上完成。当时间很重要时，例如，如果你必须快速搜索和检索数据，你可以使用trie数据结构。|1589907|如果你想要你的内存空间消耗更少，并且你希望有更好的性能，那么就使用三元数据结构。这两种方法都适用于存储大量的字符串(例如，字典中包含的单词)。|1589908|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Arrays - It would always be better when we have to achieve faster fetching of results

Lists- Performs results on insertion and deletion since they can be done in O(1) and this also provides methods to add, fetch and delete data easily. Much easier to use.

But always remember that the fetching of data would be fast when the index position in array where the data is stored - is known. 

This could be achieved well by sorting the array. Hence this increases the time to fetch the data (ie; storing the data + sorting the data + seek for the position where the data is found). Hence this increases additional latency to fetch the data from the array even they may be good at fetching the data sooner.

Hence this could be solved with trie data structure or ternary data structure. As discussed above the trie data structure would be very efficient in searching for the data the search for a particularly word can be done in O(1) magnitude. When time matters ie; if you have to search and retrieve data quickly you may go with trie data structure. 

If you want your memory space to be consumed less and you wish to have a better performance then go with ternary data structure. Both these are suitable for storing huge number of strings (eg; like words contained in dictionary).

blocks|key|1589976|text|使用哪一个取决于问题。我们需要看看大O。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1589977|​|1589978|📷|atomic|offset|length|1589979|1589980|图片来源：https://github.com/egonSchiele/grokking_algorithms|1589981|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/77c8a4012e4d9509a8b1eaabd0c4bcb4.png|imageAlt|1|LINK|MUTABLE|url|https://github.com/egonSchiele/grokking_algorithms^0|0|0|0|1|0|0|0|5|1E|1|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@$G|12|H|13|1|14]]|A|$]]|$1|I|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@$G|17|H|18|1|19]]|A|$]]|$1|L|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S|T|-4]]|U|$5|V|P|W|A|$X|Y]]]]

Which one to use depends on the problem. We need to look at the Big O.
<a href="https://i.stack.imgur.com/kQ9c5.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/kQ9c5.png" alt="Big O Values of List and Array" /></a>
image source: <a href="https://github.com/egonSchiele/grokking_algorithms" rel="nofollow noreferrer">https://github.com/egonSchiele/grokking_algorithms</a>

I have to keep thousands of strings in memory to be accessed serially in Java. Should I store them in an array or should I use some kind of List ?

Since arrays keep all the data in a contiguous chunk of memory (unlike Lists), would the use of an array to store thousands of strings cause problems ?

Array or List in Java. Which is faster?

数据结构

Java

我必须在内存中保存数千个字符串，以便在Java中串行访问。我应该将它们存储在数组中，还是应该使用某种列表？由于数组将所有数据保存在一个连续的内存块中(与列表不同)，因此使用一个数组来存储数千个字符串会导致问题吗？

问Java中的数组或列表。哪个更快？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的数组或列表。哪个更快？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的数组或列表。哪个更快？
EN