LinkList学习-双向链表机构

for顺序遍历耗时 > iterator迭代器遍历耗时 > 通过removeFirst()或removeLast()遍历耗时 > forach顺序遍历耗时 = 通过pollFirst()或pollLast()来遍历耗时。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;

public class Test {
    
    public static void main(String[] args) {
        //创建存放int类型的linkedList
        LinkedList<Integer> linkedList = new LinkedList<Integer>();
        for(int i = 20;i < 100;i ++) {
            linkedList.add(i);
        }
        //添加元素到列表开头
        linkedList.addFirst(0);
        System.out.println("添加元素到列表开头:"+linkedList);
        //在列表结尾添加元素,同linkedList.add()同inkedList.offer()
        linkedList.addLast(9);
        System.out.println("添加元素到列表结尾:"+linkedList);
        //在指定位置添加元素
        linkedList.add(1, 1);
        System.out.println("在指定位置添加元素:"+linkedList);
        //获得第一个元素
        System.out.println("获得第一个元素:"+linkedList.getFirst());
        //获得第最后一个元素
        System.out.println("获得最后一个元素:"+linkedList.getLast());
        //删除第一个元素并返回删除的元素
        System.out.println("删除第一个元素:"+linkedList.removeFirst());
        //删除最后一个元素并返回删除的元素
        System.out.println("删除第一个元素:"+linkedList.removeLast());
        //判断是否指定元素
        System.out.println("判断是否指定元素:"+linkedList.contains(3));
        //将列表中指定位置的元素替换为指定的元素
        linkedList.set(0, 999);
        System.out.println("将列表中指定位置的元素替换为指定的元素:"+linkedList);
        //获得指定位置的元素
        System.out.println("获得指定位置的元素:"+linkedList.get(0));
        //获取首次出现的指定元素的索引
        System.out.println("获取首次出现的指定元素的索引:"+linkedList.indexOf(999));
        //获取最后一次次出现的指定元素的索引
        System.out.println("获取最后一次出现的指定元素的索引:"+linkedList.lastIndexOf(5));
        //获取第一个元素但不移除此列表的第一个元素
        System.out.println("peek(): " + linkedList.peek());
        System.out.println("element(): " + linkedList.element());
        //移除第一个元素
        System.out.println("poll(): " + linkedList.poll());
        System.out.println("集合: " + linkedList);
        System.out.println("remove():" + linkedList.remove());
        System.out.println("集合: " + linkedList);
        //在此列表的开头插入指定的元素
        linkedList.offerFirst(6); 
        System.out.println("集合: " + linkedList);
        //在此列表末尾插入指定的元素
        linkedList.offerLast(6);
        System.out.println("集合: " + linkedList);
        //获取但不移除此列表的第一个元素
        System.out.println("peekFirst(): " + linkedList.peekFirst());
        //获取但不移除此列表的最后一个元素
        System.out.println("peekLast(): " + linkedList.peekLast());
        //获取并移除此列表的第一个元素
        linkedList.pollFirst(); 
        System.out.println("pollFirst():" + linkedList);
        //获取并移除此列表的最后一个元素
        linkedList.pollLast(); 
        System.out.println("pollLast():" + linkedList);
        //将元素推入此列表所表示的堆栈（插入到列表的头）
        linkedList.push(6);
        System.out.println("push():" + linkedList);
        //从此列表所表示的堆栈处弹出一个元素（获取并移除列表第一个元素）
        linkedList.pop();
        System.out.println("pop():" + linkedList);
        //从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表）
        linkedList.push(999);
        linkedList.push(888);
        linkedList.push(999);
        System.out.println("开始removeFirstOccurrence()前:" + linkedList);
        linkedList.removeFirstOccurrence(999); 
        System.out.println("removeFirstOccurrence():" + linkedList);
        //从此列表中移除最后一次出现的指定元素（从尾部到头部遍历列表）
        linkedList.push(999);
        linkedList.push(888);
        linkedList.push(999);
        System.out.println("开始removeFirstOccurrence()前:" + linkedList);
        linkedList.removeLastOccurrence(888);
        System.out.println("removeFirstOccurrence():" + linkedList);
        //清空所有元素
        linkedList.clear();
        for (int i = 0; i < 10000; i++) {
            linkedList.add(i);
        }
        //迭代器遍历
        Iterator<Integer> iterator = linkedList.iterator();
        long start = System.currentTimeMillis();
        StringBuffer stringBuffer = new StringBuffer();
        while (iterator.hasNext()) {
            stringBuffer.append(iterator.next());
        }
        long end = System.currentTimeMillis();
        System.out.println("iterator迭代器遍历耗时:" + (end - start) + "ms");
        //顺序遍历
        start = System.currentTimeMillis();
        for (int i = 0; i < linkedList.size(); i++) {
            linkedList.get(i);
        }
        end = System.currentTimeMillis();
        System.out.println("for顺序遍历耗时:" + (end - start) + "ms");
        //顺序遍历
        start = System.currentTimeMillis();
        stringBuffer = new StringBuffer();
        for (Integer integer:linkedList) {
            stringBuffer.append(integer);
        }
        end = System.currentTimeMillis();
        System.out.println("forach顺序遍历耗时:" + (end - start) + "ms");
        //通过pollFirst()或pollLast()来遍历LinkedList
        LinkedList<Integer> integers = new LinkedList<Integer>();
        integers.addAll(linkedList);
        start = System.currentTimeMillis();
        stringBuffer = new StringBuffer();
        while (integers.size() != 0) {
            stringBuffer.append(integers.pollFirst());
        }
        end = System.currentTimeMillis();
        System.out.println("通过pollFirst()或pollLast()遍历耗时:" + (end - start) + "ms");
        //通过removeFirst()或removeLast()来遍历LinkedList
        LinkedList<Integer> integers2 = new LinkedList<Integer>();
        integers2.addAll(linkedList);
        start = System.currentTimeMillis();
        stringBuffer = new StringBuffer();
        while (integers2.size() != 0) {
            stringBuffer.append(integers2.removeFirst());
        }
        end = System.currentTimeMillis();
        System.out.println("通过removeFirst()或removeLast()遍历耗时:" + (end - start) + "ms");
        
    }
}