究竟是什么样的讲解数组算法的博客让我写了三小时？？？

版本说明

当前版本号[20231004]。

版本	修改说明
20231004	初版

版本说明
目录
二. 基础数据结构
- 2.1 数组
- - 1) 概述
  - 2) 动态数组
  - - 1）插入
    - - addlast 方法
      - 测试: addlast 方法
      - add 方法
      - 测试：add方法
      - addlast 方法与 add 方法合并版
      - get 方法
      - 测试：get 方法
    - 2）遍历
    - - 遍历方法1：consumer 遍历
      - 测试：consumer 遍历
      - 遍历方法2：迭代器遍历
      - 测试：迭代器遍历
      - 遍历方法3：stream 遍历
      - 测试：stream 遍历
    - 插入与遍历方法汇总
    - 插入与遍历测试类汇总
    - 3）删除
    - - 测试：删除方法
    - 4）扩容
    - 5）插入或删除性能
  - 3) 二维数组
  - - **测试**
  - 4) 局部性原理
  - - **对效率的影响**

二. 基础数据结构

2.1 数组

1) 概述

定义

在计算机科学中，数组是由一组元素（值或变量）组成的数据结构，每个元素有至少一个索引或键来标识

因为数组内的元素是连续存储的，所以数组中元素的地址，可以通过其索引计算出来，例如：

int[] array = {1,2,3,4,5}

知道了数组的数据起始地址 $B a se A dd ress$ ，就可以由公式 $B a se A dd ress + i * s i ze$ 计算出索引 $i$ 元素的地址

$i$ 即索引，在 Java、C 等语言都是从 0 开始
$s i ze$ 是每个元素占用字节，例如 $in t$ 占 $4$ ， $d o u b l e$ 占 $8$

小测试

byte[] array = {1,2,3,4,5}

已知 array 的数据的起始地址是 0x7138f94c8，那么元素 3 的地址是什么？

答：0x7138f94c8 + 2 * 1 = 0x7138f94ca

空间占用

Java 中数组结构为

8 字节 markword
4 字节 class 指针（压缩 class 指针的情况）
4 字节数组大小（决定了数组最大容量是 $2^{32}$ ）
数组元素 + 对齐字节（java 中所有对象大小都是 8 字节的整数倍[^12]，不足的要用对齐字节补足）

例如

int[] array = {1, 2, 3, 4, 5};

的大小为 40 个字节，组成如下

8 + 4 + 4 + 5*4 + 4(alignment)

随机访问性能

即根据索引查找元素，时间复杂度是 $O (1)$

2) 动态数组

1）插入

addlast 方法

意在把新增的元素加入到最后一个到动态数组里。

public class 动态数组
{
    private int size = 0;//逻辑大小
    private int capacity = 8;//所创建数组的数组容量
    private int[] array = new int[capacity];

       /**
     * 向最后位置 [size] 添加元素
     *
     * @param element 待添加元素
     */
    public void addlast(int element)
    {
        array[size] = element;
        size++;
    }
}

这个类具有以下特点：

size变量表示当前数组中已存储的元素数量。
capacity变量表示数组的容量，即可以容纳的最大元素数量。
array是一个整型数组，用于存储元素。
addlast(int element)方法用于在数组的末尾添加一个元素，并将size增加1。

测试: addlast 方法

这段代码作为一个JUnit测试类，在测试方法test1中，首先创建了一个动态数组对象，然后向数组中添加了5个元素，最后遍历数组并打印出每个元素的值。

package SuanFa.test;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import SuanFa.初始算法.第一章数组.动态数组;
import java.util.Arrays;

public class 动态数组Test {

    @Test
    public void test1()
    {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);
        dynamicarray.addlast(5);

        for(int i = 0; i < 5; i++)
        {
            System.out.println(dynamicarray.get(i));
        }
    }
}

测试结果如下：

注：接下来的所有方法中将只保留最主要的代码。

add 方法

意在向某一个索引里加入新值。

     /**
     * 向 [0 .. size] 位置添加元素
     *
     * @param index   索引位置
     * @param element 待添加元素
     */
    public void add(int index, int element)
    {
        if(index >=0 && index < size)
        {
            System.arraycopy(array, index, array, index+1, size - index);
            array[index] = element;
            size++;
        }
    }

