集合之ArrayList源码学习

最新推荐文章于 2025-01-16 06:30:00 发布
最新推荐文章于 2025-01-16 06:30:00 发布
阅读量127 收藏
点赞数 1
分类专栏： Java基础 Java集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/juemuren123/article/details/119711420
版权
本文详细探讨了ArrayList的源码，包括其继承关系、属性、构造方法和主要操作。重点分析了ArrayList的扩容机制，添加、删除元素的方法，以及查询和遍历元素的实现。ArrayList使用数组作为底层数据结构，支持高效随机访问，但在多线程环境下不安全。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

集合之ArrayList源码学习

ArrayList是日常开发经常用到的数据结构，底层是用数组实现的List，相当于单纯的数组相比，ArrayList有动态扩容的能力并提供了很多动态数组的方法。

继承关系

在这里插入图片描述
ArrayList继承了AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable等接口。
ArrayList实现了List，提供了基础的添加、删除、查找、遍历等操作。
ArrayList实现了RandomAccess，提供了随机访问的能力。
ArrayList实现了Cloneable，可以被克隆。
ArrayList实现了Serializable，可以被序列化。

属性

    private static final int DEFAULT_CAPACITY = 10;
    //空的数组，这种是通过new ArrayList(0)创建时用的是这个空数组。
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
    *也是空数组，这种是通过new ArrayList()创建时用的是这个空数组，
    *与EMPTY_ELEMENTDATA的区别是在添加第一个元素时使用这个空数组的会初始化为DEFAULT_CAPACITY（10）个元素。
    **/
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //真正存放元素的地方，使用transient是为了不序列化这个字段。
    transient Object[] elementData; // non-private to simplify nested class access
    //真正存储元素的个数，不代表elementData的大小
    private int size;

ArrayList底层是一个Object数组，存储元素的大小有专门的size字段计算，因为存储元素的elementData数组是动态扩容的，可能没有存储数组。
属性定义了两个空数组EMPTY_ELEMENTDATA 和DEFAULTCAPACITY_EMPTY_ELEMENTDATA ，EMPTY_ELEMENTDATA 用在构造器为new ArrayList(0)创建时用的是这个空数组，DEFAULTCAPACITY_EMPTY_ELEMENTDATA用在不传参构造使用。在扩容的时DEFAULTCAPACITY_EMPTY_ELEMENTDATA 默认是扩展为10，EMPTY_ELEMENTDATA 无这个特性

elementData方法被transient 标识。使用transient是为了不序列化这个字段。ArrayList实现序列化反序列化方法writeObject、readObject

//序列化
private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
    // 防止序列化期间有修改
    int expectedModCount = modCount;
    // 写出非transient非static属性
    s.defaultWriteObject();
    // 写出元素个数
    s.writeInt(size);
    // 依次写出元素
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }
    // 期间有修改，则抛出异常
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    // 声明为空数组
    elementData = EMPTY_ELEMENTDATA;
    // 读入非transient非static属性
    s.defaultReadObject();
    // 读入元素个数，没什么用，只是因为写出的时候写了size属性，读的时候也要按顺序来读
    s.readInt();

    if (size > 0) {
        // 计算容量
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        // 检查是否需要扩容
        ensureCapacityInternal(size);
        
        Object[] a = elementData;
        // 依次读取元素到数组中
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

查看writeObject()方法可知，先调用s.defaultWriteObject()方法，再把size写入到流中，再把元素一个一个的写入到流中。
一般地，只要实现了Serializable接口即可自动序列化，writeObject()和readObject()是为了自己控制序列化的方式，这两个方法必须声明为private，在java.io.ObjectStreamClass#getPrivateMethod()方法中通过反射获取到writeObject()这个方法。
在ArrayList的writeObject()方法中先调用了s.defaultWriteObject()方法，这个方法是写入非static非transient的属性，在ArrayList中也就是size属性。同样地，在readObject()方法中先调用了s.defaultReadObject()方法解析出了size属性。
elementData定义为transient的优势，自己根据size序列化真实的元素，而不是根据数组的长度序列化元素，减少了空间占用。

常用的构造方法

ArrayList(int initialCapacity)构造方法

传入初始容量，大于0就初始化elementData为对应大小，如果等于0就使用EMPTY_ELEMENTDATA空数组，如果小于0抛出异常。

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 初始容量大于0,初始化elementData的数组大小
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 初始容量等于0，使用空数组EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 小于0则抛出异常
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}

