3.Arraylist LinkedList

已于 2022-09-22 22:55:43 修改
阅读量252 收藏
点赞数
分类专栏： java 集合 文章标签： java jvm servlet
于 2022-08-13 23:15:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/REXmama/article/details/126324912
版权

一.Arraylist

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。

1.Arraylist实现List接口的失误

public class ArrayList<E> extends AbstractList<E>
           implements List<E>, RandomAccess, Cloneable, java.io.Serializable

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>

 Arraylist父类已经实现过List了

2.成员变量

//默认的容量，用于每次数组的自动扩展
 15     private static final int DEFAULT_CAPACITY = 10;
 16 
 17     //定义的一个默认空数组对象
 18     private static final Object[] EMPTY_ELEMENTDATA = {};
 19 
 20    //ArrayList是基于数组结构来实现的，该数组用来实际保存数据，transient这个关键字是声明改变量不能被序列化
 21     private transient Object[] elementData;
 22 
 23     //当前集合中实际的元素的个数即大小
 24     private int size;

3.实例方法

  • JDK1.7：只要newArrayList时，就会给数组默认值为10，
  • JDK1.8：newArrayList时候会给出一个空的数组，但是当调用add方法时，这时才会给出长度为10的数组。再次扩容是扩为1.5倍
//带参数的构造函数，initialCapacity，初始化的容量即需要构造的List的大小
 27     public ArrayList(int initialCapacity) {
 28         super();
 29         if (initialCapacity < 0)
 30             throw new IllegalArgumentException("Illegal Capacity: "+
 31                                                initialCapacity);
 32         this.elementData = new Object[initialCapacity];
 33     }
 35    //无参构造函数初始化，注意是根据默认大小限定为10，即你不传参数时也会构造大小为10的List
 36     public ArrayList() {
 37         super();
 38         this.elementData = EMPTY_ELEMENTDATA;
 39     }
 41     /*
 42     *创建一个包含Collection类型的ArrayList，实际的过程是首先根据Collection中的元素复制一个数组
 43     */
 44     public ArrayList(Collection<? extends E> c) {
 45         elementData = c.toArray();//返回包含此 collection 中所有元素的数组。
 46         size = elementData.length;//数组的长度
 47         if (elementData.getClass() != Object[].class)//判断是否为数组类型
 48             elementData = Arrays.copyOf(elementData, size, Object[].class);//Arrays工具类，复制数组
 49     }

4.扩容机制（图摘韩顺平）

实质  elementData = Arrays.copyOf(elementData, newCapacity); 因为Arrays.copyOf会保留原始数据

public boolean add(E e) {
    ensureCapacityInternal(size + 1); //判断容量是否够
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == EMPTY_ELEMENTDATA) {		//先确定是不是空数组，即是不是第一次添加
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

//明确是否要扩容   参数传入是 add之后的容量大小
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;	//记录当前集合被修改的次数
    if (minCapacity - elementData.length > 0) // 如果当前容量不满足了..就需要发生扩容 
       // 即最小所需容量》当前容量
        grow(minCapacity);
}

//扩容
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);		//这里也是重要的地方.以原来1.5倍的大小进行扩容
    if (newCapacity - minCapacity < 0)	//如果扩容之后还是不满足数量的增长..就增长到 需要的数量
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)  //如果扩容超过了最大值..
        newCapacity = hugeCapacity(minCapacity);	//尝试容量能否下降下来..不能就爆了
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

5.优缺点

ArrayList 的优点如下：
  • ArrayList 底层以数组实现，是一种随机访问模式。 ArrayList 实现了 RandomAccess 接口，因此查找的时候非常快。
  • ArrayList 在顺序添加一个元素的时候非常方便
ArrayList 的缺点如下：
  • 删除元素的时候，需要做一次元素复制操作。如果要复制的元素很多，那么就会比较耗费性能。
  • 插入元素的时候，也需要做一次元素复制操作，缺点同上。

ArrayList 比较适合顺序添加、随机访问的场景。 

二.LinkedList

LinkedList是基于双向循环链表实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。

1.特点

继承了AbstractSequentialList，实现了List,Queue,Cloneable,Serializable，既可以当成列表使用，也可以当成队列，堆栈使用。

