【Java进阶之路】ArrayList源码分析

news2024/11/19 23:39:23

概述

ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。

基础属性

//初始化容量
private static final int DEFAULT_CAPACITY = 10;
//空实例数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认大小的空实例数组，在第一次调用ensureCapacityInternal时会初始化长度为18
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存放元数据数组
transient Object[] elementData;
//数组当前的元素数量
private int size;

//带容量参数的构造函数
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    }
}

//不带容量参数则使用默认大小的空实例数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

一些基本属性，参考下图理解。

get方法

@SuppressWarnings("unchecked")
//直接根据索引位置返回元素
E elementData(int index) {
    return (E) elementData[index];
}

//根据索引获取元素
public E get(int index) {
    //校验索引是否越界
    rangeCheck(index);
    校验索引是否越界（底层elementData是数组）
    return elementData(index);
}

很简单，由于底层是数组实现的，先检查下索引是否越界，然后直接返回对应索引位置的元素即可。

set方法

//用指定的元素(element)替换指定位置( index)的元素
public E set(int index, E element) {
    rangeCheck(index);  //校验索引是否越界

    E oldValue = elementData(index); //1根据index获取指定位置的元素
    elementData[index] = element; //用传入的element替换index位置的元素
    return oldValue; //返回index位置原来的元素
}

  • 校验索引是否越界

  • 根据index获取指定位置的元素

  • 用传入的element替换index位置的元素

  • 返回index位置原来的元素

    ​

add方法

//增加一个元素
public boolean add(E e) {
    //将modCount+1,并校验添加元素是否需要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //在数组尾部添加元素，并将size+1
    elementData[size++] = e;
    return true;
}

//将指定的元素(element)插入此列表中的指定位置(index)。
//将index位置及后面的所有元素(如果有的话)向右移动一个位置
public void add(int index, E element) {
    //校验索引是否越界
    rangeCheckForAdd(index);
    //将modCount+1,并校验添加元素是否需要扩容
    ensureCapacityInternal(size + 1);
    将index位置及之后的所有元素向右移动-个位 置(为要添加的元素腾出1个位置)
    System.arraycopy(elementData, index, elementData, index + 1,
            size - index);
    elementData[index] = element;  //index位置填入要添加的元素
    size++;  //元素数量+1
}

add(E e)：

调用ensureCapacityInternal方法（下文有详解），如果数组还没初始化，则进行初始化；如果已经初始化了，则将modCount+1，并校验添加元素后是否需要扩容。
在elementData数组尾部添加元素即可（size位置）。

add(int index, E element)：

  • 检查索引是否越界，再调用ensureCapacityInternal方法，将modCount+1，并校验添加元素后是否需要扩容。

  • 将index位置及之后的所有元素向右移动一个位置（为要添加的元素腾出1个位置）。

  • 将index位置设置为element元素，并将size+1。

    ​

add(int index, E element)的过程如下图所示。

remove方法


//删除列表中index位置的元素，将index位置后面的所有元素向左移一个位置
public E remove(int index) {

    //校验索引是否越界
    rangeCheck(index);
    //修改次数+1
    modCount++;
    // index位置的元素，也就是将要被移除的元素
    E oldValue = elementData(index);
    
    //计算需要移动的元素个数，例口: size为10， index为9， 此时numMoved为0，则无需移动元素,
    //因为此时index为9的元素刚好是最后一个元素，直接执行下面的代码，将索引为9的元素赋值为空即可
    int numMoved = size - index - 1;
    //如果需要移动元素
    if (numMoved > 0)
        //将index+1位置及之后的所有元素，向左移动一个位置
        System.arraycopy(elementData, index+1, elementData, index,
                numMoved);
    //将size-1位置的元素赋值为空(因为. 上面将元素左移了，所以size-1位 置的元素为重复的，将其移除)
    elementData[--size] = null;
    //返回index位置原来的元素
    return oldValue;
}

//如果存在与入参相同的元素，则从该列表中删除指定元素的第一个匹配项;如果列表不包含元素，则不变。
public boolean remove(Object o) {
    //如果入参元素为空，则遍历数组查找是否存在元素为空，
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //如果存在则调用fastRemove将该元素移除，
                fastRemove(index);
                //并返回true表示移除成功
                return true;
            }
        //如果入参元素不为空，则遍历数组查找是否存在元素与入参元素使用equals比较返回true
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                //如果存在则调用fastRemove将该元素移除，
                fastRemove(index);
                //并返回true表示移除成功
                return true;
            }
    }
    //不存在目标元素，返回false
    return false;
}

