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