blocks|key|5365845|text|使用链表可以实现一个像数组一样工作的对象。与数组相比，有些操作会更快，有些会更慢。例如，对于接近末尾的元素，使用链表调用get()的速度可能比使用数组慢得多。但是，这仍然是可能的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5365846|另一方面，从链表的中间删除元素将比使用数组完成的相应操作更快。|5365847|entityMap^0|1O|5|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

It is possible to implement an object that works like an array, using a linked list. Compared to arrays, some operations will be faster and some will be slower. For example, calling <code>get()</code> for an element near the end might be quite a lot slower with a linked list than with an array. But, it's still possible.

On the other hand, deleting an element from the middle of a linked list will be faster than the corresponding operation done using arrays.

blocks|key|5081304|text|LinkedList是一个实体链，其中每个实体都知道next-one，因此get(索引)操作需要使用计数器在这个链上迭代。但是这个列表针对按位置添加和删除进行了优化(当我需要将元素放入列表中或从中间链表中删除元素时，效果会更好)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5081305|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|$]]

LinkedList is a chain of entities in which every entity knows about next-one,
so get(index) operation requires iterating over this chain with counter.
But this list optimized for adding and deleting by position (in case when I need to put element inside list or delete element from middle linked list performs better)

blocks|key|5365918|text|不怎么有意思。链表是由集合提供的，通过良好的设计，您可以创建一个双向链表。现在它不像数组，因为这些对象没有索引，也不是容器中的元素，即list。因此，您需要定义下一步和前一步，并指定下一步是什么。它们都有相同的方法，因为正如我所说的，它们又是集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5365919|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|$]]

Not really. Linked list is provided by the collection and by good design you could create a double linked list. Now it is not like array because these objects will not have indexes and are not elements within the container i.e. list. Hence you go through defining the next and previous and dictate what the next move is. They all have the same methods because again they are collections like i said.

blocks|key|962822|text|在内部，它将使用所谓的“板片分配器”--这基本上是一个小数组的链表。每次添加对象时，它都会检查楼板中是否有空间，如果有，则将对象放在那里。否则，它将分配一个新的板，并将对象放在板的第一个元素中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962823|这种技术最大限度地减少了内存分配开销--如果您向链表中添加了很多项，那么这将是大量占用大量时间的小内存分配，而slab分配器会将其最小化|962824|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|$]]

Internally it will be using what is called a 'slab allocator' -- this is basically a linked list of small arrays. Each time you add an object, it checks if there is space in the slab, and if so, puts the object there. Otherwise, it allocates a new slab and puts the object in the first element of the slab. 

This technique minimizes memory allocation overheads -- if you add a lot of items to a linked list, that would be a lot of small memory allocations which take a lot of time, and the slab allocators minimize that

blocks|key|5081388|text|那么，LinkedList在内部是一个类似数组的序列吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5081389|5081390|不是的。它是一个私有嵌套类Entry的一系列实例，其中包含next、previous和element引用。请注意，您可以通过查看JDK附带的源代码来了解这一点。|offset|length|style|CODE|5081391|这种内部结构不暴露的原因是它防止了结构被破坏，例如包含循环。并且通过List和Deque接口的统一访问允许多态使用。|5081392|entityMap^0|0|0|D|5|T|4|Y|8|17|7|0|Y|4|13|5|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|6|7|O|8|@$E|P|F|Q|G|H]|$E|R|F|S|G|H]|$E|T|F|U|G|H]|$E|V|F|W|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@$E|Y|F|Z|G|H]|$E|10|F|11|G|H]]|9|@]|A|$]]|$1|K|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|L|$]]

<blockquote>
 So, is LinkedList internally an array-like sequence?
</blockquote>

No. It's a series of instances of a private nested class <code>Entry</code>, which has <code>next</code>, <code>previous</code> and <code>element</code> references. Note that you could have found this out yourself by looking at the source code, which comes with the JDK. 

