LinkedList类

最新推荐文章于 2022-10-16 20:24:06 发布

原创最新推荐文章于 2022-10-16 20:24:06 发布 · 152 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #LinkedList类

Java SE 专栏收录该内容

82 篇文章

订阅专栏

本文详细介绍了Java中的LinkedList和ArrayList，包括它们的构造方法、特有功能，如作为队列和栈的实现。对比了两者的查询、增删元素效率，分析了在不同操作下应选择哪种集合。实验结果显示，ArrayList查询快，插入删除慢，适合查询频繁的场景；LinkedList插入删除快，查询慢，适合增删频繁的场景。最后，通过模板设计模式进一步验证了这些结论。

1、API介绍
在这里插入图片描述
2、构造方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;

public class Demo9_LinkedList {

    public static void main(String[] args) {

        //构造方法
        //LinkedList() 空链表
        LinkedList list  = new LinkedList();
        System.out.println(list);//[]

        //LinkedList(Collection) 初始化集合元素
        Collection col = new ArrayList();
        col.add(10);
        LinkedList list2  = new LinkedList(col);
        System.out.println(list2);//[10]
    }

}

3、特有的功能方法
在这里插入图片描述

import java.util.LinkedList;

public class Demo4_linkedList {

    public static void main(String[] args) {
        //模仿队列,先进先出
        LinkedList list = new LinkedList();
        //.offer(Object) 添加（尾）数据到队列中
        list.offer(1);
        list.offer(2.3);
        list.offer(true);

        System.out.println(list);//[1, 2.3, true]

        //.poll() 删除（头）队列中的数据
        Object poll = list.poll();//1
        System.out.println(poll);

        System.out.println(list);//[2.3, true]

        System.out.println("-----------------");

        //模仿栈 先进后出
        LinkedList list2 = new LinkedList();
        //.push(Object) 压（头）数据到栈中
        list2.push(2);
        list2.push(3.3);
        list2.push(false);

        System.out.println(list2);//[false, 3.3, 2]
        //.pop() 弹（头）数据出栈
        Object pop = list2.pop();
        System.out.println(pop);//false
        System.out.println(list2);//[3.3, 2]
    }
}

2、ArrayList和LinkedList区别？
(1)ArrayList查询元素效率高，增删元素效率低。
(2)LinkedList查询元素效率低，增删元素效率高。


import javafx.scene.text.Text;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

//模版设计模式
abstract class TestTemplate {

    public void test() {
        long start = System.currentTimeMillis();
        content();
        long end = System.currentTimeMillis();
        long time = end - start;
        System.out.println("花费时间为：" + time);
    }

    public abstract void content();
}

class TestArrayList extends TestTemplate {

    @Override
    public void content() {
//        ArrayList list = new ArrayList();
//        //添加10000元素
//        for (int i = 0; i < 100000; i++) {
//            list.add(0, i);
//        }
        LinkedList list = new LinkedList();
        for (int i = 0; i < 100000; i++) {
            list.add(0, i);
        }
    }
}


public class Demo4_linkedList {

    public static void main(String[] args) {
        TestTemplate tt = new TestArrayList();
        tt.test();//花费时间为：ArrayList:1838/LinkedList:37
        //结论：ArrayList底层是数组，添加元素时，会使其他元素要进行偏移，效率低。
        //     LinkedList底层链表，添加元素时，只需修改节点访问上下节点指针的值无需偏移，效率高。
    }
}

import javafx.scene.text.Text;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

//模版设计模式
abstract class TestTemplate {

    public void test() {
        LinkedList list = new LinkedList();
        for (int i = 0; i < 100000; i++) {
            list.add(0, i);
        }
        long start = System.currentTimeMillis();
        content(list);
        long end = System.currentTimeMillis();
        long time = end - start;
        System.out.println("花费时间为：" + time);
    }

    public abstract void content(List list);
}

class TestArrayList extends TestTemplate {

    @Override
    public void content(List list) {
        for (int i = 0; i < 100000; i++) {
            int index = (int)(Math.random()*100000);//生成0～99999 下标随机值
            list.get(index);
        }
    }
}


public class Demo4_linkedList {

    public static void main(String[] args) {
        TestTemplate tt = new TestArrayList();
        tt.test();
        //查询元素花费时间为：ArrayList:26/LinkedList:13012
        //结论：ArrayList底层是数组，连续空间，查找的元素都在同一个空间，效率高。
        //      LinkedList底层是链表，不连续空间，查找元素不再同一个空间，效率低。

        //增加元素花费时间为：ArrayList:1838/LinkedList:37
        //结论：ArrayList底层是数组，添加元素时，会使其他元素要进行偏移，效率低。
        //     LinkedList底层链表，添加元素时，只需修改节点访问上下节点指针的值无需偏移，效率高。

        //总结论：集合中元素经常需要修改（新增/删除）这时应该选择LinkedList集合来保存。
        //集合中元素经常需要查询，这是应该选择ArrayList集合来保存。

        //method_队列和栈();
    }
}