【Java】ArrayList与LinkedList详解！！！

目次
一🌞、List
1🍅.什么是List？
2🍅.List中的常用方法
二🌞、ArrayList
1🍍.什么是ArrayList?
2🍍.ArrayList的实例化
3🍍.ArrayList的利用
  4🍍.ArrayList的遍历
5🍍.ArrayList特点
6🍍.ArrayList优缺点
1.🍋ArrayList的长处：
2.🍋ArrayList的缺点：
三🌞、LinkedList
1🍰.什么是LinkedList？
2🍰.LinkedList的实例化
3🍰.LinkedList的利用
4🍰.LinkedList的遍历
5🍰.ListedList的特点
6🍰.LinkedList优缺点
1🍐.LinkedList长处:
2🍐.LinkedList缺点:
四🌞、ArrayList与LinkedList的区别

---

一🌞、List

1🍅.什么是List？

在聚集框架中，List就是一个接口，继续于Collection接口。
在数据布局的角度，List就是一个线性表，即n个具有雷同范例元素的有限序列，在该序列上可以实行增删查改以及变量等操纵。
   什么是线性表？ 
  线性表是由n个具有雷同范例元素构成的有限序列。线性表是一种常见的数据布局。在逻辑上，线性表是一种线性布局，就是一连的一条直线，在物理布局上，不肯定是一连的，在物理存储是，通常是以数组和链式的布局情势存储。常见的线性比表有序次表、链表、栈、队列.......
  2🍅.List中的常用方法

增
boolean add（E e）	插入元素e在末端
void add（int index，E element）	插入元素e在index位置
boolean addAll（Collection？extends？E>c）	尾插c中的元素
删
E remove（int index）	删除index位置的元素
boolean remove（Object o）	删除第一次出现的o元素
void clear（）	清空
查
E get（int index）	获取index下标位置元素
int indexOf（Object o）	获取第一个o元素所在的下标
int lastindexOf（Object o）	获取末了一个o元素所在的下标
boolean contains（Object o）	查察是否包罗o元素
改
E set（int index，E Element）	将index下标的元素改为e
截取
List<E>subList（int formIndex,int toIndex）	截取部门list

        List是一个接口，以是不能直接实例化。如果想要利用list接口，必须实例化list的实现类。
在聚集框架中，ArrayList和LinkedList都实现了这个接口。 
二🌞、ArrayList

1🍍.什么是ArrayList?

ArrayList是一个平凡的类，是序次表的一种，实现了list接口，是一种可动态调解巨细的数组，可以或许储存差异范例的对象。
   什么是序次表？
  序次表是用一段物理所在一连的存储单位依次存储数据元素的线性布局，一样平常环境下接纳数组存储。在数组上完成数据的增删查改。
  

  2🍍.ArrayList的实例化

1.         //接口的实例化：
2.         List<Integer> list1=new ArrayList<>();
3.        //ArrayList的实例化：
4.         ArrayList<Integer> list=new ArrayList<>();
5.       

复制代码

两者区别：

• 接口的实例化：只能利用接口中界说类的方法；
  
• ArrayList实例化：可以利用ArrayList中独有的方法，更具有机动性
  

3🍍.ArrayList的利用

ArrayList常见方法：

增：
void add（int data）	在数组末了添加元素
void add（int pos，int data）	在数组某下标插入元素
删：
void remove（int toRemove）	删除第一次出现的元素
void clear（）；	清空全部元素
查:
boolean contains（int toFind）	查察是否包罗该元素
int get（int pos）	获取该下标元素
int indexOf（int toFind ）	获取该元素下标
改：
void set（int pos，int value）	将下标元素举行更改

 ArrayList方法的利用：

1. public static void main(String[] args) {
2.         List<Integer> list1=new ArrayList<>();
3.         //增：
4.         //add：尾插
5.         list1.add(1);
6.         list1.add(2);
7.         list1.add(3);
8.         list1.add(4);
9.         list1.add(5);
10.         System.out.println(list1);//[1, 2, 3, 4, 5]
11.         //add：任意位置插入
12.         list1.add(3,100);
13.         System.out.println(list1);//[1, 2, 3, 100, 4, 5]
14.         //查：
15.         //contains:是否包含该元素
16.         System.out.println(list1.contains(11));//false
17.         //get:获取下标元素
18.         int ret=list1.get(3);
19.         System.out.println(ret);//100
20.         //indexOf:获取元素下标
21.         int ret2=list1.indexOf(4);
22.         System.out.println(ret2);//4
23.         //改
24.         //set:将某下标的元素进行更改
25.         list1.set(1,13);
26.         System.out.println(list1);//[1, 13, 3, 100, 4, 5]
27.         //删：
28.         // remove：删除第一次出现的元素
29.         list1.remove(2);
30.         list1.remove(3);
31.         //list1.remove(6);//超出范围，报错
32.         System.out.println(list1);//[1, 13, 100, 5]
33.         //清空
34.         list1.clear();
35.         System.out.println(list1);//无
36.         //大小的获取：
37.         System.out.println(list1.size());
38.     }

