5.数组的学习-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_63223737/article/details/145509002

一、数组基本概念

程序=算法+数据结构

算法：解决程序的流程步骤

数据结构：将数据按照某种特定的结构来存储

设计良好的数据结构会导致良好的算法。

ArrayList、LinkedList

面试问题：基本数据类型有8个，分别是......数字（整数（4）+小数（2））+字符（1）+ 布尔（1）

数组是最简单的数据结构。

数组：存放同一种类型数据的集合，在内存里面是开辟一块连续的区域。

int num = 3;

int[] array = new int[4];

1、存放整数类型的数组

2、长度是4 （数组缺点长度固定，ArrayList解决长度固定的问题）

3、只能存放int类型

数组的访问：数组名[下标]

元素类型[] 数组名 = new 元素类型[长度];

int[] array1 = new int[3];
double[] array2 = new double[3];
boolean[] array3 = new boolean[3];
char[] array4 = new char[3];
Student[] array5 = new Student[3];

数组定义的方式：

1、静态初始化：在声明数组的同时，直接给出数组元素的初始值。适用于数组元素已知的情况。

int[] array = {32,5,7,87};

int[] array = new int[]{32,5,7,87};

2、动态初始化：在声明数组时，仅指定数组的长度，然后通过赋值语句逐个给数组元素赋值。适用于数组元素在声明时未知的情况。

int[] array = new int[4];

array[0] = 34;

自动换行

@Test
public void test1() {
    int num = 3;
    int score1 = 84;
    int score2 = 54;
    int score3 = 64;
    //数组：存放同一种类型数据的集合，在内存里面是开辟一块连续的区域。
    int[] array = new int[4];
    System.out.println("length: " + array.length);//4
    array[0] = 33;
    array[1] = 2;
    array[2] = 45;
    array[3] = 19;
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
    System.out.println("-------------");
    for (int i = array.length - 1; i >= 0; i--) {
        System.out.println(array[i]);
    }
 
}

二、数组下标越界异常

java.lang.Array Index OutOf Bounds Exception: 4

数组下标越界异常

进一步理解：

数组在 Java 中的索引是从 0 开始的，所以一个长度为 n 的数组，索引的有效范围是 0 到 n-1。
访问数组时，务必确保索引在合法范围内，否则会抛出 ArrayIndexOutOfBoundsException。

总结：

数组下标越界异常是由于访问了数组中不存在的元素，通常是因为访问的索引超过了数组的实际长度。通过确保索引在有效范围内，可以避免此类异常。

@Test
public void test45() {
    int[] array = new int[4];
    array[0] = 33;
    array[1] = 2;
    array[2] = 45;
    array[3] = 19;
    for (int i = 0; i <= array.length; i++) {
        //java.lang.ArrayIndexOutOfBoundsException: 4
        System.out.println(array[i]);
    }
}

三、数组累加和、最大值、最小值、冒泡排序

数组最重要操作就是遍历。

只要能遍历所有元素就可以求最大值、最小值、对数组排序

1、数组累加和

@Test
public void test189() {
    int[] array = new int[4];
    array[0] = 33;
    array[1] = 2;
    array[2] = 45;
    array[3] = 19;
    //array.fori   fori
    int sum = 0;
    for (int i = 0; i < array.length; i++) {
        sum = sum + array[i];
    }
    System.out.println("sum: " + sum);
}

2、最大值、最小值