The reason why this internal structure is not exposed is that it prevents the structure from becoming corrupted and e.g. containing a loop. And the uniform access via the <code>List</code> and <code>Deque</code> interfaces allows polymorphic use.

blocks|key|965920|text|据我所知，linkedlist就像你在第一段中说的那样。每个对象都有两个引用，称为它的前一个和下一个。与按顺序工作的数组不同(在C语言中，它是按顺序存储的。我认为java做同样的事情，这就是为什么我们不能调整数组的大小)，list是通过引用来工作的。因此，从逻辑上讲，它的工作速度比数组慢。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|965921|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|$]]

as i know linkedlist is like what you said in the first paragraph. each object has two references, called it's previous and it's next.
unlike array which works sequentially (in C it's exactly stored in sequence. i think java just does the same, that's why we can't re-size an array), list works by referencing. so logically it works slower than array does.

blocks|key|5081450|text|Java中的LinkedList的工作方式与您期望的一样。如果你使用官方的集合LinkedList，那么它实际上是一堆对象，它们通过“下一个”，有时还有“上一个”相互连接。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5081451|是的，它有一个get(int+index)方法，这是令人惊讶的，因为它的效率不是很高，因为你需要从一开始就开始计数，直到找到index条目，而这并不是LinkedLists擅长的。之所以如此，是因为LinkedList实现了List接口。这是您可以对所有列表执行的操作。|style|CODE|5081452|但是，当大多数对LinkedList的访问都是通过get(int+index)方法时，您可能会尽量避免使用它，因为这显然是效率最低的。使用ArrayList可能会更好。|5081453|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/6/docs/api/java/util/LinkedList.html|1|http://docs.oracle.com/javase/6/docs/api/java/util/List.html|2|http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html^0|13|A|0|0|7|E|1Q|5|34|4|1|0|P|E|1X|9|2|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|@$A|10|B|11|F|G]|$A|12|B|13|F|G]]|9|@$A|14|B|15|1|16]]|C|$]]|$1|H|3|I|5|6|7|17|8|@$A|18|B|19|F|G]]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|J|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]|T|$5|M|N|O|C|$P|U]]]]

A LinkedList in Java works just as you would expect it to do. If you use the official Collections <a href="http://docs.oracle.com/javase/6/docs/api/java/util/LinkedList.html" rel="noreferrer">LinkedList</a> then it will indeed be a a bunch of object connected to each other by having a 'next' and sometimes 'previous'.

And yes, it has a <code>get(int index)</code> method which is surprising because it would not be very efficient as you would need to start at the beginning and count your way up the list to find the <code>index</code>th entry and this is not what LinkedLists are good at. The reason it is there is because LinkedList implements the <a href="http://docs.oracle.com/javase/6/docs/api/java/util/List.html" rel="noreferrer">List</a> interface. This is something you can with ALL lists.

However, you would probably try to avoid using a LinkedList when most of your access to it is through the <code>get(int index)</code> method as that would clearly be most inefficient. You would be perhaps better to use an <a href="http://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html" rel="noreferrer">ArrayList</a>.

As far as I know, the concept of a linked list is a bunch of object connected to each other by having a 'next' and sometimes 'previous' attribute to traverse the objects.

I noticed in Java, you can create a LinkedList object...but treat it like an array/list/sequence by using the same methods such as .add(), .get(), etc.

So, is LinkedList internally an array-like sequence?

How does LinkedList work internally in Java?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

据我所知，链表的概念是一堆对象，它们通过“下一个”，有时还有“前一个”属性来遍历这些对象。我注意到，在Java语言中，您可以使用.add()、.get()等相同的方法创建一个LinkedList object...but，并将其视为数组/列表/序列。那么，LinkedList在内部是一个类似数组的序列吗？

问在Java中，LinkedList是如何在内部工作的？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，LinkedList是如何在内部工作的？EN