Java-集合（3）

WINorYU

已于 2023-01-09 21:46:46 修改

阅读量593

点赞数

分类专栏： JAVASE All 文章标签： java 数据结构链表

于 2023-01-08 22:17:56 首次发布

本文链接：https://blog.csdn.net/WINorYU/article/details/128593017

版权

JAVASE All 专栏收录该内容

110 篇文章 1 订阅

订阅专栏

Vector集合类

1.Vector底层保存数据的也是一个对象数组：protected Object[] elementDate;
2.Vector是线程同步的，也就是线程安全Vactor的操作方法都带有synchronized修饰。以此可以进行安全线程保障，所以在开发中如果确认只有一个线程操作集合就用ArrayList如果有多个线程就用Vector

Vector和ArrayList的比较

在这里插入图片描述

Vector创建和扩容底层源码分析

public class Vector_ {
    public static void main(String[] args) {
        Vector vector = new Vector();
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(10);
    }
}

总体上来说Vector和ArrayList的源码结构差不太多，主要是扩容的倍数不太一样，和默认赋值的地方不一样，Arraylist是先赋0空间，然后add的时候再赋10个空间。而Vector是一开始的无参构造就直接赋10个空间

1.进入无参构造，可以看到无参构造直接传入 10 调用另一个有参构造，最终创建了一个10空间大小的elementDate数组
在这里插入图片描述

2.接着开始进入for循环进线添加，同样的先自动装箱

3.进入add方法，修改次数+1，然后使用ensureCapacityHelper方法用于确认如果要添加1个，剩余空间是否够，如果不够就扩容，够的话就直接返回进行下面的添加。elementCount的作用和ArrayList的size是一样的，可以理解为一个数组的指针，初始指向数组的第0个空间。随着不断的add，elementCount也会逐渐增加指向第1/2/3/4/5…
在这里插入图片描述
4. 由于Vector无参构造直接赋了10个空间所以初次add是会直接返回进行添加的，所以我们直接跳到第11次添加，需要扩容的时候：因为前面进行了10次添加，所以此时elementCount是10，代表指向数组的最后一个空间，接着调用ensureCapacityHelper方法用于确认再添加一个元素，剩余空间是否还够用。传入了elementCount + 1，也就是11。

在这里插入图片描述
5.进入ensureCapacityHelper可以看到，是先用if判断 minCapacity（需要的空间11）减去 elementDate.length（当前的空间10），11-10大于0 所以进入grow扩容方法

6.进入grow扩容方法且把需要空间数量传入，首先将elementDate当前的空间数量给oldCapacity老容量
然后用老容量+（这里用了三元运算，capacityIncrement是否大于0，如果大于0就返回capacityIncrement，如果小于等于0就返回老容量）而capacityIncrement只要不修改就默认是0 ，所以这里会返回老容量，也就意味着newCapacity新容量是老容量的2倍。
然后进行一个if判断新容量减去需要的容量是否小于0，如果小于0就意味着新容量不够需要的容量，那么就会把需要的容量的值赋给新容量。此时新容量是20 而需要的容量是11，所以直接进入下方的Arrays.copyOf进行扩容。
在这里插入图片描述
7.扩容完毕后直接原路返回到add进行添加操作。可以看到此时elementDate的空间已经被扩容成20个了，而添加使用的是elementCount++，由于是后++所以是先添加再将elementCount往后移一位。

LinkedList集合类

LinkedList底层实现了双向链表和双端队列特点
可以添加任意元素(元素可以重复)，包括null
线程不安全，没有实现同步

LinkedList底层结构

LinkedList底层维护了一个双向链表（待会简单讲解）
LinkedList中维护了两个属性first和last分别指向首节点和尾节点
每个节点（Node对象），里面又维护了prev（指向前一个），next（指向后一个），item（保存数据的）三个属性，其中通过prev指向前一个Node对象，通过next指向后一个Node对象，最终实现双向链表
所以LinkedList的元素的添加和删除不是通过数组完成的，相对来说效率较高

简单了解双向链表

下面通过简单代表来初步认识什么是双向链表，以及怎么对双向链表进行添加和删除

简单的来说双向链表就是通过Node类的prev和next来连接多个Node对象，然后通过多态的特点来遍历

双向链表的连接