这个类具有以下特点：

size变量表示当前数组中已存储的元素数量。
capacity变量表示数组的容量，即可以容纳的最大元素数量。
array是一个整型数组，用于存储元素。
add(int index, int element)方法用于在指定索引位置插入到指定索引位置，并确保索引在合法范围内（大于等于0且小于当前数组大小）。
如果索引合法，使用System.arraycopy()方法将原数组中从指定索引位置开始的元素向后移动一个位置，腾出空间来插入新元素。（复制 array 数组中从下标为 index 的元素复制到 array 数组的下标为 index+1 的元素上，并且只复制 size - index 的元素）
将新元素赋值给指定索引位置。
增加size变量的值，表示数组中已存储的元素数量增加了1。
如果索引不合法，该方法不会执行任何操作。

测试：add方法

这段代码作为一个JUnit测试类，在测试方法test1中，首先创建了一个动态数组对象，然后向数组中添加了4个元素，接着使用add方法在索引为2的位置插入了一个值为9的元素。最后遍历数组并打印出每个元素的值。

    @Test
    public void test2()
    {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);
        //dynamicarray.addlast(5);

        dynamicarray.add(2, 9);

        for(int i = 0; i < 5; i++)
        {
            System.out.println(dynamicarray.get(i));
        }
    }
}

测试结果如下：

addlast 方法与 add 方法合并版

由于addlast与add方法中，都有 array[下标] = element; size++; 这两段代码，于是也可以对他们进行优化，放在一起

     /**
     * 向 [0 .. size] 位置添加元素
     *
     * @param index   索引位置
     * @param element 待添加元素
     */
    public void add(int index, int element)
    {
        // 添加逻辑
        if(index >=0 && index < size)
        {
            // 向后挪动, 空出待插入位置
            System.arraycopy(array, index,
                    array, index+1, size - index);
        }
        array[index] = element;
        size++;
    }

       /**
     * 向最后位置 [size] 添加元素
     *
     * @param element 待添加元素
     */
    public void addlast(int element)
    {
        add(size, element);
    }

这个类具有以下特点：

size变量表示当前数组中已存储的元素数量。
capacity变量表示数组的容量，即可以容纳的最大元素数量。
array是一个整型数组，用于存储元素。
add(int index, int element)方法用于在指定索引位置插入一个元素。
addlast(int element)方法用于在数组的末尾添加一个元素。
add(int index, int element)方法将传入的元素插入到指定索引位置，并确保索引在合法范围内（大于等于0且小于当前数组大小）。
如果索引合法，使用System.arraycopy()方法将原数组中从指定索引位置开始的元素向后移动一个位置，腾出空间来插入新元素。
将新元素赋值给指定索引位置。
增加size变量的值，表示数组中已存储的元素数量增加了1。
如果索引不合法，该方法不会执行任何操作。
addlast(int element)方法调用add(int index, int element)方法，将元素添加到数组的末尾。
数组会自动调整大小以适应新元素的添加。

get 方法

意在接收一个整数参数 index ，返回数组中下标为 index 的元素。

        /**
     * 查询元素
     *
     * @param index 索引位置, 在 [0..size) 区间内
     * @return 该索引位置的元素
     */
    public int get(int index)
    {
        return array[index];
    }

这个类具有以下特点：

size变量表示当前数组中已存储的元素数量。
capacity变量表示数组的容量，即可以容纳的最大元素数量。
array是一个整型数组，用于存储元素。
查询方法get接收一个整数参数 index ，返回数组中下标为 index 的元素。

测试：get 方法

与测试：addlast 方法相同

    @Test
    public void test1()
    {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);
        dynamicarray.addlast(5);

        for(int i = 0; i < 5; i++)
        {
            System.out.println(dynamicarray.get(i));
        }
    }

2）遍历

遍历方法1：consumer 遍历