主要特点有：

1.线程不安全，不同步，如果需要同步需要使用
List list = Collections.synchronizedList(new LinkedList());

2.实现List接口，可以对它进行队列操作

3.实现Queue接口，可以当成堆栈或者双向队列使用

4.实现Cloneable接口，可以被克隆，浅拷贝

5.实现Serializable，可以被序列化和反序列化

2.参数

	//链表的数据个数
	transient int size = 0;
	//头节点
    transient Node<E> first;
	//尾节点
    transient Node<E> last;

	//Node类LinkedList的静态内部类
    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;
            }
        }

3.add()方法

    public boolean add(E e) {
        linkLast(e);
        return true;
    }

//加入到最后一个
    void linkLast(E e) {
        //指向链表的尾部
        final Node<E> l = last;
        //以尾部为前驱节点创建一个新节点
        final Node<E> newNode = new Node<>(l, e, null);
        //更新最后一个节点
        last = newNode;
        //如果之前的最后一个节点为空,说明链表是空的,就将新的节点指向first
        if (l == null)
            first = newNode;
        else
            //l的后置节点的引用跟新为新的节点
            l.next = newNode;
        size++;
        modCount++;
    }

过程：

  • LinkedList  mylist=new LinkedList();

        public LinkedList() {} 首先为空

  • 此时 LinkedList的属性 first=null   last=null
  • 执行 添加  public boolean add(E e) {
            linkLast(e);
            return true;
        }
  • 加入双向链表最后一个 void linkLast(E e) {..........}

4.删除方法