代码演示：

public class LinkedList {
    public static void main(String[] args) {
        //首先创建三个Node对象
        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node mary = new Node("mary");
        //此时这三个对象彼此之间没有任何联系，是独立存在的。
        //下面我们用prev和next让他们彼此之间联系起来
        jack.next = tom;//jack的下一个指向tom
        tom.next = mary;//tom的下一个指向mary
        mary.prev = tom;
        tom.prev = jack;
        //接着创建first和last分别指向这个链表的头和尾
        Node first = jack;
        Node last = mary;
    }
}
class Node{
    public Object item ;
    public Node prev;
    public Node next;

    public Node(Object item) {
        this.item = item;
    }

    @Override
    public String toString() {
        return "name = "+item;
    }
}

可以看到此时三个Node对象彼此之间就有了联系，关系如图：
在这里插入图片描述

双向链表的连接

在上面我们通过prev和next将三个对象连接起来了，那么下面将使用first和last将这个链表遍历
从头开始遍历:

while (true){
            if (first == null){//如果first指向null就退出循环
                break;
            }
            System.out.println(first);
            first = first.next;
        }

因为first先开始是指向第一个对象：jack，所以不是null，接着输出first，那么根据多态的特性，此时first的编译类型是Node first这个引用，那么实际的运行类似其实是Node jack，再自动使用toString方法输出jack的item。
接下来将first.next赋给first。这里的first.next就是Node.tom，所以此时first就变成了Node tom
接着又进入while循环，first依旧不等于null，所以输出 tom
而后又进行 first = first.next ，此时的first是Node.tom，而tom的next又指向mary，所以此时first又变成了mary。接着又进入循环输出mary。
然后又运行first = first.next，此时的first是Node mary，而mary的next是null，所以first变成了null。再下一次循环就会退出、

那么根据上面的规律要从尾往前遍历，只需将first换成last，且将next换成prev即可。

while(true){
            if (last == null){
                break;
            }
            System.out.println(last);
            last = last.prev;
        }

遍历图示：
在这里插入图片描述

总而言之：双向链表的遍历，就是通过一直改变first或者last指向的地址进行对不同对象的调用。

双向链表的增加与删除

通过上面的了解双向链表之间的链接是通过next和prev，那么同理当我们需要将链表当中的某一个对象删除或者增加某一个对象时，也只需改变前一个和后一个的next和prev的指向即可。
代码演示

//创建一个新的对象
        Node smith = new Node("smith");
        //将前一个的next的指向smith，且将smith的next指向下一个
        tom.next = smith;
        smith.next = mary;
        //将后一个的prev也指向smith,且将smith的prev指向上一个
        mary.prev = smith;
        smith.prev = tom;

遍历输出确认一下：
name = jack
name = tom
name = smith
name = mary
可以看到确实被添加进去了
图示体现链表添加
在这里插入图片描述
双向链表的删除
同理，将一个对象从双向链表删除也是改变要删除对象的前后next和prev的指向即可
例如将smith从双向链表中删除

//将前一个元素的next跳过smith直接指向后一个,且将后一个的prev跳过smith直接指向前一个
        tom.next = mary;
        mary.prev = tom;

这样就从链表中删除了smith，对于smith的next和prev的指向可以改也可以不改，因为在使用链表的时候应该不会到smith那去了。
图示：
在这里插入图片描述

LinkedList添加删除底层源码分析

根据上面的学习我们知道LinkedList底层是使用了双向链表来保存数据的，那么下面就根据一段代码来追一下源码具体是怎么添加的。

public class LinkedList_2 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
    }
}

首先进入无参构造，做一个初始化。里面维护了几个变量 {size：链表的长度，first：首节点，last：尾节点，modCount：修改次数}
同样的做一个自动装箱
进入add方法，调用linkLast(e)方法传入要添加的元素
进入重点方法：linkList：