这段代码定义了一个名为 foreach 的方法，该方法接收一个 Consumer 类型的参数consumer。在方法内部，使用for循环遍历数组array，**对于每个元素，调用consumer的accept方法执行传入的操作。**最后，forEach方法没有返回值（void）。

    /**
     * 遍历方法1
     *
     * @param consumer 遍历要执行的操作, 入参: 每个元素
     */
 public void foreach(Consumer<Integer> consumer)
    {
        for(int i = 0; i<size ; i++)
   	   // 提供 array[i]
        // 返回 void
        {
            consumer.accept(array[i]);
        }
    }

测试：consumer 遍历

在该测试方法中，首先创建了一个动态数组对象dynamicarray，并向其中添加了5个元素。然后调用forEach方法遍历数组，对于每个元素，使用Lambda表达式打印出该元素的值。

public class 动态数组Test {

    @Test
    public void test3()
    {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);

        dynamicarray.forEach((element->
        {
            System.out.println(element);
        }));
    }
}

测试结果如下：

遍历方法2：迭代器遍历

该动态数组类实现了Iterable接口，并重写了iterator方法。

在类中重写了Iterable接口的iterator方法，返回一个Iterator对象，该对象实现了Iterator接口的方法hasNext和next。其中，hasNext方法用于判断是否还有下一个元素，next方法用于**返回当前元素并将指针移动到下一个元素。**由于没有给出数组元素的添加和删除操作，因此该类的迭代器只能从头到尾遍历一遍数组。

public class 动态数组 implements Iterable<Integer>
{
    private int size = 0;//逻辑大小
    private int capacity = 8;//容量
    private int[] array = new int[capacity];

        /**
     * 遍历方法2 - 迭代器遍历
     */
    @Override
    public Iterator<Integer> iterator(){
        return new Iterator<Integer>() {
            int i = 0;
            @Override
            public boolean hasNext() { // 有没有下一个元素
                return i < size;
            }

            @Override
            public Integer next() { // 返回当前元素，并移动到下一个元素
                return array[i++];
            }
       };
}

测试：迭代器遍历

使用增强for循环遍历数组，对于每个元素，打印出该元素的值。

@Test
    public void test4()
    {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);

        for(Integer element: dynamicarray)
        {
            System.out.println(element);
        }
    }

测试结果如下：

遍历方法3：stream 遍历

这段代码定义了一个名为stream的公共方法，该方法返回一个IntStream类型的对象。在方法内部，使用IntStream.of()方法创建一个包含数组array中前size个元素的IntStream流，并返回该流。

    /**
     * 遍历方法3 - stream 遍历
     *
     * @return stream 流
     */
public IntStream stream(){
        return IntStream.of(Arrays.copyOfRange(array,0,size));
    }

测试：stream 遍历

 @Test
    public void test5()
    {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(7);
        dynamicarray.addlast(2);
        dynamicarray.addlast(4);
        dynamicarray.addlast(1);

        dynamicarray.stream().forEach(element->{
            System.out.println(element);
        });
    }

测试结果如下：

插入与遍历方法汇总

以下这段代码定义了一个名为动态数组的类，汇总了所有方法，实现了Iterable接口。该类方法分别有：

add(int index, int element)：向指定索引位置添加元素的方法。如果索引有效（即大于等于0且小于当前大小），则将该位置及之后的元素向后移动一位，然后将新元素放置在指定索引位置上，并将大小加1。
addlast(int element)：向数组末尾添加元素的方法。调用add(size, element)实现。
get(int index)：获取指定索引位置的元素的方法。
foreach(Consumer<Integer> consumer)：遍历数组并对每个元素执行给定的消费者操作。
stream()：返回一个IntStream流，其中包含数组中的所有元素。使用Arrays.copyOfRange(array, 0, size)创建一个包含数组元素的新数组，并将其转换为IntStream流。

package SuanFa.初始算法.第一章数组;

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

public class 动态数组 implements Iterable<Integer> {
    private int size = 0;//逻辑大小
    private int capacity = 8;//容量
    private int[] array = new int[capacity];

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() { // 有没有下一个元素
                return i < size;
            }

            @Override
            public Integer next() { // 返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    public void add(int index, int element) {
        if (index >= 0 && index < size) {
            System.arraycopy(array, index,
                    array, index + 1, size - index);
        }
        array[index] = element;
        size++;
    }

    public void addlast(int element) {
        add(size, element);
    }

