Java基础【数组】

数组是什么

数组是一种数据类型，是引用类型。

为什么要有数组

快速访问和修改数据： 数组通过索引可以快速访问和修改特定位置的数据，使数据操作更加高效。

有序存储： 数组按顺序存储元素，保持了数据的有序性，便于查找和排序。

内存管理： 数组在内存中连续存储数据，易于分配和管理内存空间。

批量处理： 数组支持批量操作，可以对整个数组进行统一的处理，提高了处理效率。

数组的种类

一维数组

// 一维数组
int[] arr = {1, 2, 3, 4, 5};
for (int i : arr) {
    System.out.print(i + " ");
}
System.out.println();

二维数组

// 多维数组（二维数组）
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
for (int[] row : matrix) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

动态数组

// 动态数组
import java.util.ArrayList;

ArrayList<Integer> dynamicArr = new ArrayList<>();
dynamicArr.add(1);
dynamicArr.add(2);
System.out.println(dynamicArr);

字符数组

// 字符数组（字符串）
String str = "Hello, World!";
char[] charArr = str.toCharArray();
for (char c : charArr) {
    System.out.print(c + " ");
}
System.out.println();

对象数组

// 对象数组
class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Person[] people = {new Person("Alice", 25), new Person("Bob", 30), new Person("Carol", 28)};
for (Person person : people) {
    System.out.println(person.name + " " + person.age);
}

数组的使用

数组的初始化

数组在使用之前要进行初始化

避免未定义行为：如果不对数组进行初始化操作，数组中的元素会包含之前存在的垃圾值或默认值（比如0或null），这样可能导致未定义的行为，影响程序的正确性。

确保数据准确性：通过初始化，可以将数组的所有元素设置为特定的数值或状态，确保数据在使用前是可靠和准确的。

方便后续操作：初始化数组可以为后续操作提供一个清晰的起点，使得对数组的操作更加简单和可预测。

提高代码可读性：在代码中明确进行数组初始化可以增强代码的可读性和可维护性，让其他人更容易理解代码的意图。

避免潜在的错误：未初始化的数组可能导致访问越界、空指针异常等问题，通过初始化可以有效避免这些潜在的错误。

静态初始化

在声明数组的同时为数组元素分配初始值

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

动态初始化

在声明数组后，通过循环或其他逻辑为数组元素赋予初始值

int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
    arr[i] = i + 1;
}

数组的引用

数组的引用是指在许多编程语言中，数组变量本身实际上存储的是数组的地址或引用，而不是数组的实际数据。这意味着对数组变量的操作实际上是对数组数据的引用操作。
具体来说，当我们创建一个数组并将其赋值给一个变量时，该变量实际上持有数组数据的内存地址，而不是数组数据本身。这样做的好处是可以节省内存空间，并且可以更高效地传递数组数据。

int[] arr1 = {1, 2, 3, 4, 5};  // 创建并初始化一个数组
int[] arr2 = arr1;  // 将arr1的引用赋给arr2

arr1[0] = 10;  // 修改arr1的第一个元素
System.out.println(arr2[0]);  // 输出arr2的第一个元素

数组的赋值

浅拷贝：在 Java 中，数组的赋值实际上是将数组的引用复制给另一个数组变量，因此会导致浅拷贝的效果。

public class ArrayCopyExample {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = arr1;  // 这里实际上是浅拷贝

        arr1[0] = 10;
        System.out.println(arr2[0]);  // 输出为10，因为arr1和arr2指向同一块内存空间
    }
}

深拷贝：在 Java 中实现深拷贝需要使用 Arrays.copyOf 方法或手动进行元素的逐个复制

import java.util.Arrays;

public class DeepArrayCopyExample {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = Arrays.copyOf(arr1, arr1.length);  // 这里进行了深拷贝

        arr1[0] = 10;
        System.out.println(arr2[0]);  // 输出为1，因为arr1和arr2是独立的数组
    }
}

基础 增删改查

增加元素：Java 中的数组长度是固定的，如果需要添加元素，可以使用 ArrayList 类来代替数组，因为 ArrayList 具有动态大小的特性。如果要继续使用数组，可以创建一个新数组，并将原数组的元素复制到新数组中，然后在末尾添加新元素。

// 使用 ArrayList 添加元素
ArrayList<Integer> list = new ArrayList<>();
list.add(10);

// 使用数组添加元素
int[] arr = {1, 2, 3};
int[] newArr = Arrays.copyOf(arr, arr.length + 1);
newArr[arr.length] = 4;

删除元素：删除数组中的元素通常需要移动其他元素来填补被删除元素的位置。可以使用 System.arraycopy() 方法或者循环来实现元素的删除操作。

// 删除数组中指定位置的元素
int indexToRemove = 1;
int[] arr = {1, 2, 3, 4, 5};
for (int i = indexToRemove; i < arr.length - 1; i++) {
    arr[i] = arr[i + 1];
}
arr = Arrays.copyOf(arr, arr.length - 1);

修改元素：直接通过索引访问数组元素并进行修改

int[] arr = {1, 2, 3, 4, 5};
arr[0] = 10;

**查找元素：**可以通过循环遍历数组来查找特定的元素，或者使用 Arrays.binarySearch() 方法（前提是数组已经有序）。

int[] arr = {1, 2, 3, 4, 5};
int target = 3;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        System.out.println("Element found at index: " + i);
        break;
    }
}

数组的注意事项

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3. 数组创建后，如果没有赋值，有默认值
   int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
4. 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组
5. 数组的下标是从 0 开始的。
6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如int [] arr=new int[5]; 则有效下标为 0-4
7. 数组属引用类型，数组型数据是对象(object)

public class ArrayExample {
    public static void main(String[] args) {
        // 1. 声明数组并开辟空间
        int[] numbers = new int[5]; // 创建一个包含 5 个整数的数组

        // 2. 给数组各个元素赋值
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        // 3. 使用数组
        System.out.println("数组中的元素为：");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // 尝试访问超出数组范围的下标，会导致数组越界异常
        // System.out.println(numbers[5]); // 这行代码会导致数组越界异常

        // 数组的默认值示例
        boolean[] flags = new boolean[3];
        System.out.println("boolean数组默认值为：");
        for (int i = 0; i < flags.length; i++) {
            System.out.println("flags[" + i + "] = " + flags[i]);
        }

        String[] names = new String[3];
        System.out.println("String数组默认值为：");
        for (int i = 0; i < names.length; i++) {
            System.out.println("names[" + i + "] = " + names[i]);
        }
    }
}