//供上面的remove方法调用，直接删除掉index位置的元素；与remove(int index)方法一样
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

remove(int index)：

  • 检查索引是否越界，将modCount+1，拿到索引位置index的原元素。
  • 计算需要移动的元素个数。
  • 如果需要移动，将index+1位置及之后的所有元素，向左移动一个位置。
  • 将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）。

remove(Object o)：

  • 如果入参元素为空，则遍历数组查找是否存在元素为空，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功。
  • 如果入参元素不为空，则遍历数组查找是否存在元素与入参元素使用equals比较返回true，如果存在则调用fastRemove将该元素移除，并返回true表示移除成功。
    *否则，不存在目标元素，则返回false。

调用remove方法， 会， 且只会 删除第一个与传入对象通过equals方法判断相等的元素。如果传入null， 则删除掉第一个null元素
所以， 如果自定义类想要使用remove方法从列表删除某个指定值对象， 还需要实现该类型自己的equals方法才行！
且删除只能从后往前删，从前往后删，删不干净

fastRemove(int index)：跟remove(int index)类似

  • 将modCount+1，并计算需要移动的元素个数。
  • 如果需要移动，将index+1位置及之后的所有元素，向左移动一个位置。
  • 将size-1位置的元素赋值为空（因为上面将元素左移了，所以size-1位置的元素为重复的，将其移除）。

remove(int index)方法的过程如下图所示。

clear方法

//删除此列表中的所有元素。
public void clear() {
    //修改次数+1
    modCount++;
    
    //遍历数组将所有元素清空
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    //元素数量赋0
    size = 0;
}

遍历数组将所有元素清空即可。

扩容

上文add方法在添加元素之前会先调用ensureCapacityInternal方法，主要是有两个目的：1.如果没初始化则进行初始化；2.校验添加元素后是否需要扩容。

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //校验当前数组是否为DEFAULTCAPACITY_EMPTY_ ELEMENTDATA,
    //如果是则将minCapacity设为DEFAULT_CAPACITY,
    //主要是给DEFAULTCAPACITY_EMPTY_ELEMENTDATA设置初始容量
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//修改次数+1

    //如果添加该元素后的大小超过数组大小，则进行扩容
    if (minCapacity - elementData.length > 0)
        //进行扩容
        grow(minCapacity);
}

//数组允许的最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

//数组扩容
private void grow(int minCapacity) {
    //原来的容量
    int oldCapacity = elementData.length;
    //新容量 = 老容量 + 老容量/2
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果新容量比minCapacity小，
    if (newCapacity - minCapacity < 0)
        //则将新容量设为minCapacity,兼容初始化情况
        newCapacity = minCapacity;
    //如果新容量比最大允许容量大，
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //则调用hugeCapacity方法设置个合适的容量
        newCapacity = hugeCapacity(minCapacity);
    //将原数组元素拷贝到一个容量为newCapacity的新数组(使用System.arraycopy)，
    //并且将elementData设置为新数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError(); //越界
    //如果minCapacity大于MAX_ARRAY_SIZE, 则返回Integer.MAX_VALUE, 否则返回MAX_ARRAY_SIZE
    return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

ensureCapacityInternal(int minCapacity)：此方法就是为默认大小的空实例数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA而写的，判断数组是否为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是则将minCapacity设置为DEFAULT_CAPACITY。

ensureExplicitCapacity(int minCapacity)：将modCount+1，并校验minCapacity是否大于当前数组的容量，如果大于则调用grow方法进行扩容。

grow(int minCapacity)：
将数组新容量设置为老容量的1.5倍。
两个if判断，第一个是对DEFAULTCAPACITY_EMPTY_ELEMENTDATA初始化的兼容，第二个是对超过MAX_ARRAY_SIZE的兼容。
调用Arrays.copyOf方法创建长度为newCapacity的新数组，并将老数组的数据复制给新数组，并将elementData赋值为新数组。

grow(int minCapacity)的过程如下图所示。

Iterator()

 public Iterator<E> iterator() {
        return new Itr();
}

在调用list.iterator()的时候返回的是一个Itr对象，它是ArrayList中的一个内部类。
主要是实现了Iterator的三个方法：

hasNext()、next()、remove()

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        //expectedModCount的初值为modCount
        //设置此直的原因是：
        //在使用迭代器遍历集合的时候同时修改集合元素。因为ArrayList被设计成非同步的，所以理所当然会抛异常。
        int expectedModCount = modCount;
    
        public boolean hasNext() {
            //hasNext的判断条件为cursor!=size，就是当前迭代的位置不是数组的最大容量值就返回true
            return cursor != size;
        }
    
        @SuppressWarnings("unchecked")
        public E next() {
            //会先调用checkForComodification来检查expectedModCount和modCount是否相等
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
    
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
    
            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

坑一：删除一个null元素，只会删除第一个null元素；如果删除自定义元素，需要自己实现equals方法

//如果存在与入参相同的元素，则从该列表中删除指定元素的第一个匹配项;如果列表不包含元素，则不变。
public boolean remove(Object o) {
    //如果入参元素为空，则遍历数组查找是否存在元素为空，
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                //如果存在则调用fastRemove将该元素移除，
                fastRemove(index);
                //并返回true表示移除成功
                return true;
            }
        //如果入参元素不为空，则遍历数组查找是否存在元素与入参元素使用equals比较返回true
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                //如果存在则调用fastRemove将该元素移除，
                fastRemove(index);
                //并返回true表示移除成功
                return true;
            }
    }
    //不存在目标元素，返回false

