Java数组

Java数组的用法

在Java中，数组是一种常用的数据结构，用于存储相同类型的多个元素，以下是一些关于Java数组的基本学习要点。

1. 数组的声明

声明一个数组变量，指定其类型，但此时不分配内存空间。

int[] numbers; // 声明一个整型数组变量

2. 数组的初始化

在声明的同时初始化数组，也可以单独初始化。

声明并初始化

int[] numbers = {1, 2, 3, 4, 5}; // 声明并初始化一个整型数组

单独初始化

int[] numbers; // 声明
numbers = new int[5]; // 初始化，分配5个整数的空间
// 然后可以单独设置每个元素的值
numbers[0] = 1;
numbers[1] = 2;
// ...

3. 访问数组元素

使用索引（从0开始）来访问数组中的元素。

int firstNumber = numbers[0]; // 访问数组的第一个元素

4. 数组的长度

使用 length 属性来获取数组的长度（即元素的数量）。

int length = numbers.length; // 获取数组的长度

5. 数组的遍历

使用循环（如for循环）来遍历数组中的每个元素。

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

6. 多维数组

Java还支持多维数组，如二维数组。

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

7. 数组作为方法参数和返回值

你可以将数组作为参数传递给方法，也可以从方法中返回数组。

public static int[] doubleArray(int[] array) {
    int[] result = new int[array.length];
    for (int i = 0; i < array.length; i++) {
        result[i] = array[i] * 2;
    }
    return result;
}

8. 数组拷贝

Java提供了几种方式来拷贝数组，如使用 System.arraycopy() 方法或使用 Arrays.copyOf() 方法。

int[] copiedArray = Arrays.copyOf(numbers, numbers.length);

9. 数组排序

使用 Arrays.sort() 方法可以对数组进行排序。

Arrays.sort(numbers);

10. 数组查找

• 基本查找：当数组元素无序时，从头找到尾进行查找。

• 二分查找（折半查找）：当数组元素有序时，通过每次比较中间元素，将查找范围减半，从而提高查找效率。

使用 Arrays.binarySearch() 方法可以在已排序的数组中进行高效查找。但在使用之前，必须确保数组已排序。

int index = Arrays.binarySearch(numbers, targetValue);

11. 数组填充

使用 Arrays.fill() 方法可以快速填充数组。可以填充整个数组，也可以填充指定范围的数组元素。

12. 数组转换

数组转字符串：使用 Arrays.toString() 方法可以将数组转换为字符串表示形式。

13. 数组连接

• 使用 System.arraycopy() 或循环遍历的方式连接两个数组。

• 使用第三方库如Apache Commons Lang的 ArrayUtils.addAll() 方法可以更方便地连接数组。

14. 数组比较

使用 Arrays.equals() 方法可以比较两个数组是否相等。

注意，直接使用 == 运算符比较两个数组将比较它们的引用地址，而不是内容。

15. 数组与集合框架的互操作

Java的集合框架（如ArrayList、HashSet等）提供了丰富的功能，可以与数组进行互操作。

• 将数组转换为列表，然后再对列表进行操作，例如：List<Integer> list = Arrays.asList(numbers);   （请注意，返回的列表大小固定，不支持增删操作）。

• 将列表转换为数组，例如：Object[] objects = list.toArray();  

16. 数组流

使用Java 8引入的流（Stream）API，可以对数组进行更高效、更简洁的操作。例如，可以使用 Arrays.stream() 方法将数组转换为流，然后使用流的各种操作对数据进行处理。

17. 数组与泛型

在Java中，可以使用泛型来创建可以处理任何类型数组的类和方法。这增加了代码的灵活性和可重用性。

Java数组案例代码

1. 数组排序

使用 Arrays.sort() 方法进行排序：

import java.util.Arrays;

public class ArraySortDemo {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 9, 1, 5, 6};
        Arrays.sort(numbers);
        System.out.println(Arrays.toString(numbers)); // 输出: [1, 2, 5, 5, 6, 9]
    }
}

2. 数组查找

使用 Arrays.binarySearch() 方法进行二分查找（数组必须已排序）：

import java.util.Arrays;

