java - 迭代链表

发布于 2024-10-13 01:43:36 字数 59 浏览 3 评论 0原文

如果我在java中的链表上使用for-each循环, 是否保证我会按顺序迭代元素 它们出现在哪个列表中?

if I use a for-each loop on a linked list in java,
is it guaranteed that I will iterate on the elements in the order
in which they appear in the list?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(6

带上头具痛哭 2024-10-20 01:43:36

我发现了 5 种在 Java 中迭代链表的主要方法(包括 Java 8 方法):

  1. For 循环
  2. 增强型 For 循环
  3. While 循环
  4. < em>迭代器
  5. 集合的stream() util (Java8)

For循环

LinkedList<String> linkedList = new LinkedList<>();
System.out.println("==> For Loop Example.");
for (int i = 0; i < linkedList.size(); i++) {
    System.out.println(linkedList.get(i));
}

增强的for循环

for (String temp : linkedList) {
    System.out.println(temp);
}

While循环

int i = 0;
while (i < linkedList.size()) {
    System.out.println(linkedList.get(i));
    i++;
}

Iterator

Iterator<String> iterator = linkedList.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next()); 
}

collection stream() util (Java 8)

linkedList.forEach((temp) -> {
    System.out.println(temp);
});

需要指出的是,For LoopWhile 的运行时间循环的时间复杂度为 O(n 平方),因为 get(i) 操作需要 O(n) 时间(有关详细信息,请参阅此)。其他 3 种方式需要线性时间并且性能更好。

I found 5 main ways to iterate over a Linked List in Java (including the Java 8 way):

  1. For Loop
  2. Enhanced For Loop
  3. While Loop
  4. Iterator
  5. Collections’s stream() util (Java8)

For loop

LinkedList<String> linkedList = new LinkedList<>();
System.out.println("==> For Loop Example.");
for (int i = 0; i < linkedList.size(); i++) {
    System.out.println(linkedList.get(i));
}

Enhanced for loop

for (String temp : linkedList) {
    System.out.println(temp);
}

While loop

int i = 0;
while (i < linkedList.size()) {
    System.out.println(linkedList.get(i));
    i++;
}

Iterator

Iterator<String> iterator = linkedList.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next()); 
}

collection stream() util (Java 8)

linkedList.forEach((temp) -> {
    System.out.println(temp);
});

One thing should be pointed out is that the running time of For Loop or While Loop is O(n square) because get(i) operation takes O(n) time(see this for details). The other 3 ways take linear time and performs better.

野味少女 2024-10-20 01:43:36

链表保证按顺序执行。

来自文档

有序集合(也称为
顺序)。该界面的使用者
可以精确控制其中的位置
列出每个插入的元素。这
用户可以通过其访问元素
整数索引(列表中的位置),
并在列表中搜索元素。

迭代器()
按正确顺序返回此列表中元素的迭代器。

Linked list is guaranteed to act in sequential order.

From the documentation

An ordered collection (also known as a
sequence). The user of this interface
has precise control over where in the
list each element is inserted. The
user can access elements by their
integer index (position in the list),
and search for elements in the list.

iterator()
Returns an iterator over the elements in this list in proper sequence.

回忆躺在深渊里 2024-10-20 01:43:36

正如 Linkedlist 的定义所示,它是一个序列,并且保证您按顺序获取元素。

例如:

import java.util.LinkedList;

public class ForEachDemonstrater {
  public static void main(String args[]) {
    LinkedList<Character> pl = new LinkedList<Character>();
    pl.add('j');
    pl.add('a');
    pl.add('v');
    pl.add('a');
    for (char s : pl)
      System.out.print(s+"->");
  }
}

As the definition of Linkedlist says, it is a sequence and you are guaranteed to get the elements in order.

eg:

import java.util.LinkedList;

public class ForEachDemonstrater {
  public static void main(String args[]) {
    LinkedList<Character> pl = new LinkedList<Character>();
    pl.add('j');
    pl.add('a');
    pl.add('v');
    pl.add('a');
    for (char s : pl)
      System.out.print(s+"->");
  }
}
一个人的旅程 2024-10-20 01:43:36

链表确实保证顺序。

不要使用 linkedList.get(i),尤其是在顺序循环内,因为它违背了链表的目的,并且代码效率低下。

使用ListIterator

    ListIterator<Object> iterator = myLinkedList.listIterator();
    while( iterator.hasNext()) {
        System.out.println(iterator.next());
    }

Linked list does guarantee sequential order.

Don't use linkedList.get(i), especially inside a sequential loop since it defeats the purpose of having a linked list and will be inefficient code.

Use ListIterator

    ListIterator<Object> iterator = myLinkedList.listIterator();
    while( iterator.hasNext()) {
        System.out.println(iterator.next());
    }
只是一片海 2024-10-20 01:43:36

每个 java.util.List 实现都需要保留顺序,因此您可以使用 ArrayList、LinkedList、Vector 等。它们中的每一个都是有序集合,并且它们中的每一个都保留插入的顺序(请参阅 http://download.oracle.com/javase/1.4.2/docs/ api/java/util/List.html)

Each java.util.List implementation is required to preserve the order so either you are using ArrayList, LinkedList, Vector, etc. each of them are ordered collections and each of them preserve the order of insertion (see http://download.oracle.com/javase/1.4.2/docs/api/java/util/List.html)

绅刃 2024-10-20 01:43:36

为未来的访问者添加我的输入。

首先要做的事情:按照 $jls-14.14.2,for-each内部使用迭代器。

现在,当您使用for-遍历LinkedList时every 或迭代器,则循环始终是顺序的。

但这样很容易出现线程安全问题。因此,可能会发生两件事:

  1. 如果您使用非线程安全的 List 实现,那么您将遇到 ConcurrentModificationException
  2. 您可以使用像 CopyOnWriteArrayList 这样的线程安全 List 实现。如果您必须使用LinkedList,则只能使用Collections.synchronizedList()将非线程安全LL转换为线程安全LL,但您再次需要注意使用以线程安全的方式迭代器。

Adding my inputs for future visitors.

First things first: as per $jls-14.14.2, for-each internally use Iterator.

Now, when you iterate over LinkedList using a for-each or an iterator then the looping is always sequential.

But this is prone to thread safety issues. So, two things can happen:

  1. If you use a non-threadsafe List implementation then you will run into ConcurrentModificationException
  2. You can use a threadsafe List implementation like CopyOnWriteArrayList. And if you must use a LinkedList only then use Collections.synchronizedList() to convert your non-threadsafe LL into a threadsafe LL, but again you need to watch out for using iterator in a threadsafe manner.
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文