LinkedList for 和 forEach遍历分析

 

Java中LinkenList数据结构->链表

 

链式存储,Sequential Access:

  这种方式,每一个数据元素,在内存中都不要求处于相邻的位置,每个数据元素包含他的下一个元素的内存地址,不可以根据元素的位置直接计算出内存地址,只能按照顺序读取元素。主要是以链表为代表。

 

1.传统的for循环遍历,基于计数器的:

遍历者自己在集合外部维护一个计数器,然后依次读取每一个位置的元素,当读取到一最后一个元素后停止。主要是需要按元素的位置来读取。这也是最原始的集合遍历方法。 

LinkedList链表,对于链式存储(size=n)读取一个特定位置元素的平均时间复杂度约为O(n/4),遍历整个集合的平均时间复杂度约为O(n^2/4) ,即四分之一n的平方)

代码实现:

 

public static void forTest(List<String> list){

    int size = list.size();

    for(int i=0;i<size;i++) {

        String v =  list.get(0);

    }

}

源码分析:new LinkenList().get()

数据结构:Node链表

private static class Node<E> {
   
E item;
   
Node<E> next;
   
Node<E> prev;

   
Node(Node<E> prev, E element, Node<E> next) {
       
this.item = element;
       
this.next = next;
       
this.prev = prev;
    }
}

public E get(int index) {
    checkElementIndex(index);
   
return node(index).item;
}

/**
 * Returns the (non-null) Node at the specified element index.
 */

Node<E> node(int index) {
   
// assert isElementIndex(index);

   
if (index < (size >> 1)) {
       
Node<E> x = first;
       
for (int i = 0; i < index; i++)
            x = x.
next;
       
return x;
    }
else {
       
Node<E> x = last;
       
for (int i = size - 1; i > index; i--)
            x = x.
prev;
       
return x;
    }
}

 

从代码分析 new LinkenList().get() 当 index < size/2 时 向下一节点遍历,

遍历平局次数 (1+size /2)/2;当 index > size/2 时 倒叙向上一节点遍历,

遍历平局次数 (1+size/2)/2;

总次数约为  size/2+size^2/4 约 n^2/4

 

2.foreach 循环遍历:

内部也是采用了Iterator的方式实现,LinkenList extends AbstractSequentialList extends AbstractList 重写了 iterator() 方法

代码实现:

public static void forEach(List<String> list){

    for(String str : list){

       String v = str;

    }

}

源码解析:forEach 实现是调用LinkenList extends AbstractSequentialList 的 iterator() 方法, 在通过调用 AbstractSequentialList extends AbstractList 的 listIterator() 方法,最后在listIterator(0)方法new ListItr().next() 遍历对象


1.AbstractSequentialList.calss

public Iterator<E> iterator() {
   
return listIterator();
}

 

2.AbstractList.class

 

public ListIterator<E> listIterator() {
   
return listIterator(0);
}

 

3.LinkedList.calss

 

public ListIterator<E> listIterator(int index) {
    checkPositionIndex(index);
   
return new ListItr(index);
}


private class ListItr implements ListIterator<E> {
   
private Node<E> lastReturned;
   
private Node<E> next;
   
private int nextIndex;
   
private int expectedModCount = modCount;

   
ListItr(int index) {
       
// assert isPositionIndex(index);
       
next = (index == size) ? null : node(index);
       
nextIndex = index;
    }

   
public boolean hasNext() {
       
return nextIndex < size;
    }

   
public E next() {
        checkForComodification();
       
if (!hasNext())
           
throw new NoSuchElementException();

       
lastReturned = next;
       
next = next.next;
       
nextIndex++;
       
return lastReturned.item;
    }

   
public boolean hasPrevious() {
       
return nextIndex > 0;
    }

   //
。。。代码省略。。。
}

 

从代码分析 LinkenList forEach遍历 是通过Iterator迭代器,向下一节点遍历对象,整体的时间复杂度约o(n)

 

LinkenList for、forEach 遍历测试结果如下:(测试结果仅供参考)

分析结果:LinkedList集合遍历的次数越多,forEach性能约是for性能 4.5倍

总结:对于LinkendList遍历建议使用forEach遍历,for遍历耗时在于读取特定元素循环遍历对象

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
当使用ArrayListLinkedList进行遍历时,你可以使用for循环、foreach循环和Iterator迭代器三种方法来遍历集合元素。以下是示例代码: 使用for循环遍历ArrayList: ```java import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class Main { public static void main(String[] args) { List<String> arrayList = new ArrayList<>(); arrayList.add("Apple"); arrayList.add("Banana"); arrayList.add("Orange"); for (int i = 0; i < arrayList.size(); i++) { String element = arrayList.get(i); System.out.println(element); } } } ``` 使用foreach循环遍历ArrayList: ```java import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class Main { public static void main(String[] args) { List<String> arrayList = new ArrayList<>(); arrayList.add("Apple"); arrayList.add("Banana"); arrayList.add("Orange"); for (String element : arrayList) { System.out.println(element); } } } ``` 使用Iterator迭代器遍历ArrayList: ```java import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; import java.util.List; public class Main { public static void main(String[] args) { List<String> arrayList = new ArrayList<>(); arrayList.add("Apple"); arrayList.add("Banana"); arrayList.add("Orange"); Iterator<String> iterator = arrayList.iterator(); while (iterator.hasNext()) { String element = iterator.next(); System.out.println(element); } } } ``` 对于LinkedList,你可以使用相同的方式进行遍历,只需将ArrayList替换为LinkedList即可。 请注意,以上示例代码仅用于说明不同遍历方法的用法,实际应用中需要根据具体情况选择合适的遍历方式。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值