深入理解 LinkedList 及底层源码分析

news2024/12/25 1:35:35

LinkedList 是基于链表结构的一种 List，在分析 LinkedList 源码前我们先对对链表结构做一个简单的了解。

一、链表的概念

链表是由一系列非连续的节点组成的存储结构，简单分下类的话，链表又分为_单向链表和双向链表，而单向 / 双向链表又可以分为循环链表和非循环链表_，下面简单就这四种链表进行图解说明：

1、单向链表
单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的 next 指向 null。

2、单向循环链表

单向循环链表和单向列表的不同是，最后一个节点的 next 不是指向null，而是指向 head 节点，形成一个“环”。

3、双向链表

从名字就可以看出，双向链表是包含两个指针的，pre 指向前一个节点，next 指向后一个节点，但是第一个节点 head 的 pre 指向 null，最后一个节点的 tail 指向 null。

4、双向循环链表

双向循环链表和双向链表的不同在于，第一个节点的 pre 指向最后一个节点，最后一个节点的 next 指向第一个节点，也形成一个“环”。

LinkedList 就是基于双向循环链表设计的。

**二、**LinkedList 介绍及其源码剖析

1、继承树结构：

2、LinkedList 定义

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
  • LinkedList 继承了 AbstractSequentialList 类，实现了 List 接口、Deque 接口、Cloneable 接口、java.io.Serializable 接口。
  • LinkedList 实现了 List 接口，即能对它进行队列操作，提供了相关的添加、删除、修改、遍历等功能。
  • LinkedList 实现了 Deque 接口，即能将 LinkedList 当作双端队列使用。
  • LinkedList 实现了 Cloneable 接口，即覆盖了函数 clone()，所以它能被克隆。
  • LinkedList 实现 java.io.Serializable 接口，这意味着 LinkedList 支持序列化，能通过序列化进行传输。

3、LinkedList 属性源码剖析

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // 双向链表的节点个数
    transient int size = 0;

    /**
     * Pointer to first node.     * Invariant: (first == null && last == null) ||     *            (first.prev == null && first.item != null)     */
     // 双向链表指向头节点的指针
    transient Node<E> first;

    /**
     * Pointer to last node.     * Invariant: (first == null && last == null) ||     *            (last.next == null && last.item != null)     */
     // 双向链表指向尾节点的指针
    transient Node<E> last;

}

从以上源码可以看出，LinkedList 的属性比较少，分别是：

  • size ： 双向链表的节点个数
  • first： 双向链表指向头节点的指针
  • last： 双向链表指向尾节点的指针

注意：first 和 last 是由引用类型 Node 连接的，这是它的一个内部类。

4、内部类 Node 源码剖析：

LinkedList 是通过双向链表实现的，而双向链表就是通过 Node 类来实现的，Node 类中通过 item 变量存储当前元素，通过 next 变量指向当前节点的下一个节点，通过 prev 变量指向当前节点的上一个节点。