    public int get(int index) {
        return array[index];
    }

    public void foreach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));
    }
}

插入与遍历测试类汇总

该类包含了5个测试方法：

test1()：测试了向动态数组末尾添加元素的功能。首先创建了一个空的动态数组对象dynamicarray，然后连续调用addlast()方法向数组末尾添加了5个元素（1到5）。最后使用循环遍历数组并打印每个元素的值。
test2()：测试了在指定位置插入元素的功能。首先创建了一个空的动态数组对象dynamicarray，然后连续调用addlast()方法向数组末尾添加了5个元素（1到5）。接着调用add()方法在索引为2的位置插入了一个新元素9。最后使用循环遍历数组并打印每个元素的值。
test3()：测试了使用IntStream流遍历动态数组的功能。首先创建了一个空的动态数组对象dynamicarray，然后连续调用addlast()方法向数组末尾添加了5个元素（1到5）。接着调用stream()方法获取一个包含数组元素的IntStream流，并使用forEach()方法对每个元素执行打印操作。
test4()：测试了使用for-each循环遍历动态数组的功能。首先创建了一个空的动态数组对象dynamicarray，然后连续调用addlast()方法向数组末尾添加了5个元素（1到5）。接着使用for-each循环遍历数组，并在每次迭代中打印当前元素的值。
test5()：测试了在动态数组中间插入元素的功能。首先创建了一个空的动态数组对象dynamicarray，然后连续调用addlast()方法向数组末尾添加了4个元素（7、2、4、1）。最后使用流

package SuanFa.test;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;


import SuanFa.初始算法.第一章数组.动态数组;

import java.lang.annotation.ElementType;
import java.util.Arrays;


public class 动态数组Test {

    @Test
    public void test1() {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);
        dynamicarray.addlast(5);

        for (int i = 0; i < 5; i++) {
            System.out.println(dynamicarray.get(i));
        }
    }

    @Test
    public void test2() {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);

        dynamicarray.add(2, 9);

        for (int i = 0; i < 5; i++) {
            System.out.println(dynamicarray.get(i));
        }
    }

    @Test
    public void test3() {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);

        dynamicarray.stream().forEach(element -> {
            System.out.println(element);
        });
    }

    @Test
    public void test4() {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);

        for (Integer element : dynamicarray) {
            System.out.println(element);
        }
    }

    @Test
    public void test5() {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(7);
        dynamicarray.addlast(2);
        dynamicarray.addlast(4);
        dynamicarray.addlast(1);

        dynamicarray.stream().forEach(element -> {
            System.out.println(element);
        });
    }
}

3）删除

该方法接受一个整数参数 index，表示要删除元素的索引位置。

首先，它将要删除的元素保存在变量 removed 中。然后，使用 System.arraycopy() 方法将索引位置后的元素向前移动一位，覆盖掉要删除的元素。

接下来，通过将数组的大小减一来更新数组的大小。

最后，返回被删除的元素。

/**
 * 从 [0 .. size) 范围删除元素
 *
 * @param index 索引位置
 * @return 被删除元素
 */
public int remove(int index){
    // 保存要删除的元素
    int removed = array[index];
    
    // 将索引位置后的元素向前移动一位
    System.arraycopy(array, index + 1, array, index, size - index - 1);
    
    // 更新数组的大小
    size--;
    
    // 返回被删除的元素
    return removed;
}

测试：删除方法

这是一个J用于测试动态数组的测试类。首先创建一个dynamicarray的动态数组对象，然后使用addlast方法向数组中添加元素1、2、3、4和5。接着**调用remove方法移除索引为2的元素，并将其值赋给变量removed。**最后，使用stream方法和forEach遍历打印数组中的所有元素。

@Test
    public void test6() {
        动态数组 dynamicarray = new 动态数组();
        dynamicarray.addlast(1);
        dynamicarray.addlast(2);
        dynamicarray.addlast(3);
        dynamicarray.addlast(4);
        dynamicarray.addlast(5);

        int removed = dynamicarray.remove(2);
        System.out.println(removed);
        System.out.println("-----");
        dynamicarray.stream().forEach(element -> {
            System.out.println(element);
        });
    }