首先将last尾节点指向的元素备份一个到Node l
然后新建一个结点newNode，使用的是有参构造，此有参构造是Node(Node prev,Object item,Node next),代入参数就是将last指向的对象给newNode这个节点的prev(上一个)，将此次要存的元素给item，将null给next。因为此add方法是在最后面添加一个节点，所以新节点的next肯定是null。
接着将last指向新节点，原理就是在最后添加，那么last就是指向最后一个节点的
然后进入一个if判断：如果L是指向空，这里的L是last在被重新指向的指向，可以理解为是否是第一次添加节点。如果是第一次添加就将first指向这个新节点，因为是第一次添加节点，所以first和last都是需要指向这个节点的。如果不是第一次添加节点，就让上一个节点的next指向这个新节点，l 就代表last上一个的指向也就是添加之前的最后一个节点。
最后size长度+1，修改次数+1.，返回到add执行完毕

上面追完了第一次添加结点，下面接着追一下第2次添加节点。为了更好理解，下面图示一下添加完第一个节点的双向链表
下面开始追添加第二个节点，要将一个节点添加进行，需要将last指向要添加的节点，然后将前一个节点的next也指向要添加的节点，最后将要添加的节点的prev指向上一个节点。那么看看源码是怎么操作的
首先还是自动装箱，接着进入add方法，调用linkLast传入此次要添加的元素 2
进入linkList，

首先将last的指向备份一个给l，此时的last和L都指向第一个节点
然后创建一个新节点：将l传入新节点的prev，将此次添加的元素保存到新节点的item，将新节点的next指向null
然后让last不指向第一个节点转而指向这次添加的节点
接着进入if判断是否是第一次添加节点，因为是第二次添加节点所以l不指向null，进入l.next = newNode,注意这里的l还是指向第一个节点，那么这里也就意味着将第一个节点的next指向第二个新节点
最后第二个节点就添加好了，size长度+1，修改次数+1.后面再要添加节点也是根据相同的结构添加

在这里插入图片描述
9. 添加好的双向链接如图

LinkedList的删除
LinkedList里重载了很多删除方法，针对不同的需要可以使用不同的删除方法

下面使用最普通的删除方法追源码分析下，同增加的原理，删除就是需要将双向链表的前后节点的next和prev改变下，如果删除的是头尾还需要将first和last改变下。

public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        linkedList.remove();
        System.out.println(linkedList);
    }

上面添加了3个元素，此时的双向链表中有3个节点。下面分析下此删除方法会删除哪一个节点，且是怎么删除的

可以看到普通的remove方法底层使用的是removeFirst方法，根据方法名可以推断出应该是first指向那个就删除哪个
进入removeFirst方法，首先将first指向的节点备份给 f ，然后进入if判断当前的链表是否是空链表，如果是就抛出异常，如果不是就调用unlinkFirst方法且传入 f
进入unlinkFirst方法这里是实际删除的地方提示：此时 f 代表第一个节点

首先将 f 指向的节点保存的元素给到 element
然后将 f 指向的节点的next也就是下一个节点备份给next 此时Node next指向第二个节点
接着让 f 指向的节点的 item和next置空让后面GC回收掉
然后将next(第二个节点)代替第一个节点，让first指向它
接着进入一个if 判断看看此链表是不是一共只有要删除的这一个节点，如果是就干脆将last置空
如果不仅有一个节点，就将第二个节点的prev置空(因为他的上一个要被删除了)。
最后链表的size-1 修改次数+1，返回删除节点保存的元素，删除执行完毕

总的来说LinkedList的增删改查底层还是对于双向链表的改动，所以需要了解双向链表

ArrayList和LinkedList的比较与选择

从前面的学习中我们了解到，ArrayList和LinkedList是线程不安全的两个集合实现类，适合在单线程的情况下使用。但是同样是适配单线程操作集合，他们之间也有所区别。

集合类	底层结构	增删效率	改查效率
ArrayList	可变数组	较低，需要数组扩容缩减	较高
LinkedList	双向链表	较高，通过链表追加删除	较低

所以根据上列的区别，在实际应用开发中：

改查操作较多，使用ArrayList
增删操作较多，使用LinkedList
实际项目中也可根据业务灵活选择，例如一个模块用ArrayList另一个模块用LinkedList

WINorYU

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java-集合（3）

1.Vector底层保存数据的也是一个对象数组：protected Object[] elementDate;2.Vector是线程同步的，也就是线程安全Vactor的操作方法都带有synchronized修饰。以此可以进行安全线程保障，所以在开发中如果确认只有一个线程操作集合就用ArrayList如果有多个线程就用Vector。
复制链接

扫一扫