private static class Node<E> {
    // item表示当前存储元素
    E item;
    // next表示当前节点的后置节点
    Node<E> next;
    // prev表示当前节点的前置节点
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

三、构造方法及其源码剖析

1、无参构造方法

LinkedList 的无参构造就是**构造一个空的 list 集合**。

/**
 * Constructs an empty list. */
public LinkedList() {
}

2、有参构造方法

传入一个 Collection<? extends E> 类型参数，构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

/**
 * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param  c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

四、常用方法及其源码剖析

1、add(E e) 方法，将指定的元素追加到此列表的末尾

/**
 * Appends the specified element to the end of this list. * * <p>This method is equivalent to {@link #addLast}. * * @param e element to be appended to this list * @return {@code true} (as specified by {@link Collection#add}) */
public boolean add(E e) {
    linkLast(e);
    return true;
}

其中，调用的 linkLast() 方法，设置元素 e 为最后一个元素：

/**
 * Links e as last element. */
void linkLast(E e) {
    // 获取链表的最后一个节点
    final Node<E> l = last;
    // 创建一个新节点
    final Node<E> newNode = new Node<>(l, e, null);
    // 使新的一个节点为最后一个节点
    last = newNode;
    // 如果最后一个节点为null，则表示链表为空，则将newNode赋值给first节点
    if (l == null)
        first = newNode;
    else
    	// 否则尾节点的last指向 newNode
        l.next = newNode;
    // 元素的个数加1
    size++;
    // 修改次数自增
    modCount++;
}

执行流程：
第一步，获取链表的最后一个节点；第二步，创建一个新节点；第三步，使新的一个节点为最后一个节点；第四步，如果最后一个节点为 null，则表示链表为空，则将 newNode 赋值给 first 节点；否则尾节点的 last 指向 newNode。

2、add(int index, E element) 方法，在指定位置插入元素

/**
 * Inserts the specified element at the specified position in this list. * Shifts the element currently at that position (if any) and any * subsequent elements to the right (adds one to their indices). * * @param index index at which the specified element is to be inserted * @param element element to be inserted * @throws IndexOutOfBoundsException {@inheritDoc} */
public void add(int index, E element) {
    // 检查索引index的位置
    checkPositionIndex(index);

    // 如果index==size，直接在链表的最后插入元素，相当于add(E e)方法
    if (index == size)
        linkLast(element);
    else
    	// 否则调用node方法将index位置的节点找出，接着调用linkBefore 方法
        linkBefore(element, node(index));
}

执行流程：
首先检查索引 index 的位置，看下标是否越界；如果 index==size，直接在链表的最后插入元素，相当于 add(E e) 方法；否则调用 node 方法将 index 位置的节点找出，接着调用 linkBefore 方法。
其中，调用 checkPositionIndex() 方法，检查索引 index 的位置：

private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

在增加元素的时候，调用了 linkBefore() 方法，在非 null 节点 succ 之前插入元素 e：

/**
 * Inserts element e before non-null Node succ. */
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    // 指定节点的前驱
    final Node<E> pred = succ.prev;
    // 创建新的节点，前驱节点为succ的前驱节点，后续节点为succ，则e元素就是插入在succ之前的
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 构建双向链表，succ的前驱节点为新的节点
    succ.prev = newNode;
    // 如果前驱节点为null，则把newNode赋值给first
    if (pred == null)
        first = newNode;
    else
    	// 构建双向列表
        pred.next = newNode;
    // 元素的个数加    
    size++;
    // 修改次数自增
    modCount++;
}

总结：
① 指定节点的前驱
② 创建新的节点，前驱节点为 succ 的前驱节点，后续节点为 succ，则 e 元素就是插入在 succ 之前的
③ 构建双向链表，succ 的前驱节点为新的节点
④ 如果前驱节点为 null，则把 newNode 赋值给 first；否则构建双向列表

3、remove() 方法删除这个列表的头（第一个元素）

/**
 * Retrieves and removes the head (first element) of this list. * * @return the head of this list * @throws NoSuchElementException if this list is empty * @since 1.5 */
public E remove() {
    return removeFirst();
}

其中，调用了**removeFirst()** 方法，删除并返回第一个元素：

/**
 * Removes and returns the first element from this list. * * @return the first element from this list * @throws NoSuchElementException if this list is empty */
public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

4、remove(int index) 方法，删除指定位置的元素

/**
 * Removes the element at the specified position in this list.  Shifts any * subsequent elements to the left (subtracts one from their indices). * Returns the element that was removed from the list. * * @param index the index of the element to be removed * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */
public E remove(int index) {
    // 检查索引index的位置
    checkElementIndex(index);
    // 调用node方法获取节点，接着调用unlink(E e)方法	
    return unlink(node(index));
}

检查索引 index 的位置，调用 node 方法获取节点，接着调用 unlink(E e) 方法：

/**
 * Unlinks non-null node x. */
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 {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
    	// 删除的是最后一个元素
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
	
	// 把item置为null，让垃圾回收器回收
    x.item = null;
     // 移除一个节点，size自减
    size--;
    modCount++;
    return element;
}

**5、**set(int index, E element) 方法，将指定下标处的元素修改成指定值

