【JAVASE】数组技巧与实践：提升你的编程能力

在 Java 编程中，数组是一种常见的数据结构，用于存储多个相同类型的元素。它提供了一系列操作来对数组进行管理和操作。下面是一些常见的 Java 数组操作：

1. 数组的创建和初始化：

• 使用new关键字创建数组。
• 可以指定数组的类型和大小。
• 可以通过循环或直接赋值来初始化数组元素。

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};

1.1 动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array2 = new int[10];

1.2 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

int[] array3 = {0,1,2,3,4,5,6,7,8,9};

【注意事项】
1、静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
2、静态初始化时, {}中数据类型必须与[]前数据类型一致。
3、静态初始化可以简写，省去后面的new T[]。

1.3 如果没有对数组进行初始化，数组中元素有其默认值

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0f
double	0.0
char	/u0000
boolean	false

如果数组中存储元素类型为引用类型，默认值为null

2. 数组的索引访问：

• 使用索引来访问数组中的元素。
• 索引从 0 开始，所以第一个元素的索引是 0，第二个元素的索引是 1，以此类推。
• 可以使用arr[index]的方式来访问指定索引处的元素。

int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);
// 也可以通过[]对数组中的元素进行修改
array[0] = 100;
System.out.println(array[0]);

【注意事项】

1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
2. 下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组中只有3个元素，下标一次为：0 1 2，array[3]下标越界

// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at Test.main(Test.java:4)

3. 数组的遍历：

• 可以使用for循环来遍历数组中的每个元素。

int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
	System.out.println(array[i]);
}

• 也可以使用for-each循环（在 Java 5 及更高版本中可用）来遍历数组。

int[] array = {1, 2, 3};
for (int x : array) {
	System.out.println(x);
}

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错

4. 数组的常见操作

4.1 数组转字符串（toString）

import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
// 执行结果
[1, 2, 3, 4, 5, 6]

使用这个方法后续打印数组就更方便一些.
Java 中提供了java.util.Arrays 包, 其中包含了一些操作数组的常用方法.

4.2 数组拷贝（copyOf）

import java.util.Arrays;
public static void func(){
int[] arr = {1,2,3,4,5,6};
int[] newArr = arr;
newArr[0] = 10;
System.out.println("newArr: " + Arrays.toString(arr));

newArr和arr引用的是同一个数组
因此newArr修改空间中内容之后，arr也可以看到修改的结果

使用Arrays中copyOf方法完成数组的拷贝：
copyOf方法在进行数组拷贝时，创建了一个新的数组
arr和newArr引用的不是同一个数组

arr[0] = 1;
newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));

因为arr修改其引用数组中内容时，对newArr没有任何影响

arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));

拷贝某个范围.

int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));
}

4.3 求数组中元素的平均值

public static void main(String[] args) {
	int[] arr = {1,2,3,4,5,6};
	System.out.println(avg(arr));
}
public static double avg(int[] arr) {
	int sum = 0;
	for (int x : arr) {
		sum += x;
	} 
	return (double)sum / (double)arr.length;
} 
// 执行结果
3.5

4.4 查找数组中指定元素(顺序查找)

public static void main(String[] args) {
	int[] arr = {1,2,3,10,5,6};
	System.out.println(find(arr, 10));
}
public static int find(int[] arr, int data) {
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == data) {
			return i;
		}
	} 
	return -1; // 表示没有找到
} 
// 执行结果
3

4.5 查找数组中指定元素(二分查找)

• 可以使用Arrays类中的binarySearch方法在已排序的数组中查找指定元素。

以升序数组为例, 二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：
如果相等，即找到了返回该元素在数组中的下标
如果小于，以类似方式到数组左半侧查找
如果大于，以类似方式到数组右半侧查找

public static void main(String[] args) {
	int[] arr = {1,2,3,4,5,6};
	System.out.println(binarySearch(arr, 6));
}

✌️自己实现binarySearch

public static int binarySearch(int[] arr, int toFind) {
	int left = 0;
	int right = arr.length - 1;
	while (left <= right) {
		int mid = (left + right) / 2;
		if (toFind < arr[mid]) {
			// 去左侧区间找
			right = mid - 1;
		} else if (toFind > arr[mid]) {
			// 去右侧区间找
			left = mid + 1;
		} else {
			// 相等, 说明找到了
			return mid;
		}
	} 
	// 循环结束, 说明没找到
	return -1;
} 
// 执行结果
5

4.6. 数组的排序(sort)：

