数组的LinkedList ..所有元素都获取最后一个元素的值
数组和链表是两种常见的数据结构，用于存储和操作一组元素。它们在获取最后一个元素的值方面有一些区别。
- 数组（Array）：
- 概念：数组是一种线性数据结构，由一组连续的内存空间组成，用于存储相同类型的元素。
- 分类：可以分为静态数组和动态数组。静态数组在创建时需要指定大小，大小固定不变。动态数组可以根据需要动态调整大小。
- 优势：由于内存空间连续，可以通过索引快速访问任意位置的元素，时间复杂度为O(1)。
- 应用场景：适用于已知元素数量且需要频繁访问元素的场景，如算法中的数组操作、矩阵运算等。
- 腾讯云相关产品：腾讯云提供的云服务器（CVM）可以用于部署应用程序，其中可以使用数组进行数据存储和操作。具体产品介绍请参考：腾讯云云服务器
- 链表（LinkedList）：
- 概念：链表是一种非连续的数据结构，由一组节点组成，每个节点包含数据和指向下一个节点的指针。
- 分类：可以分为单向链表、双向链表和循环链表。单向链表每个节点只有指向下一个节点的指针，双向链表每个节点有指向前一个节点和后一个节点的指针，循环链表的尾节点指向头节点。
- 优势：插入和删除元素的时间复杂度为O(1)，不需要像数组一样移动其他元素。链表可以动态调整大小，不受内存限制。
- 应用场景：适用于需要频繁插入和删除元素的场景，如链表操作、LRU缓存等。
- 腾讯云相关产品：腾讯云提供的云原生数据库TDSQL-C可以用于存储和操作链表数据。具体产品介绍请参考：腾讯云云原生数据库TDSQL-C
综上所述，数组和链表都是常见的数据结构，用于存储和操作一组元素。数组适用于已知元素数量且需要频繁访问元素的场景，链表适用于需要频繁插入和删除元素的场景。具体选择哪种数据结构取决于应用的需求和性能要求。
相关·内容
从理论上讲，从ArrayList或LinkedList中删除元素更有效吗
浏览 0提问于2009-06-23得票数 0
回答已采纳
指出，在LinkedList中没有“随机访问”。有人能给我解释一下吗？
给定的
LinkedList<String> l = new LinkedList<>();
然后我就可以使用，
l.get(n);
既然如此，为什么这篇文章会说“不能随机访问”？
浏览 9提问于2013-06-22得票数 2
回答已采纳
我有一个LinkedList的ArrayList来将我的传感器捕获的数据存储在线程中(在ArrayList对象上使用synchronized )
在捕获时，会添加传感器事件，我可以看到linkedlist在增加，但第一个和最后一个元素始终是最后一个捕获事件。有什么地方不对劲吗...？
// main thread ('samplingFifoQueues' passed as an arg to be synchronized ...)
public volatile LinkedList<SensorEvent> accelFifoQueue = n
浏览 2提问于2014-02-08得票数 0
我想知道为什么LinkedList没有initialCapacity。
我知道什么时候使用ArrayList，什么时候使用LinkedList。
定义集合最终大小的良好实践如下：
List<String> arraylist = new ArrayList<String>(5);
例如，对于LinkedList：
List<String> linkedlist = new LinkedList<String>(); // right way
但
List<String> arraylist = new LinkedList<St
浏览 5提问于2013-09-27得票数 27
回答已采纳
我在读关于LinkedList和ArrayList的书。我发现许多人说，通过ArrayList进行迭代比LinkedList更快，但同时，从LinkedList中添加和删除元素比ArrayList更快。
如何证明这一点？
我用Java编写了一个实验，并在调试模式下运行它，但是我没有看到ArrayList和LinkedList之间有什么区别。
你是如何处理这个问题的，如何证明人们所说的是真的？
这是我的代码：
import java.util.ArrayList;
import java.util.LinkedList;
public class List {
public stat
浏览 4提问于2015-12-12得票数 0
回答已采纳
我正在处理一个稀疏矩阵类，需要来使用LinkedList数组来存储矩阵的值。数组的每个元素(即每个LinkedList)表示矩阵的一行。并且，LinkedList数组中的每个元素都表示一个列和存储的值。
在我的类中，我有一个数组声明为：
private LinkedList<IntegerNode>[] myMatrix;
而且，在我的SparseMatrix构造函数中，我试图定义：
myMatrix = new LinkedList<IntegerNode>[numRows];
我最终得到的错误是
无法创建LinkedList<IntegerNode>的泛
浏览 26提问于2008-10-19得票数 103
回答已采纳
我尝试使用For循环填充一个数组的LinkedList，但结果很奇怪:我的'for‘循环之外的所有元素都获取最后一个元素的值！然而，当我用一个整型的LinkeList做同样的事情时，这次它工作了，所有的元素都得到了它的“实际值”。所以我的问题是:为什么它适用于整数的LinkedList，但它不适用于数组?？ public static void main(String[] args) {
LinkedList<Integer[]> listOfArrays = new LinkedList<Integer[]>();
L
浏览 22提问于2020-03-27得票数 2
我了解到在LinkedList的末尾添加一个元素是O(1)，因为我们只是添加一个链接到列表最后一个节点的对象，而ArrayList也是O(1)，但最坏的情况是O(n)，因为当数组中没有空间时必须调整大小。我试着对我所学到的结果进行测试，但在添加1000万个元素方面，ArrayList比LinkedList快得多。 经过多次尝试，ArrayList花费了大约570毫秒，而LinkedList花费了大约1900毫秒。 public static void listPractice(List<String> test) {
long startTime = System.cur
浏览 40提问于2020-12-12得票数 0
回答已采纳
1回答
我研究过，如果我们想要更多的插入/删除，我们使用LinkedList；如果我们有更多的retravision，我们使用ArrayList。
但我怀疑在编程所有插入都需要每次检索，否则插入几乎是无用的。每次都是为了操作，每次我们需要检索数据时计算。
那么我们为什么要使用Linkedlist呢？
浏览 2提问于2022-02-12得票数 -1
我创建了一个LinkedList，并向它添加了以下元素。
List<Integer> integers = new LinkedList<>();
integers.add(0);
integers.add(45);
integers.add(95);
integers.add(5);
integers.add(12);
Integer[] arr = integers.toArray(new Integer[3]);
System.out.println(arr.length);
for(int c:arr) {
System.out.println(
浏览 4提问于2017-08-25得票数 1
回答已采纳
4回答
我正在尝试创建一个removeDuplicates函数，该函数在链表中查找重复的值，调用并将找到重复值的索引传递给removeNode函数(该函数将删除这些重复的值)。removeDuplicates函数还返回删除的重复值的计数。
但是我的代码中有一些错误，在我选择了选项3之后，程序必须被强制停止，这是调用removeDuplicates函数的选项。
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
typedef struct _listnode
{
int item
浏览 2提问于2014-04-15得票数 0
我有一个字符串数组
String[] names;
假设数组中有给定数量的元素
我想要创建一个返回字符串的getLast方法
public String getLast() {
return names.length - 1;
}
这给了我一个错误，它是不兼容的。
我怎么能这样做才能返回字符串呢？
添加方法也是如此。
public void add(int index, String element){
我很好奇，如果不使用Linkedlist或Arraylist，而是一个基于数组的列表，它将如何工作。
浏览 0提问于2014-09-22得票数 0
回答已采纳
我认为我在理论上很好地理解了ArrayList和LinkedList之间的区别。然而，这是第一次，我把它进行了一个小小的测试，测试结果与我的预期完全不同。
期望：
在开始插入时，Arraylist将比linkedlist慢，因为它必须“移动”元素，对于链接列表，它只需要更新2个引用。
现实:在大多数迭代中，结果都是一样的。对于一些特定的迭代，它要慢一些。
在开始删除时，Arraylist将比LinkedList慢，因为它必须“移动”元素，对于Linkedlist，它只是取消了一个元素。
实际情况:从beg中删除时，性能相同。
测试用例:1 000 000元素
public st
浏览 11提问于2013-03-01得票数 6
回答已采纳
我在www.javatpoint.com上发现了以下问题
如果要使用列表实现，但不确定要实现哪一个，因为需求尚不明确。在这种情况下，您将使用哪个列表实现？
选项: 1. ArrayList 2. LinkedList
正确答案是ArrayList
但是没有解释为什么，请帮助我
浏览 0提问于2017-05-31得票数 0
回答已采纳
我有一个类，它应该创建一个哈希表，并为这些值创建一个链表。如果键是新的，它会创建一个链表，如果已经存在，则会将其追加到列表的末尾。由于某种原因，当我使用addLast()时，它会替换我列表中的内容。你能看到我做错了什么吗？这是我的代码。谢谢!
import java.util.*;
public class Semantic {
String currentScope;
Stack theStack = new Stack();
HashMap<String, LinkedList> SymbolTable= new HashMap<String,
浏览 0提问于2013-07-09得票数 0
回答已采纳
由于HashMap使用LinkedList，当两个不同的键生成相同的hashCode.But时，我想知道是什么使LinkedList在这里比其他List.Why实现更好，而不是ArrayList，因为ArrayList在内部使用Array，与LinkedList相比，arrays具有更快的迭代速度。
浏览 2提问于2015-05-23得票数 6
回答已采纳
Java中的StringBuffer/StringBuilder类主要用于修改字符串值，而不必每次初始化新的String对象。
是否有特定的原因，它不使用LinkedList而不是Char，因为它是底层的数据结构？
将char插入数组总是会导致O(n)时间来将所有元素复制到下一个索引，就像在LinkedList情况下在O(1)时间完成的那样。
浏览 1提问于2018-09-09得票数 2
回答已采纳
3回答
我正在制作一个程序来玩UNO的游戏。在UNO甲板上，有些卡片是重复的，因此我不能只列出整数；我必须使用对象。我计划在甲板上使用一个LinkedList，但我知道LinkedList上的拖拉动作非常慢。
我的问题是，我应该.
完全避免使用LinkedList，只需使用ArrayList
使用ArrayList或类似的，洗牌，然后将内容放入LinkedList
构造一个ArrayList，然后创建我自己的洗牌例程(也称不使用随机程序)，该例程将添加到LinkedList中。
无论如何，洗牌LinkedList (就像在，它并没有那么糟糕)
这不是为了家庭作业；它是为了帮助玩
浏览 3提问于2012-05-19得票数 2
回答已采纳
3回答
我正在比较ArrayList和LinkedList中contains方法在0到1000之间的数字序列上的性能。
对于这两个列表，我做一个包含(400)。ArrayList的性能总是比LinkedList高3倍。用JMH进行了比较。
ArrayList花费了329,642纳秒
LinkedList花费了945,881纳秒
如果这两个列表都具有worse方法的O(n)性能，为什么LinkedList要差3倍呢？
比较类：
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations
浏览 0提问于2020-08-02得票数 0
回答已采纳
3回答
我有接受用户输入的代码，并为打印和删除目的而递增计数器。我添加了一些打印行，以查看链表和当前位置之间的计数差异，得到的结果如下：
Enter a command from the list above (q to quit):
2
Deleted: e e 5 $5.0
Current record is now first record.
4
5
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index
浏览 1提问于2013-03-28得票数 0
回答已采纳
3回答
当我像这样声明LinkedList时：
List<String> names = new LinkedList<String>();
它不支持任何LinkedList的特殊方法(例如：names.peekLast()、names.pollFirst() )
但当我声明如下时：
LinkedList<String> names = new LinkedList<String>();
然后它支持这些方法。
是的，很明显，原因是引用，因为LinkedList包含的方法，而List没有！
但我的问题是，当我想使用LinkedList时，哪个更好、更正确？
浏览 1提问于2016-02-08得票数 3
1回答
我为我的Java类编写了一个程序，但我似乎找不出它做错了什么。我用1到100之间的25个随机整数填充LinkedList。然后我对列表进行排序，并输出总和和平均值。然后我删除奇数并输出新列表的总和和平均值。然而，当我做最后的计算时，它似乎也会从原始列表中添加最大的数字。如果第一个列表中最大的数字是偶数，则将其相加两次。
import java.util.Collections;
import java.util.Random;
import java.util.List;
import java.util.LinkedList;
import java.util.ListIterator;
i
浏览 0提问于2013-11-18得票数 0
第一部分：
我在"Data Structure and Algorithms made in Java“一书中读到，从Linkedlist和Arraylist中删除最后一个元素的时间复杂度为O(n)。但是链表在内部实现了DoublyLinkedlist，所以时间复杂度应该是O(1)，类似地，对于数组来说，因为它在内部实现了数组，所以时间复杂度应该是O(1)。
第二部分：
它还指出，在linkedlist结尾处插入元素的时间复杂度为O(n)，但是linkedlist在结尾处和前面都保留了指针。那么这句话是正确的吗？而且，如果数组未满，则在数组末尾插入元素的时间复杂度为O(1)，如果数组已
浏览 14提问于2017-04-01得票数 10
回答已采纳
3回答
我的老师给我分配了一个程序，在那里我要创建一个随机数的链表。我将从一个列表中创建它，然后任务的第二部分是反转它。实际报价是
编写一个名为reverseLinkedList()的Java方法，该方法将从问题1中创建的链接列表生成反向链接列表，您的方法应该接受链接列表作为输入，并返回另一个具有反向顺序的节点引用的链接列表。请不要反向打印原始列表。这样做的目的是操纵节点引用，使节点按照最初创建的顺序保持不变。
到目前为止我生成的代码如下所示
import java.util.*;
public class progassignment2
{
public static void
浏览 0提问于2018-10-08得票数 0
4回答
我知道这是一个愚蠢的问题，但它真的困扰着我。
请执行以下操作：
public <TParseable> LinkedList<TParseable> readAllParseable(
Parseable<TParseable> parseable, boolean close) throws IOException
{
LinkedList<TParseable> list = new LinkedList<TParseable>();
byte[] delim = parseable.getD
浏览 0提问于2009-11-20得票数 1
回答已采纳
我认为ArrayList在开头插入元素的复杂度为O(n)，因为它将其余元素向右移动了一位。LinkedList在最后插入元素的时间为O(n)，因为它必须遍历每个元素。所以上面的两个操作所用的时间应该是比较的，但当我实际这样做的时候，arraylist在开头插入需要34057毫秒，LinkedList在结尾插入只需要41毫秒，而两者的时间复杂度都是O(n)。为甚麽呢？
在空间复杂度方面，哪一个更好？
以下是我的代码
public void timeTakenEnd(String name, List<Integer> list) {
for (int i = 0; i &
浏览 1提问于2014-06-29得票数 1
摘自
以下相关的性能统计数据表明了这一类别：
获得添加插入迭代删除TreeList 3 5 1 2 1 ArrayList 1 40 1 40 LinkedList 5800 1 350 2 325
它接着说：
LinkedList很少是一个很好的实现选择。TreeList几乎总是一个很好的替代品，尽管它确实使用了更多的内存。
我的问题是：
ArrayList add，insert和remove times粉碎LinkedList是怎么回事？例如，我们是否应该期望现实世界中的插入和删除情况非常有利于ArrayList？
这个TreeList是不是简单地把钉子钉进了老掉牙
浏览 21提问于2009-11-11得票数 25
回答已采纳
2回答
从列表中移除范围(尾)
、、、
是否有一种有效的方法从List中删除X元素的范围(例如尾部)，例如LinkedList中的X元素？
显然，可以逐个删除最后一个元素，这将导致O(X)级性能的提高。至少对于LinkedList实例，应该可以具有O(1)性能(通过设置要删除的第一个元素的引用和设置头/尾引用)。不幸的是，我没有看到List或LinkedList中有任何方法可以一次性删除最后的元素。
目前，我正在考虑使用替换列表，但我不确定这是否具有相同的性能。至少在代码中会更清楚，另一方面，我会放松LinkedList提供的附加功能。
我主要使用列表作为堆栈，至少在语义方面，LinkedList似乎是最好的选择。
浏览 4提问于2012-05-29得票数 44
回答已采纳
在LinkedList中，当访问下一个节点时，我的老师使用了以下参数： public class LinkedList<T>{
private Node<T> header;
private int size;
public LinkedList(){
this.header=null;
this.size=0;
}
public void add(T element){
if(header==null){
header= new No
浏览 16提问于2020-01-11得票数 0
回答已采纳
我正在尝试创建一个返回字符串链接列表的方法。有一棵树，树中的每个节点都存储一个字符。该方法被认为是通过树找到所有可能的路径。每条路径创建一个字符串，并将其添加到列表中。
在第二个for循环中似乎有一个我无法解决的问题。该方法仅返回在第一个if语句中添加的字符。
每个节点都包含变量childList和nodevalue，前者是子节点的链表，后者是节点存储的字符。
public LinkedList<String> findStrings() {
LinkedList<String> paths = new LinkedList<String>();
浏览 1提问于2012-11-15得票数 3
4回答
你能给我解释一下这段代码吗？arrays.aslist(job)是什么意思？
String jobs[] ={"senior","programmeur","project manager"};
LinkedList<String> links = new LinkedList<String>(Arrays.asList(jobs));
浏览 0提问于2014-08-31得票数 0
2回答
我非常理解SLL或DLL的概念。但是我们在集合界面中使用的是哪一个呢？
到目前为止，我在接口列表、队列和Dequeue中遇到了LinkedList。
还有其他的吗？我们在这三个接口中使用的是什么类型的LinkedList？我怎么能知道呢？
浏览 0提问于2020-07-25得票数 1
回答已采纳
8回答
我在跟踪一个，上面写着：
对于LinkedList
get是O(n)
加法为O(1)
移除是O(n)
Iterator.remove是O(1)
对于ArrayList
get是O(1)
add是O(1)摊销的，但O(n)是最坏的情况，因为数组必须调整大小和复制。
移除是O(n)
因此，通过查看这个，我得出的结论是，如果我只需要在集合中对5000000元素进行顺序插入，那么LinkedList将超过ArrayList。
如果我只需要通过迭代从集合中获取元素，即不在中间抓取元素，那么LinkedList仍将超过ArrayList。
现在，为了验证
浏览 14提问于2011-05-01得票数 66
回答已采纳
我试图在链表上用C#实现桶排序算法，但我得到了正确的结果。此函数应将List和Node作为参数，然后按正确的升序插入该节点。我有一个列表4，7，12，15，我希望以升序插入数据为20的新节点，例如此列表变为4，7，12，15，20。但结果我得到了此列表4，7，12，20，15请帮助我，它有什么问题。我猜while循环内部有一些问题。此函数调用的所有其他函数都完全正常工作
static public void InsertionSort(LinkedList list, Node s)
{
int data = s.getData(
浏览 6提问于2019-12-04得票数 0
我在java.util.LinkedList上使用一个java.util.LinkedList，希望它能像这个伪代码那样工作：
list = (1,2,3,4)
iterator.next should be 1
iterator.next should be 2
iterator.prev should be 1
iterator.next should be 2
但命令是这样的：
iterator.next is 1
iterator.next is 2
iterator.prev is 2
iterator.next is 2
我无法相信这就是它的工作方式，所以我创建了一个测试，但是它产
浏览 3提问于2016-11-07得票数 2
回答已采纳
3回答
我尝试在Java中定义一个链表数组，如下所示，编译得很好，但它生成了两条警告消息。
LinkedList<Long> [] hashtable = new LinkedList[10];
warning: [rawtypes] found raw type: LinkedList
LinkedList<Long> [] hashtable = new LinkedList[10];
^
missing type arguments for generic class Link
浏览 0提问于2014-12-26得票数 5
回答已采纳
我对arraylist比linkedlist更快的理解是，对于arraylist，你基本上只需要一个动作--更新数组元素末尾的引用，而对于链表，你必须做更多的事情，例如创建一个新节点，更新2个引用，遍历链表并更新最后一个节点指向新的节点等等。
然而，我不确定java是如何实现这些的。arraylist如何知道" last“元素在哪里，它是存储最后一个元素的值，还是遍历数组并在最后一个元素之后添加一个新元素？
和链表，它们是存储对列表中最后一个节点的引用，还是遍历整个列表以到达末尾？
浏览 1提问于2013-01-24得票数 3
回答已采纳
比方说，
LinkedList<String> link=new LinkedList<String>();
link.add("A");
link.add("B");
link.add("C");
System.out.println(link.get(1));
现在，通过get(index)方法，我们可以说搜索一个元素需要O(1)次。但我读到它需要O(n)。有人能帮我弄清楚概念吗？
浏览 0提问于2016-02-19得票数 3
5回答
如何对单个链表进行排序。(这里的问题是，单个属性+使用LinkedList进行排序比使用数组更难)我希望看到伪代码。
尝试让它在时间和空间上都尽可能有效。
谢谢!
浏览 2提问于2010-07-23得票数 9
回答已采纳
2回答
我想要创建一个字节列表。(在Java中)大小是已知的。每次迭代之后，我想删除第一个元素。在任何时候，我都只访问第一个元素。
我考虑过使用队列，但这在我的用例中是行不通的，因为我需要将该项保留在列表中，以便进行多次迭代。
什么是最适合的，把表演记在心里。
LinkedList的数组列表？(顺序很重要)既然大小没有变化，那么使用数组和访问I元素怎么样？每次都不移除吗？
浏览 1提问于2021-11-10得票数 0
我在向ArrayList>添加字符串时遇到了问题。它被宣布
ArrayList<LinkedList<String>> table = new ArrayList<>();
在类的构造函数中，我调用了ArrayLists ensureCapacity方法，它似乎不像我所期望的那样。我原以为它会增加LinkedList的插槽，但它仍然是空的。
当我试图调用我的add方法时：
public boolean add(String s)
{
boolean wanted = true;
if(false)
{
w
浏览 8提问于2015-02-09得票数 2
回答已采纳
ArrayDeque的文档说：
这个类在用作堆栈时可能比stack更快，当用作队列时可能比LinkedList更快。
没有提到使用ArrayDeque作为堆栈与使用ArrayList之间的区别。您可以使用ArrayList作为堆栈，如下所示。
list.add(object); // push
object = list.remove(list.size() - 1); // pop
我发现，当我只以这种方式使用ArrayList时，它的性能比ArrayDeque差。是什么原因造成了这种差异？当然，这不可能仅仅是对size()的调用？在内部，A
浏览 9提问于2015-04-11得票数 37
我有一个带有密钥的地图和一个JSONObjects列表，如下所示
Map<String, LinkedList<JSONObject>> vendorOrdersMap = new LinkedHashMap<String, LinkedList<JSONObject>>();
我需要计算供应商的每个LinkedList下的价格，以知道哪个供应商的价格最高。
Map<String, LinkedList<JSONObject>> vendorOrdersMap = new LinkedHashMap<String,
浏览 0提问于2014-07-31得票数 0
回答已采纳
7回答
有没有人知道有一个实现有一个恒定的时间get(int index) (即实现了)，但当它像一样增长时，不需要复制整个列表？
我认为实现很可能是在其他列表方面，例如
public class ChunkedList<T> implements List<T>, RandomAccess {
private LinkedList<ArrayList<T>> chunks;
public T get(int index) {
return findCorrectChunk(index).get(computeChunkIndex(ind
浏览 1提问于2009-09-05得票数 3
回答已采纳
在阅读了这个问题后：，我尝试对ArrayList和LinkedList的性能进行基准测试。但我发现的结果与答案大相径庭。就add()而言，ArrayList的性能是LinkedList的2-3倍。据我所知，LinkedList.add(E元素)是O(1) <- LinkedList ArrayList.add(E元素)的主要优点是O(n -索引)，但结果表明数组列表比LinkedList快得多
有人能解释一下这种行为吗？
public static void main(String[] args) {
long start = System.currentTimeMillis(
浏览 2提问于2014-03-11得票数 0
我读过和
并且理解LinkedList add(E元素)是O(1)，ArrayList add(E元素)是O(1)摊销的，但是O(n)最坏的情况，因为数组必须调整大小和复制。
但是，当我试着检查的时候
public class ArrayListVSLinkeedList {
public ArrayListVSLinkeedList() {
final int COUNTER = 15000000;
List<Integer> arrayList = new ArrayList<Integer>();
long tStart_add =
浏览 2提问于2015-02-10得票数 4
回答已采纳
2回答
import java.util.*;
class Cube{
int width;
int height;
public Cube(int width, int height){
this.width = width;
this.height = height;
}
public String toString(){
String s = "[" + width + "," + height + "]";
return s;
}
浏览 0提问于2018-02-10得票数 0
我已经有了一个包含值的列表类型Integer，如果一个元素范围的和满足特定的值，我想从索引0中依次进行测试，然后将这个范围复制到一个列表中，并将其存储在一个链接列表列表中。然后再次按顺序测试，但现在从前一个范围的以下索引开始测试，因此，如果前一个范围是索引0到索引9，那么从索引10开始，然后重复这个过程直到最后一个索引。
List<Integer> arrayB = new LinkedList<Integer>(); //this is the array with values in it
List<LinkedList> p = new Linked
浏览 5提问于2015-10-17得票数 1
回答已采纳
我是新来的，这是我第一次发帖，所以如果我会犯任何错误，请原谅我。我想要显示来自4个LinkedList的元素和那些要显示的元素，就像在一个表中一样。我不需要JTable，因为我不需要图形用户界面。我尝试过使用ListIterator，但它没有显示所有元素:我的意思是，如果一个列表有5个元素，而另一个列表有3个元素，那么每个列表中只会显示3个元素。一段比一百万个单词更有价值的代码，所以：
LinkedList list1 = new LinkedList();
LinkedList list2 = new LinkedList();
LinkedList list3 =
浏览 0提问于2013-01-03得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