/**
 * Replaces the element at the specified position in this list with the * specified element. * * @param index index of the element to replace * @param element element to be stored at the specified position * @return the element previously at the specified position * @throws IndexOutOfBoundsException {@inheritDoc} */
public E set(int index, E element) {
    checkElementIndex(index);
    // 通过node(int index)找到对应下标的元素
    Node<E> x = node(index);
     // 取出该节点的元素，供返回使用
    E oldVal = x.item;
     // 用新元素替换旧元素
    x.item = element;
    // 返回旧元素
    return oldVal;
}

执行流程：
先通过 node(int index) 找到对应下标的元素，然后修改 Node 中 item 的值。

**5、**get(int index) 返回此列表中指定位置的元素

public E get(int index) {
	// 检查索引index的位置
    checkElementIndex(index);
    // 调用node()方法
    return node(index).item;
}

在此调用了_node()_ 方法：

/**
 * Returns the (non-null) Node at the specified element index. */
// 这里查询使用的是先从中间分一半查找
Node<E> node(int index) {
    // assert isElementIndex(index);
    // 从前半部分进行查找
    if (index < (size >> 1)) {
        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;
    }
}

总结：
这里查询使用的是先从中间分一半查找，根据下标是否超过链表长度的一半，来选择从前半部分开始遍历查找，还是从后半部分开始遍历查找：
① 如果 index 小于 size 的一半，就从首节点开始遍历，一直获取 x 的下一个节点
② 如果 index 大于或等于 size 的一半，就从尾节点开始遍历，一直获取 x 的上一个节点

五、双端队列操作方法的源码剖析

1、offerFirst(E e) 方法，将元素添加到首部

/**
 * Inserts the specified element at the front of this list. * * @param e the element to insert * @return {@code true} (as specified by {@link Deque#offerFirst}) * @since 1.6 */
public boolean offerFirst(E e) {
    addFirst(e);
    return true;
}

2、offerLast(E e) 方法，将元素添加到尾部

 /**
  * Inserts the specified element at the end of this list.  *  * @param e the element to insert  * @return {@code true} (as specified by {@link Deque#offerLast})  * @since 1.6  */
 public boolean offerLast(E e) {
     addLast(e);
     return true;
 }

3、peekFirst() 方法，获取此集合列表的第一个元素值

/**
  * Retrieves, but does not remove, the first element of this list,  * or returns {@code null} if this list is empty.  *  * @return the first element of this list, or {@code null}  *         if this list is empty  * @since 1.6  */
 public E peekFirst() {
     final Node<E> f = first;
     return (f == null) ? null : f.item;
  }

4、peekLast() 方法，获取此集合列表的最后一个元素值

/**
 * Retrieves, but does not remove, the last element of this list, * or returns {@code null} if this list is empty. * * @return the last element of this list, or {@code null} *         if this list is empty * @since 1.6 */
public E peekLast() {
    final Node<E> l = last;
    return (l == null) ? null : l.item;
}

5、pollFirst() 方法，删除此集合列表的第一个元素，如果为 null，则会返回 null

/**
 * Retrieves and removes the first element of this list, * or returns {@code null} if this list is empty. * * @return the first element of this list, or {@code null} if *     this list is empty * @since 1.6 */
public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

6、pollLast() 方法 ，删除此集合列表的最后一个元素，如果为 null 会返回 null

/**
   * Retrieves and removes the last element of this list,   * or returns {@code null} if this list is empty.   *   * @return the last element of this list, or {@code null} if   *     this list is empty   * @since 1.6   */
  public E pollLast() {
      final Node<E> l = last;
      return (l == null) ? null : unlinkLast(l);
  }

7、push(E e) 方法，将元素添加到此集合列表的首部

/**
  * Pushes an element onto the stack represented by this list.  In other  * words, inserts the element at the front of this list.  *  * <p>This method is equivalent to {@link #addFirst}.  *  * @param e the element to push  * @since 1.6  */
 public void push(E e) {
     addFirst(e);
 }

8、pop() 方法，删除并返回此集合列表的第一个元素，如果为null会抛出异常

