Java知识总结—第四篇（数组）

4.1 数组的介绍

Java数组是一种用于存储和操作相同类型数据的数据结构。它们提供了一种有效的方式来管理大量数据，并且可以方便地访问和修改数组中的元素。
在Java中，数组是固定大小的，这意味着在定义数组时必须指定其大小。数组的大小由其容量确定，也就是说，一旦数组被创建，其大小就不能更改。
Java数组可以包含任何基本数据类型或自定义对象类型。要创建一个数组，需要使用关键字“new”来分配内存空间，并指定数组的大小
Java数组是一种强大的数据结构，可用于存储和操作大量数据。通过使用索引和循环，可以方便地访问和修改数组中的元素。

4.2 数组的创建

4.2.1 数组的静态初始化

Java数组的静态初始化是指在定义数组时直接为其赋值。这种方法通常用于创建小型数组或者已知元素的情况。

Java数组的静态初始化有两种方式：

1. 声明和初始化同时完成

例如，以下代码声明了一个包含三个整数的数组，并将其初始化为1、2、3：

int[] myArray = {1, 2, 3};

2. 声明和初始化分开完成

例如，以下代码先声明一个包含四个字符串的数组，然后在另一行中将其初始化：

String[] myArray;
myArray = new String[]{"apple", "banana", "orange", "grape"};

需要注意的是，在使用第二种方法时，需要在大括号内指定数组的长度。在第一种方法中，数组的大小由初始值的数量决定。

静态初始化使得数组的定义更加简洁明了，并且可以减少代码量和错误率。但是，它并不适用于动态计算数组元素的情况，因为在静态初始化中，数组的大小必须是确定的。

4.2.2 数组的动态初始化

Java数组的动态初始化是指在定义数组时只指定数组的长度，而不为其分配具体的初始值。然后可以使用循环或其他方法为数组元素赋值。

Java数组的动态初始化有以下方式：

1. 通过关键字 new 和指定数组长度进行初始化

例如，以下代码声明了一个包含5个整数的数组，并将其初始化为默认值0:

int[] myArray = new int[5];

2. 声明数组变量和数组长度，但是在稍后的代码中使用 new 关键字完成数组初始化

例如，以下代码声明了一个包含10个字符串的数组，然后在另一行中使用 new 关键字为其赋值：

String[] myArray;
myArray = new String[10];

需要注意的是，在动态初始化中，数组的大小可以在运行时根据需要进行计算，这使得它更加灵活。但是，与静态初始化相比，动态初始化需要更多的代码，并且在循环或其他方法中赋值也可能会导致性能问题。

4.3 数组使用的细节

在使用Java数组时，有一些需要注意的细节，包括：

1. 数组的索引从0开始，因此最后一个元素的索引是数组长度减1。

2. 在访问数组元素之前，必须确保已分配了足够的内存空间。

3. 在创建数组时，必须指定其大小，并且一旦创建，其大小就不能改变。如果需要扩大数组，可以创建一个新的更大的数组，并将原始数组中的元素复制到新的数组中，然后使用新的数组替换原始数组。

4. Java数组可以存储任何基本类型或对象类型。但是，在声明数组时，必须指定元素的数据类型，而且所有元素都必须具有相同的数据类型。

5. 初始化数组时，必须为每个元素赋初值。如果不初始化，则会出现编译错误。

6. 在使用数组时，应该注意避免数组下标越界。否则会导致运行时异常。

7. 数组可以作为方法的参数和返回值。在这种情况下，应该注意参数和返回值的类型，并确保数组的大小正确。

总之，Java数组是一种强大的数据结构，可用于存储和操作大量数据。在使用数组时，需要注意上述细节，以确保代码正确性和性能。

4.4 数组的常用操作

在Java中，有很多对数组进行操作的方法和函数。下面列出一些常用的操作：

1. 创建一个数组

可以使用关键字 new 来创建一个数组，例如：

int[] myArray = new int[10];

这将创建一个包含10个整数的数组。

2. 访问数组元素

可以使用索引操作符 ([]) 来访问数组中的元素，例如：

int value = myArray[0];

这将把数组中的第一个元素赋给变量 value。

3. 修改数组元素

可以使用索引操作符 ([]) 来修改数组中的元素，例如：

myArray[0] = 5;

这将把数组中的第一个元素更改为值5。

4. 获取数组长度

可以使用数组对象的 length 属性来获取数组的长度，例如：

int len = myArray.length;

这将返回数组 myArray 的长度。

5. 遍历数组