测试结果如下：

4）扩容

该方法首先进行容量检查。
如果当前数组的大小为0，即数组为空，那么将创建一个新的数组，其容量为capacity。
如果当前数组的大小等于容量，即数组已满，那么将通过将容量增加至原来的两倍来扩展数组。
然后，创建一个新的数组newArray，其容量为新的容量值。
接下来，使用System.arraycopy()方法将原数组中的元素复制到新数组中。
最后，将新数组赋值给原数组，完成数组的扩展操作。
这个方法通常用于动态数组的管理，以确保数组在插入元素时能够自动调整其容量大小，以适应不断增长的数据量。

  private void checkAndGrow() {
        // 容量检查
        if (size == 0) {
            array = new int[capacity];
        } else if (size == capacity) {
            capacity += capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0,
                    newArray, 0, size);
            array = newArray;
        }
    }

5）插入或删除性能

头部位置，时间复杂度是 $O (n)$

中间位置，时间复杂度是 $O (n)$

尾部位置，时间复杂度是 $O (1)$ （均摊来说）

3) 二维数组

int[][] array = {
    {11, 12, 13, 14, 15},
    {21, 22, 23, 24, 25},
    {31, 32, 33, 34, 35},
};

二维数组占 32 个字节，其中 array[0]，array[1]，array[2] 三个元素分别保存了指向三个一维数组的引用
三个一维数组各占 40 个字节
它们在内层布局上是连续的

更一般的，对一个二维数组 $A rr a y [m] [n]$

$m$ 是外层数组的长度，可以看作 row 行
$n$ 是内层数组的长度，可以看作 column 列
当访问 $A rr a y [i] [j]$ ， $0\leq i \lt m, 0\leq j \lt n$ 时，就相当于
- 先找到第 $i$ 个内层数组（行）
- 再找到此内层数组中第 $j$ 个元素（列）

测试

Java 环境下（不考虑类指针和引用压缩，此为默认情况），有下面的二维数组

byte[][] array = {
    {11, 12, 13, 14, 15},
    {21, 22, 23, 24, 25},
    {31, 32, 33, 34, 35},
};

已知 array 对象起始地址是 0x1000，那么 23 这个元素的地址是什么？

答：

起始地址 0x1000
外层数组大小：16字节对象头 + 3元素 * 每个引用4字节 + 4 对齐字节 = 32 = 0x20
第一个内层数组大小：16字节对象头 + 5元素 * 每个byte1字节 + 3 对齐字节 = 24 = 0x18
第二个内层数组，16字节对象头 = 0x10，待查找元素索引为 2
最后结果 = 0x1000 + 0x20 + 0x18 + 0x10 + 2*1 = 0x104a

4) 局部性原理

这里只讨论空间局部性

cpu 读取内存（速度慢）数据后，会将其放入高速缓存（速度快）当中，如果后来的计算再用到此数据，在缓存中能读到的话，就不必读内存了
缓存的最小存储单位是缓存行（cache line），一般是 64 bytes，一次读的数据少了不划算啊，因此最少读 64 bytes 填满一个缓存行，因此读入某个数据时也会读取其临近的数据，这就是所谓空间局部性

对效率的影响

比较下面 ij 和 ji 两个方法的执行效率

int rows = 1000000;
int columns = 14;
int[][] a = new int[rows][columns];

StopWatch sw = new StopWatch();
sw.start("ij");
ij(a, rows, columns);
sw.stop();
sw.start("ji");
ji(a, rows, columns);
sw.stop();
System.out.println(sw.prettyPrint());

ij 方法

public static void ij(int[][] a, int rows, int columns) {
    long sum = 0L;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            sum += a[i][j];
        }
    }
    System.out.println(sum);
}

ji 方法

public static void ji(int[][] a, int rows, int columns) {
    long sum = 0L;
    for (int j = 0; j < columns; j++) {
        for (int i = 0; i < rows; i++) {
            sum += a[i][j];
        }
    }
    System.out.println(sum);
}

执行结果

0
0
StopWatch '': running time = 96283300 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
016196200  017%  ij
080087100  083%  ji

可以看到 ij 的效率比 ji 快很多，为什么呢？