复制代码

 

  4🍍.ArrayList的遍历

ArrayList的遍历可以利用三种方法：for循环、foreach、利用迭代器
示例：

1. public static void main(String[] args) {
2.         List<Integer> list1=new ArrayList<>();
3.         list1.add(1);
4.         list1.add(2);
5.         list1.add(3);
6.         list1.add(4);
7.         list1.add(5);
8.     }

复制代码

for循环：

1. //for循环语句：
2.         //list1.size（）：list1长度
3.         for (int i = 0; i < list1.size(); i++) {
4.             //get（i）：获取i下标的元素
5.             System.out.print(list1.get(i)+" ");//1 2 3 4 5
6.         }
7.    

复制代码

foreach语句：

1. //foreach:
2.         //每次循环时，取出list中的一个元素，将该元素赋值给变量num中
3.         for (Integer num:list1) {
4.             System.out.print(num+" ");//1 2 3 4 5
5.         }

复制代码

 迭代器：Iterator和ListIterator

1. //迭代器:
2.         //从前往后打印
3.         // Iterator
4.         System.out.println("=====Iterator=====");
5.         Iterator<Integer> a=list1.iterator();
6.         //a.hasNext():用于判断集合a中是否还有下一个元素，如果有返回true，没有返回false
7.         while(a.hasNext()){
8.             //a.next:返回迭代器当前所指向的元素，然后指向下一个元素未被遍历的元素并打印
9.             System.out.print(a.next()+" ");
10.         }
11.         System.out.println();
12.         //listIterator
13.         System.out.println("=====listIterator=====");
14.         ListIterator<Integer> b=list1.listIterator();
15.         while(b.hasNext()){
16.             System.out.print(b.next()+" ");//1 2 3 4 5
17.         }
18.         System.out.println();
19.         System.out.println("=====listIterator=====");
20.         //从后往前打印
21.         ListIterator<Integer> c=list1.listIterator(list1.size());
22.         //b.hasPrevious():用于判断集合a中是否有上一个元素，如果有返回true，没有返回false
23.         while(b.hasPrevious()){
24.             //b.previous:返回迭代器当前所指向的元素，然后指向上一个元素未被遍历的元素并打印
25.             System.out.print(b.previous()+" ");//5 4 3 2 1
26.         }

复制代码

• ArrayList恰当利用for循环语句遍历； 
  

   Iterator和Listiterator的区别： 
  

• Iterator是Java中的一个接口，通过hasNext（）和next（）方法实现序次遍历；
  
• Listiterator是Iterator的子接口，除了拥有Iterator的方法外，另有其他功能，以是其另有双向遍历的功能，通过hasPrevious（）和previous（）来实现反向遍历。
  

  5🍍.ArrayList特点

• 动态数组布局：基于数组实现。可以像平凡数组一样快速访问元素；
  
• 动态调解巨细：与平凡数组差异，当添加的元素个数大于ArrayList容量，ArrayList会自动扩容1.5倍；
  
• 元素储存有序：元素按照先后添加的序次在排序中，在插入大概删除元素的时间，会相应改变元素位置；
  
• 允许元素重复：可以添加多个重复雷同的元素；
  
• 通用性好:可以储存各类对象。
  

6🍍.ArrayList优缺点

1.🍋ArrayList的长处：

• 快速访问元素：基于数组实现，可以快速访问元素，时间复杂度为O（1）；
  
• 内存利用相对高效：内存布局相对规整，重要是数组占用空间和少量额外空间用于纪录数组巨细等信息。在不消频仍的插入和删除中心元素的环境下，内存利用高效；
  
• 支持随机访问：可以随机访问恣意位置的元素，在很多算法和操纵中非常有用，如二分查找。
  

2.🍋ArrayList的缺点：

• 扩容开销：当元素数目大于数组容量的时间，会举行扩容。在扩容时会创建一个新的容量更大的数组并复制旧元素，这会斲丧较多的时间和资源；
  
• 插入和删除的服从较低（中心元素）：在频仍的插入和删除中心元素的时间，必要不绝地移动元素，时间复杂度为O（n）。
  

由于ArrayList不恰当举行频仍的插入和删除元素，以是在Java聚集中引入了LinkedList，即链表布局。
三🌞、LinkedList

1🍰.什么是LinkedList？

LinkedList的底层是双向链表布局，是链表的一种。
   什么是链表？
  链表是一种常见的数据布局，它由一系列节点构成，每个节点包罗数据域和指针域。链表逻辑序次是一连的，在物理存储布局是非一连的。
  链表的分类:
  有头链表大概无头链表：
  