可以使用循环结构来遍历数组的所有元素并进行相应的操作，例如：

for (int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
}

这将打印数组中的所有元素。

6. 排序数组

可以使用Arrays类中的sort()方法来对数组进行排序，例如：

Arrays.sort(myArray);

这将按升序对数组中的元素进行排序。

总之，在Java中，数组是一种非常有用的数据结构，它提供了方便的方式来存储和处理大量的数据。开发者可以通过上述常用操作来灵活地使用数组。

4.5 数组的复制

在Java中，数组的复制可以使用System.arraycopy()方法或Arrays.copyOf()方法完成。下面分别介绍这两种方法的用法。

1. System.arraycopy()方法

System.arraycopy()方法是Java提供的用于复制数组的快速且高效的方法，可将一个数组的某个区域复制到另一个数组的指定位置。该方法的语法如下：

public static void arraycopy(Object src, int srcPos,
                             Object dest, int destPos, int length)

其中，src表示源数组，srcPos表示源数组中要复制的起始索引，dest表示目标数组，destPos表示目标数组中放置复制数据的起始索引，length表示要复制的元素数量。

例如，以下代码演示了如何使用System.arraycopy()方法将原数组的第2到4个元素复制到新数组的第1到3个位置：

int[] original = {1, 2, 3, 4, 5};
int[] copy = new int[3];

System.arraycopy(original, 1, copy, 0, 3);

2. Arrays.copyOf()方法

Arrays.copyOf()方法是Java提供的用于复制数组的方法，它可以创建一个新数组，并将原始数组的所有元素复制到新数组中。该方法的语法如下：

public static <T> T[] copyOf(T[] original, int newLength)

其中，original表示要复制的原始数组，newLength表示新数组的长度。

例如，以下代码演示了如何使用Arrays.copyOf()方法将原数组的前三个元素复制到新数组中：

int[] original = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(original, 3);

需要注意的是，在使用Arrays.copyOf()方法时，如果原数组的长度小于新长度，则会使用默认值填充新数组中剩余的元素。

总之，Java提供了多种方法用于复制数组，包括System.arraycopy()方法和Arrays.copyOf()方法。开发者可以根据实际需要选择最适合的方法。

4.6 数组的反转

在Java中，可以使用循环和临时变量等方式来反转一个数组。下面介绍两种常用的方法：

1. 使用循环和临时变量

该方法通过循环遍历数组，将数组元素按相反的顺序存储到一个新数组中，然后将新数组赋值回原数组。例如：

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

for (int i = 0; i < myArray.length; i++) {
    reversedArray[i] = myArray[myArray.length - i - 1];
}

myArray = reversedArray;

在这个例子中，我们创建了一个新数组reversedArray，并通过循环遍历myArray数组，将元素按相反的顺序存储到reversedArray中。最后，我们将reversedArray赋值回myArray。

2. 使用循环和临时变量

该方法通过循环遍历数组，在原数组中交换相邻的元素，以实现数组反转的目的。例如：

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

for (int i = 0; i < myArray.length / 2; i++) {
    int temp = myArray[i];
    myArray[i] = myArray[myArray.length - i - 1];
    myArray[myArray.length - i - 1] = temp;
}

在这个例子中，我们通过循环遍历myArray数组，将第i个元素与倒数第i个元素交换位置，从而达到数组反转的效果。

总之，Java提供了多种方法来反转一个数组，包括使用循环和临时变量以及使用Collections类的reverse()方法等。开发者可以根据具体情况选择最适合的方法。

4.7 数组的添加/扩容

在Java中，数组的长度一旦确定后就无法更改。因此，在需要向数组中添加元素或将数组扩大时，可以采用以下两种方法：

1. 创建一个新数组

此方法包括以下步骤：

• 创建一个新的数组，其长度比原始数组大
• 将原始数组的元素复制到新数组中
• 将要添加到数组中的新元素追加到新数组中

例如，以下代码演示了如何向一个整数数组中添加一个新元素：

int[] originalArray = {1, 2, 3};
int[] newArray = new int[originalArray.length + 1];
System.arraycopy(originalArray, 0, newArray, 0, originalArray.length);
newArray[newArray.length - 1] = 4;

在这个例子中，我们首先创建了一个新数组 newArray，它比原始数组 originalArray 多一个元素。然后我们使用 System.arraycopy() 方法将 originalArray 中的所有元素复制到 newArray 中，并将要添加到数组中的新元素 4 追加到 newArray 的末尾。

2. 使用集合类