ArrayList()构造方法

不传初始容量，初始化为DEFAULTCAPACITY_EMPTY_ELEMENTDATA空数组。会在后续的扩容时判断是DEFAULTCAPACITY_EMPTY_ELEMENTDATA的话就扩容为10；

public ArrayList() {
    // 无参构造方法，数组elementData赋值为有默认容器大小标识的空数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

ArrayList(Collection<? extends E> c)构造方法

传入集合并初始化elementData，这里会使用拷贝把传入集合的元素拷贝到elementData数组中，如果元素个数为0，则初始化为EMPTY_ELEMENTDATA空数组。

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

添加元素

添加元素的方法add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)等。

add(E e)方法

添加元素到数组尾部，平均时间复杂度为O(n)

public boolean add(E e) {
    // 校验是否需要扩容
    ensureCapacityInternal(size + 1);
    // 把元素插入到最后一位
    elementData[size++] = e;
    return true;
}
扩容机制详解
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //若当前的元素数组是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则日容器大小为10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            //扩容
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 新容量为旧容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 如果新容量发现比需要的容量还小，则以需要的容量为准
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
         // 如果新容量已经超过最大容量了，则使用最大容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 拷贝出来一个新数组,扩容完成
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

ArrayList扩容机制：

  1. 根据当前elementData的组数大小判断是否需要扩容，在数组可用空间不足的情况下扩容
  2. 当数组是DEFAULTCAPACITY_EMPTY_ELEMENTDATA时，初始容器大小为10
  3. 新容量是老容量的1.5倍（oldCapacity + (oldCapacity >> 1)），若加的容量比需要的容量还小，则以需要的容量为准
  4. 创建新容量的数组并把老数组拷贝到新数组

add(int index, E element)方法

添加元素到指定位置，平均时间复杂度为O(n)。

public void add(int index, E element) {
    // 判断是数组下标是否越界
    rangeCheckForAdd(index);
    // 判断是否需要扩容
    ensureCapacityInternal(size + 1);
    // 将index位置及其之后的元素往后挪一位，则index位置处就空出来了
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 元素插入到index的位置
    elementData[index] = element;
    // 大小增1
    size++;
}

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

addAll(Collection<? extends E> c)方法

将一个集合添加到ArrayList中

public boolean addAll(Collection<? extends E> c) {
    // 集合c转为数组
    Object[] a = c.toArray();
    int numNew = a.length;
    // 判断是否需要扩容
    ensureCapacityInternal(size + numNew);
    // c中元素全部拷贝到数组的最后
    System.arraycopy(a, 0, elementData, size, numNew);
    // 大小增加c的大小
    size += numNew;
    // 如果c不为空就返回true，否则返回false
    return numNew != 0;
}

删除元素

ArrayList提供了多个元素删除的方法：

remove(int index):删除指定下标位置元素
remove(Object o)、fastRemove(int index)：删除指定元素
removeAll(Collection<?> c)、retainAll(Collection<?> c)、batchRemove(Collection<?> c, boolean complement)等等

remove(int index)

删除指定下标位置的元素，并整理数组。时间复杂度为O(n)

public E remove(int index) {
    // 检查是否越界
    rangeCheck(index);
    modCount++;
    // 获取index位置的元素
    E oldValue = elementData(index);
    // 如果index不是最后一位，则将index之后的元素往前挪一位
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //数组拷贝，index只有的元素往前挪一位
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    // 删除最后一个元素，帮助GC
    elementData[--size] = null; // clear to let GC do its work

    // 返回删除的值
    return oldValue;
}

