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遍历耗时在于读取特定元素循环遍历对象