调用remove方法， 会， 且只会 删除第一个与传入对象通过equals方法判断相等的元素。
如果传入null， 则删除掉第一个null元素。
所以， 如果自定义类想要使用remove方法从列表删除某个指定值对象， 还需要实现该类型自己的equals方法才行！

坑二：ArrayList是可以顺序删除节点的，但是！如果使用普通for循环，必须是从后往前删。不能从前往后删。

我们先来看一下【错误示范】：

ArrayList list=new ArrayList();
list.add("a");
list.add("b");
list.add("c");

System.out.println("删除前："+list.toString());

//顺序删除节点错误示范：从前往后删----会删不干净
for (int i=0;i<list.size();i++){
    list.remove(i);
}
System.out.println("删除后："+list.toString());

删除后结果

删除前：[a, b, c]
删除后：[b]

【出错原因分析】：
要顺序删除ArrayList的全部节点，如果我们从前往后的顺序删除，先删除【0】位置的数据，但是由于删除的时候是从后往前挪一位进行删除的，所以【0】的位置又会被下一个位置的数据覆盖上，实际上【0】还是有数据的。再画一张图来方便大家理解：

【正确的做法】：
要想顺序删除ArrayList的所有节点，且采用普通的for循环，那只能从后往前删，这样就不会出问题。

//通过一般for循环，必须从后往前删除！
for (int i=(arraylist.size()-1);i>=0;i--){
    arraylist.remove(i);
}

坑三：每当我们使用迭代器遍历元素时，如果使用迭代器以外的方法修改了元素内容（如删除元素），那就会抛出ConcurrentModificationException的异常。

错误示例：
ArrayList arrayList = new ArrayList();
arrayList.add(“a”);
arrayList.add(“b”);
arrayList.add(“c”);

    System.out.println("移除前：" + arrayList);
    Iterator<String> iterator = arrayList.iterator();
    while (iterator.hasNext()) {
        if ("c".equals(iterator.next())) {
            arrayList.remove("c");
        }
    }
    System.out.println("移除后：" + arrayList);

    //注意增强for使用的也是迭代器
    //所以一下这种操作也会报ConcurrentModificationException
    //for (Object o : arrayList) {
    //    arrayList.remove(o);
    //}
    //System.out.println("移除后2：" + arrayList);

报错
Exception in thread “main” java.util.ConcurrentModificationException
at java.util.ArrayList I t r . c h e c k F o r C o m o d i f i c a t i o n ( A r r a y L i s t . j a v a : 909 ) a t j a v a . u t i l . A r r a y L i s t Itr.checkForComodification(ArrayList.java:909) at java.util.ArrayList Itr.checkForComodification(ArrayList.java:909)atjava.util.ArrayListItr.next(ArrayList.java:859)
at com.xichuan.spring.dev.TestJava.main(TestJava.java:21)

先分析一下报错原因：
在我们使用 ArrayLis 的 iterator() 方法获取到迭代器进行遍历时，会把 ArrayList 当前状态下的 modCount 赋值给 ArrayListIterator类的 expectedModCount 属性。
如果我们在迭代过程中，使用了 ArrayList 的 remove()方法，这时 modCount 就会加 1 ，但是迭代器中的expectedModCount 并没有变化，当我们再使用迭代器的next()方法时，它就会报ConcurrentModificationException的错。

来自：ArrayList详解

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

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

相关文章

no main manifest attribute, in schoolspringboot-0.0.1-SNAPSHOT.jar