PS：有三种删除方法

   
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        //获取元素
        final E element = f.item;
        //保存f的下一个节点
        final Node<E> next = f.next;
        //将元素值和元素的next节点置空，有利于GC
        f.item = null;
        f.next = null; // help GC
        //首节点更新
        first = next;
        //如果首届点为空,链表就没有元素了,最后一个元素也就是空
        if (next == null)
            last = null;
        else
            //如果不为空,就将下一个结点的前置节点置为空
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

  
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

   
    private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        //获取元素值
        final E element = l.item;
        //将元素的前置节点保存
        final Node<E> prev = l.prev;
        //将元素的前置和元素值置空
        l.item = null;
        l.prev = null; // help GC
        //更新最后一个节点
        last = prev;
        //如果最后一个节点为空,那么链表为空
        if (prev == null)
            first = null;
        else
            //不为空,将前置节点的next置空
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

   
	//移除一个指定元素(链表后续还有相同元素是不会移除的)
    public boolean remove(Object o) {
        //判断元素是否为空
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

    
    E unlink(Node<E> x) {
        // assert x != null;
        //保存元素的值和前后节点
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;
		//如果前置节点为空,那么头节点就是当前节点
        if (prev == null) {
            first = next;
        } else {
            //前一个节点的next置为next
            prev.next = next;
            //该节点的前节点置空
            x.prev = null;
        }
		
        //如果后置节点为空,那么上一个节点就是最后一个节点
        if (next == null) {
            last = prev;
        } else {
            //next的上一个节点引用指向prev
            next.prev = prev;
            //被删除的节点的next置为空
            x.next = null;
        }
	    // item置空
        x.item = null;
        size--;
        modCount++;
        return element;
    }

    
	//移除指定索引的元素。先通过索引找到节点，再移除指定的节点
    public E remove(int index) {.
        //检查是否越界
        checkElementIndex(index);
	    //先找到节点，再移除指定节点
        return unlink(node(index));
    }

5.查找

   
    public E getFirst() {
        //保存第一个元素为f
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

  
    public E getLast() {
        //保存第一个元素为l
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

  
    public E get(int index) {
        //检查索引是否越界
        checkElementIndex(index);
        return node(index).item;
    }

 
	//如果索引位置在后面一半，就从后往前遍历查找，否则从前往后遍历。
    Node<E> node(int index) {
    
	   // size>>1 表示除以2，相当于index小于size的一半
        if (index < (size >> 1)) {
            // 从前面开始遍历，取出first节点，因为中间过程引用会变化，所以不可直接操作first
            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;
        }
    }

   
	//查找某一个元素的索引位置
    public int indexOf(Object o) {
        int index = 0;
        // 如果需要查找null元素
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            // 查找元素不为空
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

	//跟上面的indexOf差不多,就是倒过来查找
    public int lastIndexOf(Object o) {
        int index = size;
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (x.item == null)
                    return index;
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                index--;
                if (o.equals(x.item))
                    return index;
            }
        }
        return -1;
    }

6.更新

   
	//更新指定索引的位置的元素,返回旧值的元素
    public E set(int index, E element) {
        //检查索引是否越界
        checkElementIndex(index);
        //找到对应的节点
        Node<E> x = node(index);
        //记录旧值
        E oldVal = x.item;
        //修改元素
        x.item = element;
        return oldVal;
    }

  
	//如果索引位置在后面一半，就从后往前遍历查找，否则从前往后遍历。
    Node<E> node(int index) {
        // assert isElementIndex(index);
	   // size>>1 表示除以2，相当于index小于size的一半
        if (index < (size >> 1)) {
            // 从前面开始遍历，取出first节点，因为中间过程引用会变化，所以不可直接操作first
            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;
        }
    }

三.ArrayList 和 LinkedList 的区别

  • 数据结构实现：ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。
  • 随机访问效率：ArrayList 比 LinkedList 在随机访问的时候效率要高，因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。
  • 增加和删除效率：在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，因为ArrayList 增删操作要影响数组内的其他数据的下标。
  • 内存空间占用：LinkedList 比 ArrayList 更占内存，因为 LinkedList 的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。
  • 线程安全：ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；综合来说，在需要频繁读取集合中的元素时，更推荐使用 ArrayList，而在插入和删除操作较多时，更推荐使用 LinkedList。
  • LinkedList 的双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

四.总结

 

 

REXmama
关注
专栏目录
java.util.Arrays$ArrayList cannot be cast to java.util.ArrayList
keq_keq的博客
05-02 9398
完整报错： HTTP Status 500 – Internal Server Error</h1><hr class="line" /><p><b>Type</b> Exception Report</p><p><b>Message</b> Request processing fail...
Java如何获取(访问)ArrayList对象中的元素呢？
qq_25073223的博客
10-04 4869
Java获取(访问)ArrayList对象中的元素的方法分享，如下所示
Java集合框架之：ArrayList的常见方法使用
sjs52406的博客
11-28 2569
Java本文主要介绍Java ArrayList的使用方法教程及示例代码
ArrayList的常见使用方法
最新发布
weixin_72083767的博客
11-29 515
ArrayList的常见使用方法
如何优雅的访问ArrayList和LinkList
小雨的光的博客
08-16 544
（1）采用ArrayList对随机访问比较快，而for循环中的get()方法，采用的即是随机访问的方法，因此在ArrayList里，for循环较快； （2）采用LinkedList则是顺序访问比较快，iterator中的next()方法，采用的即是顺序访问的方法，因此在LinkedList里，使用iterator较快； 从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定...
Java面试题10.ArrayList LinkedList.mp4
09-09
Java面试题10.ArrayList LinkedList.mp4
51. ArrayList LinkedList Set HashMap介绍.txt
10-08
### ArrayList #### 简介 `ArrayList` 是 Java 中的一种动态数组实现方式，它允许在运行时调整其大小。`ArrayList` 实现了 `List` 接口，并且内部通过一个数组来存储数据。当添加元素导致数组空间不足时，`...
10.ArrayList 和LinkedList的区别.avi
03-07
10.ArrayList 和LinkedList的区别.avi
TWDH#Leetcode-From-Zero#10.ArrayList和LinkedList1
07-25
10.ArrayList和LinkedList基于动态数组，连续内存存储，适合下标访问（随机访问）扩容机制：因为数组长度固定，超出长度存数据时需要新建数组，然后
什么是 ArrayList
weixin_33826268的博客
02-24 2984
简介 ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 成员变量 ArrayList 底层是基于数组来实现容量大小动态...
arrayList 的访问问题
afternoone的专栏
01-14 923
如何得到arrayList中的内容呢？这个问题难了我几个钟，上网找也找不到，后来发觉原来答案是这样的： b=(强行类型转换)arrayList[i];就这样b就得到arrayList第i个元素啦。
C#中ArrayList类的元素访问
大道至简，知易行难
08-26 5565
C#中ArrayList类的元素访问 ArrayList是命名空间System.Collections下的一部分，在使用该类时必须进行引用，同时继承了IList接口，提供了数据存储和检索。ArrayList对象的大小是按照其中存储的数据来动态扩充与收缩的。所以，在声明ArrayList对象时并不需要指定它的长度。 C#中运用ArrayList需要引用命名空间 //在C#中使用Arra
java arraylist元素_java-访问arraylist的arraylist的arraylist的元素？
weixin_31556371的博客
02-12 829
我是Java的新手,目前正在将BlueJ用于一个项目.我在访问此类对象的ArrayList的ArrayList中的对象时遇到麻烦.说我有一个学生对象：public class Student{private String homeAddress;private String monthBorn;private String yearBorn;private int;public Student(S...
JavaSE基础(101) 遍历ArrayList集合的4种方式
郑清
08-31 5099
ArrayList遍历：取出ArrayList集合中的数据 ①：for循环 ②：增强for循环：foreach ③：Iterator：迭代器 ④：ListIterator：双向迭代器 ex: /** * ArrayList遍历：取出ArrayList集合中的数据 * ①：for循环 * ②：增强for循环：foreach * ③：Iterator：迭代器 * ④：...
Java基础（四）：ArrayList（含使用方法详解）
Viper的程序员修炼手册
03-01 7003
Java ArrayList ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。 ArrayList 继承了 AbstractList ，并实现了 List 接口。 ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下： import java.util.ArrayList; // 引入 ArrayList 类 ArrayList<E> objectName =new ArrayList<
ArrayList遍历的4种方法
宝爷的专栏
05-16 2287
Java代码 　　package com.test; 　　import java.util.ArrayList; 　　import java.util.Iterator; 　　import java.util.List; 　　public class ArrayListDemo { 　　public static void main(String args[]){ 　　List li
Java学习笔记之ArrayList基本用法
热门推荐
贱贱的梦想
05-27 9万+
更多信息可关注我的个人博客：贱贱的梦想 ArrayList简介ArrayList是一个其容量能够动态增长的动态数组。它继承了AbstractList，实现了List、RandomAccess, Cloneable, java.io.Serializable。 基本的ArrayList，长于随机访问元素，但是在List中间插入和移除元素时较慢。同时，ArrayList的操作不是线程安全的！一般在
图解集合1：ArrayList
weixin_34092455的博客
11-29 219
前言 这个分类中，将会写写Java中的集合。集合是Java中非常重要而且基础的内容，因为任何数据必不可少的就是该数据是如何存储的，集合的作用就是以一定的方式组织、存储数据。这里写的集合，一部分是比较常见的、一部分是不常用但是我个人平时见到过的，一些比较相似的集合（比如HashMap和Hashtable）就只讲一个，突出它们之间的区别即可。 最后，要指出一点，对于集合，我认为关注的点主要有四点：...
1.arraylist和linkedlist区别
09-01
ArrayList和LinkedList是Java中常用的两种集合实现类，它们的主要区别在于底层数据结构和性能特点。 1. 底层数据结构： - ArrayList使用数组作为底层数据结构，通过索引来访问元素。 - LinkedList使用双向链表作为底层数据结构，通过节点之间的引用来访问元素。 2. 内存占用： - ArrayList的内存占用比较紧凑，因为只需要存储元素和数组长度。 - LinkedList需要额外的内存来存储节点之间的引用关系，因此内存占用相对较大。 3. 插入和删除操作： - ArrayList在尾部进行插入和删除操作效率较高，时间复杂度为O(1)。但在其他位置插入和删除元素时，需要移动后续元素，时间复杂度为O(n)。 - LinkedList在任意位置进行插入和删除操作效率较高，时间复杂度为O(1)，因为只需要修改节点的引用关系。 4. 随机访问： - ArrayList通过索引可以直接访问元素，时间复杂度为O(1)。 - LinkedList需要从头或尾部开始遍历链表，直到找到目标节点，时间复杂度为O(n)。 总的来说，当需要频繁进行插入和删除操作时，选择LinkedList更加高效。当需要频繁随机访问元素时，选择ArrayList更加高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值