可以使用Java集合类（如ArrayList）来避免手动管理数组的长度和扩展。例如，下面是使用ArrayList向数组中添加一个新元素的示例：

ArrayList<Integer> myArrayList = new ArrayList<Integer>(Arrays.asList(originalArray));
myArrayList.add(4);
Integer[] newArray = myArrayList.toArray(new Integer[originalArray.length+1]);

在这个例子中，我们首先将原始数组 originalArray 转换为ArrayList，然后向列表中添加一个新元素。最后，我们将修改后的列表转换回数组 newArray。

总之，当需要向Java数组添加元素或将数组扩大时，可以使用上述方法之一。手动扩容需要更多的代码和注意事项，而使用集合类则更加简单。

4.8 二维数组的创建

4.8.1 二维数组的静态初始化

在Java中，可以使用静态初始化的方式创建二维数组。静态初始化是指在声明数组时就为其分配空间并赋予初值。以下是一个示例代码，演示如何使用Java进行二维数组的静态初始化：

public class TwoDArray {
    public static void main(String[] args) {
        int[][] myArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        
        // 打印二维数组
        for (int i = 0; i < myArray.length; i++) {
            for (int j = 0; j < myArray[i].length; j++) {
                System.out.print(myArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

在这个例子中，我们使用了双重大括号语法来创建二维数组，并为其赋予初值。我们将数组元素按照行列顺序排列，每行用一组花括号括起来，在所有行外再套一层花括号。

上述代码将创建一个3×3的二维数组myArray，并依次为其赋值为：

1 2 3 
4 5 6 
7 8 9 

在打印二维数组时，我们使用两个嵌套的循环来遍历二维数组的所有元素，并输出到控制台上。

总之，Java提供了多种方法来初始化和操作二维数组。开发者可以根据具体情况选择最适合的方法。

4.8.2 二维数组的动态初始化

在Java中，可以使用动态初始化的方式创建二维数组。动态初始化是指在声明数组时不为其分配空间，而是在后续的代码中根据需要动态为其分配空间。以下是一个示例代码，演示如何使用Java进行二维数组的动态初始化：

public class TwoDArray {
    public static void main(String[] args) {
        int[][] myArray = new int[3][3];
        
        // 打印二维数组
        for (int i = 0; i < myArray.length; i++) {
            for (int j = 0; j < myArray[i].length; j++) {
                System.out.print(myArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

在这个例子中，我们使用关键字new来创建一个3×3的二维数组myArray，并在后续的代码中为其分配空间。由于我们没有为二维数组赋初值，因此默认将所有元素初始化为0。

运行上述代码，将得到以下输出结果：

0 0 0 
0 0 0 
0 0 0 

在打印二维数组时，我们仍然使用两个嵌套的循环遍历二维数组的所有元素，并输出到控制台上。

除了动态初始化外，还可以使用静态初始化的方式进行二维数组的初始化。具体方法请参见上一条回答。

总之，Java提供了多种方法来初始化和操作二维数组。开发者可以根据具体情况选择最适合的方法。

4.9 二分查找

二分查找是一种高效的查找算法，它适用于有序数组。在Java中，可以使用以下方式实现二分查找：

public static int binarySearch(int[] arr, int key) {
    int low = 0;
    int high = arr.length - 1;
    
    while (low <= high) {
        int mid = (low + high) / 2;
        
        if (arr[mid] == key) {
            return mid;
        } else if (arr[mid] < key) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    
    return -1;
}

这个方法接受一个整数数组 arr 和一个要查找的关键字 key。该方法首先将 low 设置为0，将 high 设置为 arr.length-1，然后使用while循环在数组中进行查找。

在每次迭代中，我们通过计算 mid（即 low 和 high 的平均值）来确定当前区间的中心位置。如果 arr[mid] 等于 key，则返回 mid。否则，如果 arr[mid] 小于 key，则更新 low 为 mid+1，否则更新 high 为 mid-1。当 low > high 时，说明 key 不在数组中，返回 -1。

下面是一个调用示例：

int[] myArray = {1, 3, 5, 7, 9};
int key = 7;

int index = binarySearch(myArray, key);

if (index != -1) {
    System.out.println("Found at index: " + index);
} else {
    System.out.println("Not found");
}

在这个例子中，我们创建了一个包含奇数个元素的整数数组myArray，并将其升序排列。然后我们使用上述方法在数组中查找key等于7的元素，并打印出其索引值。

总之，二分查找是一种高效的查找算法，可以在对数时间内查找有序数组中的元素。在Java中，可以使用上述方法来实现二分查找。