public class ArraySearchDemo {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        Arrays.sort(numbers); // 二分查找前需要排序
        int index = Arrays.binarySearch(numbers, 5);
        if (index >= 0) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found");
        }
    }
}

3. 数组复制

使用 Arrays.copyOf() 方法进行复制：

import java.util.Arrays;

public class ArrayCopyDemo {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};
        int[] copied = Arrays.copyOf(original, original.length);
        System.out.println(Arrays.toString(copied)); // 输出: [1, 2, 3, 4, 5]
    }
}

4. 数组填充

使用 Arrays.fill() 方法进行填充：

import java.util.Arrays;

public class ArrayFillDemo {
    public static void main(String[] args) {
        int[] numbers = new int[5];
        Arrays.fill(numbers, 10);
        System.out.println(Arrays.toString(numbers)); // 输出: [10, 10, 10, 10, 10]
    }
}

5. 数组与集合框架的互操作

将数组转换为列表：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayToListDemo {
    public static void main(String[] args) {
        Integer[] numbers = {1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(numbers); // 注意：这里的列表是固定大小的

        // 如果需要修改列表大小，可以转换为ArrayList
        List<Integer> arrayList = new ArrayList<>(Arrays.asList(numbers));
        arrayList.add(6); // 可以添加元素

        System.out.println(arrayList); // 输出: [1, 2, 3, 4, 5, 6]
    }
}

列表转数组

import java.util.ArrayList;
import java.util.List;

public class ListToArrayExample {
    public static void main(String[] args) {
        // 创建一个ArrayList
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("banana");
        list.add("cherry");

        // 使用toArray()方法转换为数组
        // 注意：toArray()方法默认返回Object[]类型，所以我们需要进行类型转换
        Object[] objects = list.toArray();

        // 如果你知道列表中的元素类型，可以这样做来避免不必要的类型检查或ClassCastException
        // 使用toArray(T[] a)方法并传入一个空数组，该数组的类型与你期望的结果类型相同
        String[] strings = list.toArray(new String[0]);

        // 输出数组元素
        for (String s : strings) {
            System.out.println(s);
        }
    }
}

6. 数组流（Java 8及以上版本）

使用流对数组进行操作：

public class ArrayStreamDemo {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int sum = IntStream.of(numbers).sum();
        System.out.println("Sum: " + sum); // 输出: Sum: 15
    }
}

7. 数组与泛型

泛型可以与数组一起使用，但需要注意Java中的泛型不支持基本数据类型（如int、double等）。你需要使用它们的包装类（如Integer、Double等）。以下是一个泛型方法，它接受一个泛型数组并打印其内容：

public class GenericArrayMethodDemo {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5};
        String[] strings = {"one", "two", "three"};

        printArray(integers); // 输出: 1 2 3 4 5
        printArray(strings);  // 输出: one two three
    }
}

注意，泛型在数组上的使用有限制，因为Java不允许创建泛型数组（如T[] array = new T[size];是无效的）。但你可以像上面那样使用泛型方法接受泛型数组作为参数。

8. 多维数组

在Java中，你可以创建多维数组，例如二维数组。以下是一个二维数组的示例：

public class MultiDimensionalArrayDemo {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // 遍历二维数组
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

9. 数组连接

在Java中，数组没有直接的连接方法，但你可以通过循环或使用 System.arraycopy() 方法来实现：

public class ArrayConcatenationDemo {
    public static void main(String[] args) {
        int[] array1 = {1, 2, 3};
        int[] array2 = {4, 5, 6};

        // 使用System.arraycopy()连接数组
        int[] combined = new int[array1.length + array2.length];
        System.arraycopy(array1, 0, combined, 0, array1.length);
        System.arraycopy(array2, 0, combined, array1.length, array2.length);

        // 打印连接后的数组
        for (int num : combined) {
            System.out.print(num + " ");
        }
    }
}

10. 数组作为参数和返回值

数组可以作为方法的参数和返回值。

public class GenericArrayMethodDemo {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5};
        String[] strings = {"one", "two", "three"};

        printArray(integers); // 输出: 1 2 3 4 5
        printArray(strings);  // 输出: one two three
    }
}

完成！enjoy it!