• 可以使用Arrays类中的sort方法对数组进行排序。
• 也可以使用其他排序算法（如冒泡排序、插入排序、选择排序等）自行实现排序。

int[] arr = {5, 3, 8, 2, 1};
System.out.println("排序前的数组：" + Arrays.toString(arr));

// 使用 Arrays.sort 方法对数组进行排序
Arrays.sort(arr);

// 打印排序后的数组
System.out.println("排序后的数组：" + Arrays.toString(arr));
    }

4.7 数组的复制(System.arraycopy)：

• 可以使用System.arraycopy方法来复制数组。（System.arraycopy是 Java 标准类库中的一个方法，用于在数组之间进行拷贝。它可以用于复制一个数组的部分或全部元素到另一个数组中。）
• 也可以通过循环遍历数组并逐个复制元素来实现复制。

public class Main {
    public static void main(String[] args) {
        int[] sourceArray = {1, 2, 3, 4, 5};
        int[] destinationArray = new int[sourceArray.length];

        // 使用 System.arraycopy 方法进行数组拷贝
        System.arraycopy(sourceArray, 0, destinationArray, 0, sourceArray.length);

        // 输出源数组和目标数组的内容
        System.out.println("Source array: " + Arrays.toString(sourceArray));
        System.out.println("Destination array: " + Arrays.toString(destinationArray));
    }
}

在上述示例中，我们定义了两个整数数组sourceArray和destinationArray。然后，我们使用System.arraycopy方法将sourceArray数组的全部元素拷贝到destinationArray数组中 。最后，我们输出了源数组和目标数组的内容，以验证拷贝操作的结果。

System.arraycopy方法接受五个参数：源数组、源数组的起始索引、目标数组、目标数组的起始索引和要拷贝的元素个数。在示例中，我们将源数组的起始索引和目标数组的起始索引都设置为 0，表示从数组的开头开始拷贝。要拷贝的元素个数为源数组的长度，即sourceArray.length。
通过使用System.arraycopy方法，我们可以方便地在数组之间进行拷贝操作，而无需手动循环遍历数组并逐个赋值。它提供了一种高效且简洁的方式来复制数组的内容。

4.8 数组的比较(equals)：

• 可以使用Arrays类中的equals方法来比较两个数组是否相等。
• 该方法会比较数组的元素是否一一相等。

public class Main {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = "World";

        // 使用 equals 方法比较字符串内容
        boolean isEqual = str1.equals(str2);
        System.out.println("str1 和 str2 是否相等：" + isEqual);

        isEqual = str1.equals(str3);
        System.out.println("str1 和 str3 是否相等：" + isEqual);
    }
}

在上述示例中，我们定义了三个字符串对象str1、str2和str3。然后，使用equals方法来比较字符串的内容。
第一次调用equals方法时，将str1与str2进行比较。由于这两个字符串的内容相同，所以返回true，表示它们相等。
第二次调用equals方法时，将str1与str3进行比较。由于这两个字符串的内容不同，所以返回false，表示它们不相等。
通过使用equals方法，我们可以方便地比较对象的内容是否相等，而不仅仅是比较对象的引用。在实际编程中，根据具体的需求和对象类型，正确使用equals方法可以提高代码的正确性和可读性。

5. 二维数组

二维数组是一种数组类型，它由多个一维数组组成，可以用来表示表格、矩阵或图像等二维数据结构。

public class Main {
    public static void main(String[] args) {
        // 创建一个二维数组
        int[][] twoDArray = new int[3][4];

        // 给数组赋值
        for (int i = 0; i < twoDArray.length; i++) {
            for (int j = 0; j < twoDArray[i].length; j++) {
                twoDArray[i][j] = i * j;
            }
        }

        // 打印数组
        for (int i = 0; i < twoDArray.length; i++) {
            for (int j = 0; j < twoDArray[i].length; j++) {
                System.out.print(twoDArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

在上述示例中，我们创建了一个二维整数数组twoDArray，其中包含 3 行 4 列的整数。然后，我们使用双重for循环给数组赋值，并使用另一个双重for循环打印数组的内容。
通过二维数组，我们可以有效地组织和操作二维数据，例如表示棋盘、图像像素或关系型数据等。我们可以根据实际需求选择合适的数据类型和大小，并使用类似的方式进行赋值和访问数组元素。

感谢你抽出时间阅读我的博客！如果你喜欢这篇文章，请点赞、分享或订阅我的博客，以获取更多精彩内容。