• 有头链表：有一个的头节点，其指针指向第一个数据节点；
  
• 无头链表：没有专门的头节点，第一个节点直接存储数据；
  

  

  以下分类都有分为是否是有头链表还是无头链表：
  

• 单链表：每个节点包罗数据和下一个接节点的指针，末了一个节点的指针指向空
  

  

  

• 双链表：每个节点都有包罗数据，以及指向前一个节点的指针和指向后一个节点的指针
  

  

  

• 循环链表：循环链表分为单循环链表和双循环链表，其就是末了一个节点的下一个节点的指针指向其头结点。
  

  

  2🍰.LinkedList的实例化

1. LinkedList<Integer> list1=new LinkedList<>();

复制代码

3🍰.LinkedList的利用

其常用方法与ArrayList相差不大

1.   public static void main(String[] args) {        LinkedList<Integer> list1=new LinkedList<>();        //增：        //add：尾插        list1.add(1);        list1.add(2);        list1.add(3);        list1.add(4);        list1.add(5);        System.out.println(list1);//[1, 2, 3, 4, 5]        //add：恣意位置插入        list1.add(3,100);        System.out.println(list1);//[1, 2, 3, 100, 4, 5]        //查：        //contains:是否包罗该元素        System.out.println(list1.contains(11));//false        //get:获取下标元素        int ret=list1.get(3);        System.out.println(ret);//100        //indexOf:获取元素下标        int ret2=list1.indexOf(4);        System.out.println(ret2);//4        //改        //set:将某下标的元素举行更改        list1.set(1,13);        System.out.println(list1);//[1, 13, 3, 100, 4, 5]        //删：        // remove：删除第一次出现的元素        list1.remove(2);        list1.remove(3);        //list1.remove(6);//超出范围，报错        System.out.println(list1);//[1, 13, 100, 5]        //清空        list1.clear();        System.out.println(list1);//无        //巨细的获取：        System.out.println(list1.size());//0    }

复制代码

4🍰.LinkedList的遍历

 遍历的三种方式：for循环，foreach、迭代器

1. public static void main(String[] args) {        LinkedList<Integer> list1=new LinkedList<>();        list1.add(1);        list1.add(2);        list1.add(3);        list1.add(4);        list1.add(5);        //for循环语句：        for (int i = 0; i < list1.size(); i++) {            int ret=list1.get(i);            System.out.print(ret+" ");//1 2 3 4 5        }        System.out.println();        //foreach        for (Integer x:list1) {            System.out.print(x+" ");//1 2 3 4 5        }        System.out.println();        //迭代器：        Iterator<Integer> a=list1.iterator();        while (a.hasNext()){            System.out.print(a.next()+" ");//1 2 3 4 5        }        System.out.println();        ListIterator b=list1.listIterator();        while (b.hasNext()){            System.out.print(b.next()+" ");//1 2 3 4 5         }        System.out.println();        ListIterator c=list1.listIterator(list1.size());        while(c.hasPrevious()){            System.out.print(c.previous()+" ");//5 4 3 2 1        }    }

复制代码

• LinkedList恰当利用迭代器遍历； 
  

5🍰.ListedList的特点

• 动态性：没有固定的巨细限定，巨细可动态变革；
  
• 插入或删除高效：在插入和删除时，只需修改干系节点即可，时间复杂度为O（1）；
  
• 序次访问：只能序次访问节点，服从较低，时间复杂度为O（n）；
  
• 存储布局：由一系列节点构成，每个节点包罗数据域和指针域；
  
• 通用性：可以存储差异数据。
  

6🍰.LinkedList优缺点

1🍐.LinkedList长处:

• 动态性强：节点分散存储，不受一连空间的限定；
  
• 插入或删除高效：在插入和删除时，只需修改干系节点即可，时间复杂度为O（1）；
  
• 可扩性好：可方便的增长和镌汰节点的数目；
  

2🍐.LinkedList缺点:

• 随机访问服从低：只能序次访问节点，服从较低，时间复杂度为O（n）；
  
• 额外空间开销大：除了存储数据本身，每个节点还要存储额外的指针信息，内存利用率低；
  
• 数据存储不一连：倒霉于有用存储，导致数据访问慢；
  

四🌞、ArrayList与LinkedList的区别

差异点	ArrayList	LinkedList
数据布局	逻辑上和物理上都是一连的	在逻辑上一连，物理上不一连
随机访问	随机访问服从快， 时间复杂度为O（1）	随机访问服从慢， 时间复杂度为O（n）
插入或删除	服从慢， 时间复杂度为O（n）	服从快， 时间复杂度为O（1）
容量	空间不敷必要扩容	没有容量限定
内存占用	内存利用相对高效	内存利用率低
应用场景	元素访问+高效存储	插入和删除频仍

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金