remove(Object o)、fastRemove(int index)

找出指定元素值第一次出现的位置，然后快速删除该位置的元素，时间复杂度为O(n)

public boolean remove(Object o) {
    if (o == null) {
        // 遍历数组，找到元素第一次出现的位置，并将其快速删除
        for (int index = 0; index < size; index++)
            // 如果要删除的元素为null，则以null进行比较，使用==
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        // 遍历数组，找到元素第一次出现的位置，并将其快速删除
        for (int index = 0; index < size; index++)
            // 使用equals()方法
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
    // 相对于remove方法，少了一个越界校验、
    modCount++;
    // 判断index是不是最后一位，index为最后一位的话，不能挪动。不是的话需要把后面的元素往前挪一位
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    // 将最后一个元素删除，帮助GC
    elementData[--size] = null; // clear to let GC do its work
}

retainAll(Collection<?> c)方法

求两个集合的交集。

public boolean retainAll(Collection<?> c) {
    // 集合c不能为null
    Objects.requireNonNull(c);
    // 调用批量删除方法，这时complement传入true，表示删除不包含在c中的元素
    return batchRemove(c, true);
}

/**
* 批量删除元素
* complement为true标识删除c中不包含的元素
* complement为false表示删除c中包含的元素
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    // 使用读写两个指针同时遍历数组
    // 读指针每次自增1，写指针放入元素的时候才加1
    // 这样不需要额外的空间，只需要在原有的数组上操作就可以了
    int r = 0, w = 0;
    boolean modified = false;
    try {
        // 遍历整个数组，如果c中包含该元素，则把该元素放到写指针的位置（以complement为准）
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // 正常来说r最后是等于size的，除非c.contains()抛出了异常
        if (r != size) {
            // 如果c.contains()抛出了异常，则把未读的元素都拷贝到写指针之后
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // 将写指针之后的元素置为空，帮助GC
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            // 新大小等于写指针的位置（因为每写一次写指针就加1，所以新大小正好等于写指针的位置）
            size = w;
            modified = true;
        }
    }
    // 有修改返回true
    return modified;
}

removeAll(Collection<?> c)

求两个集合的单方向差集，只保留当前集合中不在c中的元素，不保留在c中不在当前集体中的元素。

public boolean removeAll(Collection<?> c) {
    // 集合c不能为空
    Objects.requireNonNull(c);
    // 同样调用批量删除方法，这时complement传入false，表示删除包含在c中的元素
    return batchRemove(c, false);
}

元素查询、遍历

get(int index)

获取指定索引位置的元素，时间复杂度为O(1)。

public E get(int index) {
    // 是否越界
    rangeCheck(index);
    // 返回数组index位置的元素
    return elementData(index);
}

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

E elementData(int index) {
    return (E) elementData[index];
}

indexOf(Object o)、lastIndexOf

查询指定元素所在的下标位置。存在返回下标位置，不存在返回-1

    //找出元素第一次出现在数组中的下标位置
    public int indexOf(Object o) {
        if (o == null) {
            //从0开始遍历数组，找出第一个满足条件的下标并返回。null使用==
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    //找出最后一次出现在数组中的下标值
    public int lastIndexOf(Object o) {
        if (o == null) {
             //逆向操作
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

迭代器Iterator

ArrayList迭代器方法iterator()方法。可见next方法使用元素遍历。变更游标实现数组遍历

 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
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            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();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

总结

  1. ArrayList底层使用数组存储元素，当数组长度不够时进行扩容，扩容为原来的1.5倍。
  2. ArrayList支持随机访问，可以通过元素下标快速定位查询数据，时间复杂度O(1)。
  3. ArrayList提供了多种添加元素方法，在队尾加入时间复杂度为O(1),在指定位置添加需要挪动元素位置为O(n)。
  4. ArrayList删除元素跟添加相似，队尾删除O(1),队中删除要挪动元素时间复杂度为O(n)。
  5. ArrayList提供了两个集合交集、并集、单向差集的方法。retainAll(Collection<? extends E> c)、addAll(Collection<? extends E> c)、removeAll(Collection<? extends E> c)
  6. ArrayList是线程不安全的，当多个线程操作时可能存在线程不安全问题。
【JDk源码解析之一】ArrayList源码解析
怪盗基德
04-15 5148
1.ArrayList的继承关系如图所示： 2.宏观上说，ArrayList是基于动态数组实现的，数组具有按索引查找的特性，所以访问很快，适合经常查询的数据。 3.具体源码解析。    为什么说ArrayList是动态数组，这个可以看它的构造函数。如下图所示，有两个构造方法，存放元素的elementData是一个数组，同时被初始化。ArrayList的放的元素就是放      在这个
Collection集合之ArrayList源码学习记录
CuteFruit的博客
04-30 743
ArrayList实现了RandomAccess接口，此接口为标记接口，表明实现此接口的List实现类具有随机访问特性。一些适用于随机访问列表的的算法应用与顺序访问列表时，可能会有不同的表现。如果一个算法在应用到随机访问列表的性能高于顺序访问列表时，建议检查此接口，并对算法做出相应调整以满足性能需求。通常，如果循环A比循环B快的时候，就需要实现RandomAccess接口。
ArrayList源码学习
qq_44587299的博客
04-19 137
ArrayList是java的一个集合类，实现的是List接口。List接口下的实现类所表示的集合具有有序可重复的特点。下面进入到ArrayList源码中看看。
对ArrayList源码的学习
m0_62689730的博客
04-25 351
一.泛型的概述和基本使用 1.泛型：是一种特殊的类型，是一种创建对象或调用方法时才明确数据类型的特殊类型。参数化类型，把类型当参数一样传递 **2.泛型优点 A：把运行期间的问题提前到了编译期间 B：避免了强制类型转换 ｃｓａｓ ＊ｇｈｇｈｇｊｈｊｈｆ ...
ArrayList源码分析
05-05
ArrayList是Java集合框架中的一员，它是List...通过深入学习ArrayList的源码，我们可以更好地理解其工作原理，从而在实际开发中做出更优的选择，提升程序的效率和稳定性。同时，这也是提升Java编程技能的一个重要步骤。
Java进阶课程系列之ArrayList集合底层源码实战分析
06-16
? ArrayList?是一种变长的集合类，基于定长数组实现...本节课程会带着大家去学习集合底层源码是什么个结构，他在做什么事情，能做到什么事情，会出现的问题以及解决方法，希望同学能够仔细听，详细你会收到丰富的回报的
图解 | 最全面的 ArrayList 源码解析 (干货满满！！！)
小斜同学的博客
01-16 1026
在Java的集合体系中，List接口的实现类ArrayList是非常常用的容器类，比如把查询数据的结果通过ORM框架，将数据存储到ArrayList当中，下面来介绍一下ArrayList是如何实现的，注意下面所有分析均基于JDK8，不同版本可能会有差异。
ArrayList源码.zip
03-13
ArrayList是Java编程语言中最常用的集合...总之，这个“ArrayList源码.zip”文件是Java程序员学习和优化代码的宝贵资源，它揭示了ArrayList内部的工作机制，帮助我们提升编程技巧，更好地理解和利用这个强大的集合类。
【源码】ArrayList源码学习笔记
洋YANG的博客
03-12 1047
目录楔子一、基本数据结构1、缺点2、优点二、核心方法的原理0、基础构造方法1、add方法源码2、set方法源码3、get方法源码4、remove方法源码 楔子 对于Java开发者来说，不管是初级、中级，还是高级，一定都曾经被问道Java集合包里的东西，而ArrayList作为集合包中重要的一员，出现的频率也非常高，今天小七就从源码的角度，重新分析学习下ArrayList。 一、基本数据结构 ArrayList顾名思义，array就是数组的意思。在java中的数组，都是定长数组，所以ArrayList会有定长
ArrayList学习[常用方法|源码]
赵同学的博客
08-22 247
ArrayList 今天我们来详细看一下ArrayList的源码.首先我们来看一下ArrayList的实现和继承 public class ArrayList<E>extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable 面试常问问题! 为什么ArrayList查询比较快? 1.底层的数据结构 2.RandomAccess 快速访问 只是其标记作用 一、构
Java集合源码浅析（一） ： ArrayList
冷血之心的博客
04-12 1755
（尊重劳动成果，转载请注明出处：https://yangwenqiang.blog.youkuaiyun.com/article/details/105317442冷血之心的博客） 背景 一直都有这么一个打算，那就是将Java中常见集合的源码进行一个全面的梳理（尽管已经有很多人进行了梳理总结）。重复造轮子的意义就在于，笔者可以亲自去阅读与欣赏JDK集合源码，学习JDK设计者们那优雅的code风格。 那么，就...
ArrayList源码分析（基于JDK8）
热门推荐
Fighter168的专栏
03-12 2万+
ArrayList 源代码解读,以及ArrayList特点总结
TensorRT加速的YOLOv5智能监控平台：多线程多任务并行处理，视频监控与录像回放一体化管理
05-06
内容概要：本文详细介绍了如何使用TensorRT加速YOLOv5模型推理，并结合QT框架搭建一个多任务并行处理的智能监控平台。主要内容包括：YOLOv5与TensorRT的融合，通过将YOLOv5模型转换为ONNX格式并进一步转化为TensorRT引擎，从而大幅提升推理速度；QT框架的应用，利用其跨平台特性实现视频监控、录像回放、电子地图等多种功能；16路视频并行检测的具体实现，通过多线程机制和CUDA流的支持，确保系统的高效运行。此外，文章还探讨了模型热更新、网络流处理、日志记录等方面的优化措施。 适合人群：具备一定编程基础，尤其是熟悉C++、Python和深度学习框架的研究人员和技术开发人员。 使用场景及目标：适用于需要高效、智能监控解决方案的企业和个人开发者。主要目标是提高视频监控系统的效率和智能化水平，如安防监控、交通监测等领域。 其他说明：文中提供了大量代码示例，帮助读者更好地理解和应用所介绍的技术。同时强调了系统设计中的性能优化技巧，如内存管理和多线程调度等。
JiYuTrainer
05-06
反极域和远程机惨的好工具
基于Matlab GUI界面的电子双缝衍射实验模拟：缝宽、间距、电压与距离的参数设置与电子数目影响研究
05-06
内容概要：本文详细介绍了如何利用MATLAB的GUI界面模拟电子双缝衍射实验。通过创建自定义的GUI界面，用户可以输入缝宽a、双缝间距b、加速电压U、缝屏距离D以及电子数目n等参数，实时观察衍射图样的变化。文中不仅提供了详细的代码实现步骤，还解释了各个参数对衍射图样的具体影响，如缝宽a的变化会影响条纹宽度，加速电压U的变化会影响条纹间距等。此外，文章还讨论了一些特殊情况下（如缝间距过大）的非预期现象及其背后的物理原因。 适合人群：物理学专业学生、教师以及对量子力学感兴趣的科研工作者。 使用场景及目标：①作为教学辅助工具，帮助学生更直观地理解电子双缝衍射实验及其背后的物理原理；②作为一种研究手段，探索不同参数条件下电子双缝衍射的具体表现形式。 其他说明：作者提醒使用者不要将电子数目n设得过高以免造成程序运行缓慢，并指出了一些常见的错误配置可能导致的异常情况。同时，提供了一个GitHub链接供有兴趣的读者进一步探讨和改进。
实训商业源码-qui-pure.v2.5-毕业设计.zip
最新发布
05-06
实训商业源码-qui-pure.v2.5-毕业设计.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值