大家好，欢迎来到IT知识分享网。

Java中的数组是对象，继承自Object类，因此可以使用Object类的方法，如toString(), hashCode(), 和 equals(Object obj) 等。这些方法对于数组来说可能不是很有用，因为它们是基于对象的引用而不是内容来比较的。在处理数组时，通常需要使用循环来遍历和操作数组元素。

数组常用操作：

获取数组长度：

int[] array = new int[10]; int length = array.length; // 获取数组长度

访问/修改数组元素：

int[] array = {1, 2, 3, 4, 5, 6} array[0]= 0; // 修改数组中索引为0的元素值为0 int element = array[2]; // 访问数组中索引为2的元素

数组填充：

public class Main { public static void main(String[] args) { // 定义并初始化一个整型数组 int[] numbers = new int[5]; // 使用Arrays.fill()方法填充整个数组为特定值 Arrays.fill(numbers, 10); // 输出填充后的数组 for (int num : numbers) { System.out.print(num + " "); } // 输出: 10 10 10 10 10 } }

数组复制：

在Java中，有多种方法可以用来复制数组，以下分别给出使用`System.arraycopy()`、`Arrays.copyOf()`和`Arrays.copyOfRange()`方法进行数组复制的案例：

示例1：使用 `System.arraycopy()` 方法复制数组

public class Main { public static void main(String[] args) { // 创建原始数组 int[] originalArray = {1, 2, 3, 4, 5}; // 创建目标数组，大小足够容纳原始数组的所有元素 int[] copiedArray = new int[originalArray.length]; // 使用 System.arraycopy() 进行复制 System.arraycopy(originalArray, 0, copiedArray, 0, originalArray.length); // 输出复制后的数组 for (int item : copiedArray) { System.out.print(item + " "); } // 输出: 1 2 3 4 5 } }

示例2：使用 `Arrays.copyOf()` 方法复制整个数组：

import java.util.Arrays; public class Main { public static void main(String[] args) { // 创建原始数组 int[] originalArray = {1, 2, 3, 4, 5}; // 使用 Arrays.copyOf() 进行复制，同时可以选择扩大或缩小目标数组的大小 int[] copiedArray = Arrays.copyOf(originalArray, originalArray.length); // 输出复制后的数组 for (int item : copiedArray) { System.out.print(item + " "); } // 输出: 1 2 3 4 5 } } // 如果想复制后得到更大的数组，只需要调整第二个参数即可 int[] largerCopiedArray = Arrays.copyOf(originalArray, originalArray.length + 5);

示例3：使用 `Arrays.copyOfRange()` 方法复制数组的部分范围：

 import java.util.Arrays; public class Main { public static void main(String[] args) { // 创建原始数组 int[] originalArray = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // 使用 Arrays.copyOfRange() 复制从索引2开始的三个元素 int fromIndex = 2; int toIndex = fromIndex + 3; int[] partialCopyArray = Arrays.copyOfRange(originalArray, fromIndex, toIndex); // 输出复制的部分数组 for (int item : partialCopyArray) { System.out.print(item + " "); } // 输出: 2 3 4 } }

数组排序：

在Java中，数组排序可以使用`java.util.Arrays`类中的`sort()`方法来实现。以下是几种不同的数组排序案例：

示例1：整型数组升序排序

import java.util.Arrays; public class Main { public static void main(String[] args) { // 创建一个整型数组 int[] numbers = {5, 3, 8, 1, 9, 2, 7, 4, 6}; // 使用Arrays.sort()方法进行排序 Arrays.sort(numbers); // 输出排序后的数组 for (int number : numbers) { System.out.print(number + " "); } // 输出：1 2 3 4 5 6 7 8 9 } }

示例2：浮点型数组排序

import java.util.Arrays; public class Main { public static void main(String[] args) { // 创建一个浮点型数组 double[] doubles = {3.5, 1.2, 9.8, 2.1, 5.3}; // Arrays.sort()也可以用于排序浮点数数组 Arrays.sort(doubles); // 输出排序后的数组 for (double d : doubles) { System.out.print(d + " "); } // 输出：1.2 2.1 3.5 5.3 9.8 } }

示例3：对象数组排序（按照对象属性）

假设有一个`Person`类，包含`name`和`age`属性，我们可以根据年龄对其进行排序：

import java.util.Arrays; import java.util.Comparator; class Person { String name; int age; Person(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } } public class Main { public static void main(String[] args) { // 创建一个Person对象数组 Person[] people = { new Person("Alice", 25), new Person("Bob", 30), new Person("Charlie", 20), new Person("David", 35) }; // 自定义比较器按年龄排序 Comparator<Person> byAge = Comparator.comparingInt(Person::getAge); // 使用Arrays.sort()方法结合比较器排序 Arrays.sort(people, byAge); // 输出排序后的数组 for (Person person : people) { System.out.println(person); } } } // 输出按年龄升序排列的人名和年龄信息 

数组转换为字符串：

在Java中，将数组转换为字符串有几种常见的方式，下面列举几个具体的案例：

示例1：使用 `Arrays.toString()` 方法

import java.util.Arrays; public class Main { public static void main(String[] args) { // 创建一个整型数组 int[] numbers = {1, 2, 3, 4, 5}; // 使用Arrays.toString()方法将数组转换为字符串 String strNumbers = Arrays.toString(numbers); // 输出转换后的字符串 System.out.println(strNumbers); // 输出：[1, 2, 3, 4, 5] } }

示例2：使用 `toString()` 和 `join()` 方法（Java 8+，针对字符数组）

public class Main { public static void main(String[] args) { // 创建一个字符数组 char[] chars = {'H', 'e', 'l', 'l', 'o'}; // 使用String.join()方法将字符数组转换为字符串（Java 8+） String strChars = String.join("", chars); // 输出转换后的字符串 System.out.println(strChars); // 输出：Hello } }

注意：`String.join()` 不适用于普通对象数组，它主要用于将字符数组或其他可迭代对象转换为字符串，且不需要额外的字符作为分隔符。

示例3：使用 `StringBuilder` 或 `StringBuffer` 拼接

public class Main { public static void main(String[] args) { // 创建一个整型数组 int[] integers = {1, 2, 3, 4, 5}; // 使用StringBuilder进行转换 StringBuilder sb = new StringBuilder(); for (int i : integers) { sb.append(i).append(", "); } // 移除最后一个逗号和空格 if (sb.length() > 0) { sb.setLength(sb.length() - 2); } String strIntegers = sb.toString(); // 输出转换后的字符串 System.out.println(strIntegers); // 输出：1, 2, 3, 4, 5 } }

示例4：自定义分隔符（例如用逗号分隔）

public class Main { public static void main(String[] args) { // 创建一个字符串数组 String[] names = {"Alice", "Bob", "Charlie"}; // 使用StringBuilder和自定义分隔符 StringBuilder sb = new StringBuilder(); for (int i = 0; i < names.length; i++) { sb.append(names[i]); if (i != names.length - 1) { sb.append(", "); // 添加逗号和空格作为分隔符 } } String strNames = sb.toString(); // 输出转换后的字符串 System.out.println(strNames); // 输出：Alice, Bob, Charlie } }

数组反转：

public class Main { public static void main(String[] args) { // 创建一个整型数组 int[] numbers = {1, 2, 3, 4, 5}; // 打印反转前的数组 System.out.println("Before reversal: " + Arrays.toString(numbers)); // 调用反转方法 reverseArray(numbers); // 打印反转后的数组 System.out.println("After reversal: " + Arrays.toString(numbers)); } // 定义反转数组的方法 public static void reverseArray(int[] arr) { int start = 0; int end = arr.length - 1; while (start < end) { // 临时变量保存arr[start]的值，然后将其与arr[end]交换 int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; // 更新边界指针 start++; end--; } } } // 输出： // Before reversal: [1, 2, 3, 4, 5] // After reversal: [5, 4, 3, 2, 1] 

查找元素：

在Java中查找数组中的元素，可以手动编写循环进行查找，也可以使用Java 8及其以后版本的Stream API进行查找。以下是两种不同方式查找数组元素的案例：

示例1：使用循环查找数组中的元素

public class Main { public static void main(String[] args) { // 创建一个整型数组 int[] numbers = {1, 2, 3, 4, 5, 6}; // 要查找的目标元素 int target = 4; // 初始化查找结果为-1（表示未找到） int index = -1; // 遍历数组查找目标元素 for (int i = 0; i < numbers.length; i++) { if (numbers[i] == target) { index = i; break; // 找到后跳出循环 } } // 输出结果 if (index != -1) { System.out.println("Element " + target + " found at index " + index); } else { System.out.println("Element " + target + " not found in the array"); } } } 

示例2：使用Java 8 Stream API查找数组元素的索引

import java.util.Arrays; import java.util.OptionalInt; import java.util.stream.IntStream; public class Main { public static void main(String[] args) { // 同样的整型数组 int[] numbers = {1, 2, 3, 4, 5, 6}; // 目标元素 int target = 4; // 使用Stream API查找元素的索引 OptionalInt indexOptional = IntStream.range(0, numbers.length) .filter(i -> numbers[i] == target) .findFirst(); // 输出结果 if (indexOptional.isPresent()) { System.out.println("Element " + target + " found at index " + indexOptional.getAsInt()); } else { System.out.println("Element " + target + " not found in the array"); } } } 

在示例2中，使用了`IntStream.range`创建了一个表示数组索引的流，然后通过`filter`方法筛选出与目标值相等的元素索引，并使用`findFirst`找出第一个匹配项（如果有）。由于`findFirst`返回的是`OptionalInt`类型，需要通过`isPresent`检查是否有找到元素，然后使用`getAsInt`获取索引值。

数组合并：

public class Main { public static void main(String[] args) { // 创建两个整数数组 int[] array1 = {1, 2, 3}; int[] array2 = {4, 5, 6}; // 合并数组 int[] mergedArray = new int[array1.length + array2.length]; // 将array1的元素复制到mergedArray System.arraycopy(array1, 0, mergedArray, 0, array1.length); // 将array2的元素复制到mergedArray适当的位置 System.arraycopy(array2, 0, mergedArray, array1.length, array2.length); // 输出合并后的数组 for (int num : mergedArray) { System.out.print(num + " "); } } } // 输出结果：1 2 3 4 5 6