/**
 * Pops an element from the stack represented by this list.  In other * words, removes and returns the first element of this list. * * <p>This method is equivalent to {@link #removeFirst()}. * * @return the element at the front of this list (which is the top *         of the stack represented by this list) * @throws NoSuchElementException if this list is empty * @since 1.6 */
 //删除首部，如果为null会抛出异常
public E pop() {
    return removeFirst();
}

9、removeFirstOccurrence(Object o)方法，删除集合中元素值等于o的第一个元素值

/**
 * Removes the first occurrence of the specified element in this * list (when traversing the list from head to tail).  If the list * does not contain the element, it is unchanged. * * @param o element to be removed from this list, if present * @return {@code true} if the list contained the specified element * @since 1.6 */
public boolean removeFirstOccurrence(Object o) {
    return remove(o);
}

注：removeFirstOccurrence() 和 remove 方法是一样的，它的内部调用了 remove 方法

10、removeLastOccurrence(Object o)方法，删除集合中元素值等于o的最后一个元素值

/**
 * Removes the last occurrence of the specified element in this * list (when traversing the list from head to tail).  If the list * does not contain the element, it is unchanged. * * @param o element to be removed from this list, if present * @return {@code true} if the list contained the specified element * @since 1.6 */
public boolean removeLastOccurrence(Object o) {
    //因为LinkedList中的元素允许存在null值，所以需要进行null判断
    if (o == null) {
    	// 从最后一个节点往前开始遍历
        for (Node<E> x = last; x != null; x = x.prev) {
            if (x.item == null) {
            	 // 调用unlink方法删除指定节点
                unlink(x);
                return true;
            }
        }
    } else {
    	// 否则元素不为空，进行遍历
        for (Node<E> x = last; x != null; x = x.prev) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

六、ArrayList 和 LinkedList 的区别

1、二者线程都不安全，但是效率比 Vector 的高；

2、ArrayList 底层是以数组的形式保存数据，随机访问集合中的元素比 LinkedList 快（LinkedList 要移动指针）；

3、LinkedList 内部以链表的形式保存集合里面数据，它随机访问集合中的元素性能比较慢，但是新增和删除时速度比 ArrayList 快（ArrayList 要移动数据）。

本文转自 https://zhuanlan.zhihu.com/p/210732993，如有侵权，请联系删除。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1641152.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

领域驱动设计（DDD）笔记（三）后端工程架构

领域驱动设计（DDD）笔记（三）后端工程架构

文章链接 领域驱动设计（DDD）笔记（一）基本概念-CSDN博客领域驱动设计（DDD）笔记（二）代码组织原则-CSDN博客领域驱动设计（DDD）笔记（三）后端工程架构-CSDN博客前导 领域驱动设计（Domain Driven Design，简称DDD）是业内主导的业务工程理论。它在各中权威人士被广泛讨论…
阅读更多...
C++ | Leetcode C++题解之第67题二进制求和

C++ | Leetcode C++题解之第67题二进制求和

题目&#xff1a; 题解&#xff1a; class Solution { public:string addBinary(string a, string b) {string ans;reverse(a.begin(), a.end());reverse(b.begin(), b.end());int n max(a.size(), b.size()), carry 0;for (size_t i 0; i < n; i) {carry i < a.siz…
阅读更多...
为什么 IP 地址通常以 192.168 开头？(精简版)

为什么 IP 地址通常以 192.168 开头？(精简版)

网络通讯的本质就是收发数据包。如果说收发数据包就跟收发快递一样。IP地址就类似于快递上填的收件地址和发件地址一样&#xff0c;路由器就充当快递员的角色&#xff0c;在这个纷繁复杂的网络世界里找到该由谁来接收这个数据包&#xff0c;所以说&#xff1a;IP地址就像快递里…
阅读更多...
vue2项目webpack3.x打包文件分割优化加载

vue2项目webpack3.x打包文件分割优化加载

vue2项目webpack3.x打包文件分割优化加载 0. 项目目录和依赖信息1. 开启 gzip&#xff08;建议&#xff09;2. vue2项目配置懒加载&#xff08;建议&#xff09;3. 拆分 vendor 包注意&#xff1a;webpack3使用CommonsChunkPlugin实现 本文使用 3 种方案进行叠加优化 优先级按以…
阅读更多...
多级留言/评论的功能实现——SpringBoot3后端篇

多级留言/评论的功能实现——SpringBoot3后端篇

目录 功能描述数据库表设计后端接口设计实体类entity 完整实体类dto 封装请求数据dto 封装分页请求数据vo 请求返回数据 Controller控制层Service层接口实现类 Mapper层Mybatis 操作数据库 补充&#xff1a;返回的数据结构自动创建实体类 最近毕设做完了&#xff0c;开始来梳理…
阅读更多...
题目：线性代数

题目：线性代数

问题描述&#xff1a; 解题思路&#xff1a; 列相乘&#xff0c;然后行相加。 注意点&#xff1a;由于元素数据范围最大为1e6&#xff0c;两个元素相乘乘积最大为1e12&#xff0c;如果元素类型为int则在乘的过程中就会爆炸&#xff0c;所以需要开long long类型。 AC代码…
阅读更多...
深度学习500问——Chapter08：目标检测（6）

深度学习500问——Chapter08：目标检测（6）

文章目录 8.3.7 RetinaNet 8.3.7 RetinaNet 研究背景 Two-Stage 检测器&#xff08;如Faster R-CNN、FPN&#xff09;效果好&#xff0c;但速度相对慢。One-Stage 检测器&#xff08;如YOLO、SSD&#xff09;速度快&#xff0c;但效果一般。 作者对one-stage检测器准确率不高…
阅读更多...
有限单元法-编程与软件应用（崔济东、沈雪龙）【PDF下载】

有限单元法-编程与软件应用（崔济东、沈雪龙）【PDF下载】

专栏导读 作者简介&#xff1a;工学博士&#xff0c;高级工程师&#xff0c;专注于工业软件算法研究本文已收录于专栏&#xff1a;《有限元编程从入门到精通》本专栏旨在提供 1.以案例的形式讲解各类有限元问题的程序实现&#xff0c;并提供所有案例完整源码&#xff1b;2.单元…
阅读更多...
JAVA基础之线程池原理与源码简读

JAVA基础之线程池原理与源码简读

线程 线程是调度CPU资源的最小单位&#xff0c;线程模型分为KLT和ULT模型&#xff0c;JVM使用的KLT模型java线程与OS线程保持1:1的映射关系&#xff0c;也就是说每一个java线程对应操作系统一个线程。Java线程有以下几种生命状态&#xff1a; NEW&#xff1a;新建状态RUNNABL…
阅读更多...
STM32——IWDG（独立看门狗）

STM32——IWDG（独立看门狗）

技术笔记&#xff01; 1. IWDG&#xff08;Independent watchdog)&#xff0c;即独立看门狗 本质&#xff1a;能产生系统复位信号的计算器。 特性&#xff1a;递减计算器&#xff1b;时钟有独立的RC振荡器提供&#xff08;可在待机和停止模式下运行&#xff09;&#xff1b…
阅读更多...
数据结构与算法---线性表

数据结构与算法---线性表

线性表 1.顺序表 需求分析 /*创建顺序表具体功能&#xff1a;初始化顺序表销毁顺序表获取顺序表元素个数输出顺序表中的内容自动扩容增 --- 插入数据&#xff08;包含了尾部添加功能&#xff09;删 --- 删除数据&#xff08;包含了尾部删除功能&#xff09;改 --- 修改数据查…
阅读更多...
UDP编程流程（UDP客户端、服务器互发消息流程）

UDP编程流程（UDP客户端、服务器互发消息流程）

一、UDP编程流程 1.1、 UDP概述 UDP&#xff0c;即用户数据报协议&#xff0c;是一种面向无连接的传输层协议。相比于TCP协议&#xff0c;UDP具有以下特点&#xff1a; 速度较快&#xff1a;由于UDP不需要建立连接和进行复杂的握手过程&#xff0c;因此在传输数据时速度稍快…
阅读更多...
【深度学习】第二门课 改善深层神经网络 Week 2 3 优化算法、超参数调试和BN及其框架

【深度学习】第二门课 改善深层神经网络 Week 2 3 优化算法、超参数调试和BN及其框架

&#x1f680;Write In Front&#x1f680; &#x1f4dd;个人主页&#xff1a;令夏二十三 &#x1f381;欢迎各位→点赞&#x1f44d; 收藏⭐️ 留言&#x1f4dd; &#x1f4e3;系列专栏&#xff1a;深度学习 &#x1f4ac;总结&#xff1a;希望你看完之后&#xff0c;能对…
阅读更多...
ASV1000视频监控平台：通过SDK接入海康网络摄像机IPC

ASV1000视频监控平台：通过SDK接入海康网络摄像机IPC

目录 一、为何要通过SDK接入海康网络摄像机 &#xff08;一&#xff09;海康网络摄像机的SDK的功能 1、视频采集和显示 2、视频存储 3、视频回放 4、报警事件处理 5、PTZ控制 6、自定义设置 7、扩展功能 &#xff08;二&#xff09;通过SDK接入的好处&#xff08;相对…
阅读更多...
【1小时掌握速通深度学习面试3】RNN循环神经网络

【1小时掌握速通深度学习面试3】RNN循环神经网络

目录 12.描述循环神经网络的结构及参数更新方式&#xff0c;如何使用神经网络对序列数据建模? 13.循环神经网络为什么容易出现长期依赖问题? 14.LSTM 是如何实现长短期记忆功能的? 15.在循环神经网络中如何使用 Dropout ? 16.如何用循环神经网络实现 Seg2Seq 映射? …
阅读更多...
2024新版Java基础从入门到精通全套教程（含视频+配套资料）

2024新版Java基础从入门到精通全套教程（含视频+配套资料）

前言 Java基础是所有入门java的同学必过的一关&#xff0c;基础学习的牢固与否决定了程序员未来成就的高度。因此&#xff0c;基础学习的重要性不言而喻。 但是很多同学学习java基础知识&#xff0c;要么是学的太“基础”&#xff0c;就是只会各个知识点的简单概念和使用&…
阅读更多...
idea 新建spring maven项目、ioc和依赖注入

idea 新建spring maven项目、ioc和依赖注入

文章目录 一、新建Spring-Maven项目二、在Spring-context使用IOC和依赖注入 一、新建Spring-Maven项目 在pom.xml文件中添加插件管理依赖 <build><plugins><plugin><artifactId>maven-compiler-plugin</artifactId><version>3.1</ver…
阅读更多...
恶补《操作系统》4_2——王道学习笔记

恶补《操作系统》4_2——王道学习笔记

4.1_5 文件存储空间管理 1、存储空间的划分与初始化 文件卷&#xff08;逻辑卷&#xff09;的概念目录区与文件区 2、几种管理方法 空闲表法&#xff1a;首位置长度&#xff0c;回收时注意修改空闲链表法&#xff08;空闲盘块链、空闲盘区链&#xff09;位示图法 成组链接法…
阅读更多...
2024年 Java 面试八股文——Mybatis篇

2024年 Java 面试八股文——Mybatis篇

目录 1. 什么是Mybatis&#xff1f; 2. 说说Mybatis的优缺点 3. Xml映射文件中&#xff0c;都有哪些标签 4. #{}和&{}有什么区别 5. Mybatis是如何进行分页的,分页插件的原理是什么 6. Mybatis是如何将sql执行结果封装为目标对象并返回的&#xff1f; 7. Mybatis是怎…
阅读更多...
JavaWeb--1.Servlet

JavaWeb--1.Servlet

Servlet&#xff08;基础&#xff09; 1、配置依赖&#xff1a; ​ 在pom.xml文件中加入相关依赖 <dependencies><dependency><groupId>jakarta.servlet</groupId><artifactId>jakarta.servlet-api</artifactId><version>5.0.0&l…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023