no main manifest attribute, in schoolspringboot-0.0.1-SNAPSHOT.jar

no main manifest attribute, in schoolspringboot-0.0.1-SNAPSHOT.jar 部署springboot项目jar包报错。解决方案&#xff1a; pom文件添加 <build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot…
阅读更多...
web前端项目使用electron打包成跨平台桌面端程序（Windows）

web前端项目使用electron打包成跨平台桌面端程序（Windows）

文章目录 Electron是什么&#xff1f;快速入门基本使用要求从github下载一个开源项目执行启动脚本运行项目安装electron依赖包编写electron入口文件&#xff0c;在package.json中配置入口文件路径和electron执行脚本启动electron脚本&#xff0c;运行electron应用 应用打包Wind…
阅读更多...
linux原生串口开发

linux原生串口开发

1.在linux环境下封装串口相关代码 &#xff08;1&#xff09;vi uartTool.c #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <stdarg.h> #include <string.h> #include <termios.h> #include <unistd.h> #…
阅读更多...
thinkphp 上传图片

thinkphp 上传图片

public function upload_img(){// 读取图片资源// 存储路径$path "uploads/avatar";$file request()->file(background_img);// 存储图片$info $file->rule(uniqid)->move($path);// 存储成功if ($info) {//获取到上传图片的路径名称$name_img $path . …
阅读更多...
计算机组成原理课程设计 报告

计算机组成原理课程设计 报告

在我的博客查看&#xff1a;https://chenhaotian.top/study/computer-composition-principles-course-design/ 计算机组成原理课程设计 报告 一、目的和要求 深入了解计算机各种指令的执行过程&#xff0c;以及控制器的组成&#xff0c;指令系统微程序设计的具体知识&#xf…
阅读更多...
plsql如何将表导出excel，同时表头是中文字段名

plsql如何将表导出excel，同时表头是中文字段名

1、导出表中所有的字段名和对应注释&#xff0c;导出ecxel。 SELECT t.column_name,t.comments FROM user_col_comments t WHERE TABLE_NAMEHT_ORDER_INFO; 2、根据导出的excel自动生成查询的SQL。 3、根据SQL进行导出。
阅读更多...
【菜鸟の笔记_利用Excel自动总结表格数据_自动链接word文本】

【菜鸟の笔记_利用Excel自动总结表格数据_自动链接word文本】

自动更新总结表格数据 1. 撰写原因2. 解决的问题3. Excel自动总结表格数据内容&#xff08;一段话&#xff09;。3.1问题引出3.2解决方式 4.Excel数据、总结内容&#xff0c;自动链接更新Word文本 1. 撰写原因 【GPT的答案】利用Excel自动总结表格数据有以下好处&#xff1a; …
阅读更多...
mmc记录

mmc记录

1、获取csd&#xff0c;也就是DSR寄存器 说是应该可以获取块长度、卡存储容量等&#xff0c;但是在8953上&#xff0c;没看到这个日志 参考&#xff1a; 一、有6个主要的和寄存器 1、OCR寄存器 描述了存储卡的Vdd电压描述 &#xff0c;总共32Bit Bit31 --- 卡上电状态位&…
阅读更多...
【已解决】JavaScript为控件绑定事件死活不生效

【已解决】JavaScript为控件绑定事件死活不生效

本博文源于最近操作的JavaScript一个诡异的事情。我在用js一个动态生成的按钮&#xff0c;然后想要为其绑定一个alert的事件&#xff0c;结果发现控制台给我报未定义的错误&#xff0c;我慌的不要要的&#xff0c;经过长时间胡乱尝试终于解决了。 问题再现 dataHtml "&…
阅读更多...
ModaHub魔搭社区：AI原生云向量数据库Zilliz Cloud数据类型JSON

ModaHub魔搭社区：AI原生云向量数据库Zilliz Cloud数据类型JSON

JSON 全称为 JavaScript Object Notation，是一种轻量级且易于使用的文本数据格式。JSON 字段由键值对组成，其中每个键是一个字符串，其相应的值可以是数字、字符串、布尔值、列表或数组。Zilliz Cloud 支持将字段以字典的形式插入到集群的 Collection 中。 以下示例代码展…
阅读更多...
快速小巧的粘贴应用程序Hasty Paste

快速小巧的粘贴应用程序Hasty Paste

什么是 Hasty Paste? Hasty Paste 是一个快速粘贴文本并共享的地方&#xff0c;主要用于共享调试日志等&#xff0c;以帮助开发人员提供技术支持。该项目的目标是既快又小。 命令行安装 在群晖上以 Docker 方式安装。 官方的镜像没有发布在 docker hub&#xff0c;而是在 gh…
阅读更多...
（超详解）----＞＞ 动态内存管理

（超详解）----＞＞ 动态内存管理

目录 本章重点 1&#xff1a;malloc,calloc,realloc,free 函数 2:常见动态内存错误 3&#xff1a;几道经典的笔试题 1&#xff1a;malloc&#xff0c;calloc&#xff0c;realloc&#xff0c;free函数 首先我们平时所创建的变量和数组都是在栈区上开辟的内存&#xff0c;空间开…
阅读更多...
Maven的exec插件

Maven的exec插件

Maven的exec插件介绍 利用maven的exec插件可以执行系统和Java程序。 官网资源 exec插件官网&#xff1a;https://www.mojohaus.org/exec-maven-plugin/java-mojo.html Goals exec:exec表示在一个单独的进程内执行系统和Java程序。 exec:java表示在当前的Java虚拟机内执行J…
阅读更多...
基于FPGA的一维卷积神经网络算法实现（1D-CNN、BNN的FPGA加速实现）

基于FPGA的一维卷积神经网络算法实现（1D-CNN、BNN的FPGA加速实现）

文章目录 概要网络结构一维卷积介绍&#xff08;科普性质&#xff09;FPGA架构FPGA端口定义操作步骤结果演示总结 概要 本文介绍一种基于FPGA的1维卷积神经网络算法加速实现的方案&#xff0c;其中为了进一步提升运算速度&#xff0c;除了第一层卷积采用的是普通卷积运算&…
阅读更多...
带你认识从 “�“ 到 “锟斤拷“ 错误编码

带你认识从 “�“ 到 “锟斤拷“ 错误编码

以一首五言绝句作为开篇&#xff0c;你知道背后说的是什么吗&#xff1f; 手持两把锟斤拷 口中疾呼烫烫烫 脚踏千朵屯屯屯 笑看万物锘锘锘 &#xfffd; 为何物&#xff1f; 在前不久石头哥的这篇文章中 —— 你可能也会掉进这个简单的 String 的坑&#xff0c;讲述了因字…
阅读更多...
【sgUploadTray】上传托盘自定义组件，可实时查看上传列表进度

【sgUploadTray】上传托盘自定义组件，可实时查看上传列表进度

【sgUploadTray】上传托盘自定义组件&#xff0c;可实时查看上传列表进度 特性&#xff1a; 可以全屏可以还原尺寸可以最小化可以回到右下角默认位置支持删除队列数据 sgUploadTray源码 <template><div :class"$options.name" :show"show" :size…
阅读更多...
架构训练营学习笔记3-5：消息队列备选架构设计实战

架构训练营学习笔记3-5：消息队列备选架构设计实战

本文属于架构训练营学习笔记系列&#xff1a;模块3的案例讲解 总的来说&#xff0c;这篇从更高的维度去讲&#xff0c;而不是关注消息队列的常见问题&#xff1a;比如消息如何发送&#xff0c;消息如何不丢失 &#xff0c;消息如何不重复。总体上分为2部分&#xff1a;利益干系…
阅读更多...
LaTex 1【字体、符号、表格】

LaTex 1【字体、符号、表格】

​&#xff08;上一期已经安装完软件&#xff0c;但是突然出现了一点子问题不会解决&#xff0c;先用overleaf来学习吧&#xff0c;网站还是很给力的&#xff09; 关键字部分&#xff1a; \quad:代表空格【无论你打多少个空格都不是空格&#xff0c;要输入“\quad”】 字体部分…
阅读更多...
github进不去的解决办法

github进不去的解决办法

github就凭运气进吧&#xff0c;偶尔能进去。 介绍几个可以快速进的办法&#xff1a; 第一个&#xff0c;安装插件&#xff1a;&#xff08;在microsoft搜索watt toolkit插件并安装&#xff09; 然后勾选github选项&#xff1a; 接着返回你github网站就可以了。 第二个&#…
阅读更多...
简单工厂模式详解

简单工厂模式详解

文章目录 前言一、简单工厂模式定义二、举个例子三、简单工厂模式的缺点总结 前言 本篇我们了解一下简单工厂模式&#xff0c;它是设计模式的雏形&#xff0c;是学习设计模式的开端&#xff0c;我会结合案例说明它的设计思路。 一、简单工厂模式定义 简单工厂模式并不是GoF23…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023