//数组最重要操作就是遍历。
//只要能遍历所有元素：求最大值、最小值、排序。
@Test
public void test23(){
    int[] array = {23, 45, 67, 2, 12};
    int max = array[0];
    for (int i = 0; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    System.out.println("max: " + max);
}

@Test
public void test333() {
    int[] array = {23, 45, 67, 2, 12};
    int maxValue = getMax(array);
    System.out.println(maxValue);
}

//参数，形参
/**
 * 返回数组的最大值
 * @param array 传递过来的数组
 * @return 数组最大值
 */
public int getMax(int[] array) {
    int max = array[0];
    for (int i = 0; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    return max;
}

@Test
public void test24(){
    int[] array = {23, 45, 67, 2, 12};
    int min = array[0];
    for (int i = 0; i < array.length; i++) {
        //正在遍历的比假设的最小的还要小
        if (array[i] < min) {
            min = array[i];
        }
    }
    System.out.println("min: " + min);
}

3、数组的排序：冒泡排序

int[] array = {40, 17, 21, 1}; // 1, 17,21,40

第一轮：40冒到最右边

17,40,21,1

17,21,40,1

17,21,1,40 ------- 40 冒出来

第二轮：21冒出来

17,21,1,40

17,1,21,40 ------- 21冒出来

第三轮：17冒出来

1,17,21,40 ------- 17冒出来

public void sort(int[] array) {

}

4个数只要比较3轮就可以，剩下那个数不要要排序就是最小的

第1轮：比较3次

第2轮：比较2次

第3轮：比较1次

i+j =4=array.length

j=array.length-i

@Test
public void test22() {
    //i=1   j=
    int[] array = {40, 17, 21, 1}; // 1, 17,21,40
    sort(array);
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
}

private void sort(int[] array) {
    for (int i = 1; i <= array.length - 1; i++) {
        for (int j = 0; j < array.length - i; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

四、数组复制

1、System.arraycopy（重点）

这是标准且高效的方法，适用于复制数组的部分或全部。

int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(source, 0, dest, 0, source.length);

//数组.fori
/*for (int i = 0; i < dest.length; i++) {
    System.out.println(dest[i]);
}*/
//增强的for循环  数组.for
for (int num : dest) {
    System.out.print(num + " ");
}

参数说明：

source：源数组
0：源数组的起始位置
dest：目标数组
0：目标数组的起始位置
source.length：复制的元素个数

2、使用 Arrays.copyOf 方法

适合复制整个数组或调整大小时使用。

import java.util.Arrays;

int[] source = {1, 2, 3, 4, 5};
int[] copiedArray = Arrays.copyOf(source, source.length); // 复制整个数组

for (int num : copiedArray) {
    System.out.print(num + " ");
}

可以调整目标数组的大小：

int[] array = Arrays.copyOf(source, 10); // 创建长度为 10 的数组

3、使用 Arrays.copyOfRange 方法

复制数组的指定范围。

import java.util.Arrays;j

int[] source = {1, 2, 3, 4, 5};
int[] array = Arrays.copyOfRange(source, 1, 4); // 复制索引 1 到 3 的元素

for (int num : array) {
    System.out.print(num + " ");
}

4、使用 clone 方法

适用于简单复制整个一维数组。

int[] source = {1, 2, 3, 4, 5};
int[] array = source.clone();

for (int num : array) {
    System.out.print(num + " ");
}

5、手动遍历赋值

当需要自定义复制逻辑时使用。

int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[source.length];

for (int i = 0; i < source.length; i++) {
    dest[i] = source[i];
}

for (int num : dest) {
    System.out.print(num + " ");
}

6、对比

方法	优点	缺点
System.arraycopy	高效，适合大数组	使用稍复杂
Arrays.copyOf	简洁易用，支持调整大小	效率可能略低于System.arraycopy
Arrays.copyOfRange	支持范围复制	语法相对复杂
clone	简单、直接	仅支持一维数组
手动遍历	灵活，适合复杂逻辑	实现较繁琐

五、二维数组(了解)

二维数组里面又是个一位数组

Java数组支持规则数组和不规则数组：

二维数组的创建和初始化：

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

从最高维开始，分别为每一维分配空间：

int[][] array = new int[3][];

array[0] = new int[2];

array[1] = new int[2];

array[2] = new int[3];

array[0][0] = 1;

array[1][1] = 3;

两行互换：

int[] temp = array[0];

array[0] = array[1];

array[1] = temp;

直接为每一维分配空间：

int[][] array = new int[2][3];

@Test
public void test222() {
    int[][] array = new int[3][];
    array[0] = new int[2];
    array[1] = new int[2];
    array[2] = new int[3];
    array[0][0] = 23;
    array[0][1] = 12;
    array[1][0] = 22;
    array[1][1] = 22;
    array[2][0] = 21;
    array[2][1] = 22;
    array[2][2] = 23;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }
}