Java 数组实例

---

1. 数组排序及元素查找
2. 数组添加元素
3. 获取数组长度
4. 数组反转
5. 数组输出
6. 数组获取最大和最小值
7. 数组合并
8. 数组填充
9. 数组扩容
10. 查找数组中的重复元素
11. 删除数组元素
12. 数组差集
13. 数组交集
14. 数组并集
15. 在数组中查找指定元素
16. 判断数组是否相等

---

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class HelloWorld {
    public static void main(String[] args) {

        System.out.println("-------------1数组排序及元素查找----------------");
        int arr[] = { 2, 5, -2, 6, -3, 8, 0, 1, 5 };
        printArray("最初的数组为", arr);
        Arrays.sort(arr); // 使用sort()方法对Java数组进行排序
        printArray("数组排序结果为", arr);
        int index1 = Arrays.binarySearch(arr, 0); // binarySearch() 方法来查找数组中的元素
        System.out.println("元素 0 在第 " + index1 + " 个位置");

        System.out.println("-----------2添加元素------------------");
        printArray("添加元素前的数组为", arr);
        int index2 = Arrays.binarySearch(arr, 9);
        System.out.println("元素 9 所在位置（负数为不存在）: " + index2);
        int newIndex = -index2 - 1;
        arr = insertElement(arr, 9, newIndex);
        printArray("添加元素后的数组为", arr);

        System.out.println("-------------3获取长度----------------");
        String[][][] data = new String[2][3][4];
        System.out.println("第一维数组长度: " + data.length);
        System.out.println("第二维数组长度: " + data[0].length);
        System.out.println("第三维数组长度: " + data[0][0].length);

        System.out.println("--------------4数组反转---------------");
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("C");
        arrayList.add("D");
        arrayList.add("E");
        System.out.println("反转前排序: " + arrayList);
        Collections.reverse(arrayList);
        System.out.println("反转后排序: " + arrayList);

        System.out.println("-------------5数组输出----------------");
        String[] greeting = new String[3];
        greeting[0] = "菜鸟教程";
        greeting[1] = "菜鸟工具";
        greeting[2] = "菜鸟笔记";
        for (int i = 0; i < greeting.length; i++) {
            System.out.println(greeting[i]);
        }

        System.out.println("-----------6数组获得最值------------------");
        Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5 };
        int min = (int) Collections.min(Arrays.asList(numbers));
        int max = (int) Collections.max(Arrays.asList(numbers));
        System.out.println("最小值: " + min);
        System.out.println("最大值: " + max);

        System.out.println("-------------7数组合并----------------");
        // 通过 List 类的 Arrays.toString () 方法和 List 类的 list.Addall(array1.asList(array2)
        // 方法将两个数组合并为一个数组
        String a[] = { "A", "E", "I" };
        String b[] = { "O", "U" };
        List<String> list = new ArrayList<String>(Arrays.asList(a));
        list.addAll(Arrays.asList(b));
        Object[] c = list.toArray();
        System.out.println(Arrays.toString(c));

        System.out.println("-------------8数组填充----------------");
        // 通过 Java Util 类的 Arrays.fill(arrayname,value) 方法和Arrays.fill(arrayname
        // ,starting index ,ending index ,value) 方法向数组中填充元素
        int array[] = new int[6];
        Arrays.fill(array, 100);
        for (int i = 0, n = array.length; i < n; i++) {
            System.out.println(array[i]);
        }
        System.out.println();
        Arrays.fill(array, 3, 6, 50);
        for (int i = 0, n = array.length; i < n; i++) {
            System.out.println(array[i]);
        }

        System.out.println("-------------9数组扩容----------------");
        // 在数组初始化后对数组进行扩容
        String[] names = new String[] { "A", "B", "C" };
        String[] extended = new String[5];
        extended[3] = "D";
        extended[4] = "E";
        System.arraycopy(names, 0, extended, 0, names.length);
        for (String str : extended) {
            System.out.println(str);
        }

        System.out.println("--------------10查找重复元素---------------");
        int[] my_array = { 1, 2, 5, 5, 6, 6, 7, 2 };
        for (int i = 0; i < my_array.length - 1; i++) {
            for (int j = i + 1; j < my_array.length; j++) {
                if ((my_array[i] == my_array[j]) && (i != j)) {
                    System.out.println("重复元素 : " + my_array[j]);
                }
            }
        }

        System.out.println("-------------11删除数组元素----------------");
        ArrayList<String> objArray = new ArrayList<String>();
        objArray.clear();
        objArray.add(0, "第 0 个元素");
        objArray.add(1, "第 1 个元素");
        objArray.add(2, "第 2 个元素");
        System.out.println("数组删除元素前：" + objArray);
        objArray.remove(1);
        objArray.remove("第 0 个元素");
        System.out.println("数组删除元素后：" + objArray);

        System.out.println("-------------12数组差集----------------");
        // 使用 removeAll () 方法来计算两个数组的差集
        ArrayList<String> objArray1 = new ArrayList<String>();
        ArrayList<String> objArray2 = new ArrayList<String>();
        objArray2.add(0, "common1");
        objArray2.add(1, "common2");
        objArray2.add(2, "notcommon");
        objArray2.add(3, "notcommon1");
        objArray1.add(0, "common1");
        objArray1.add(1, "common2");
        objArray1.add(2, "notcommon2");
        System.out.println("array1 的元素" + objArray1);
        System.out.println("array2 的元素" + objArray2);
        objArray1.removeAll(objArray2);
        System.out.println("array1 与 array2 数组差集为：" + objArray1);

        System.out.println("--------------13数组交集---------------");
        // retainAll () 方法来计算两个数组的交集
        ArrayList<String> objArray3 = new ArrayList<String>();
        ArrayList<String> objArray4 = new ArrayList<String>();
        objArray4.add(0, "common1");
        objArray4.add(1, "common2");
        objArray4.add(2, "notcommon");
        objArray4.add(3, "notcommon1");
        objArray3.add(0, "common1");
        objArray3.add(1, "common2");
        objArray3.add(2, "notcommon2");
        System.out.println("array1 数组元素：" + objArray3);
        System.out.println("array2 数组元素：" + objArray4);
        objArray3.retainAll(objArray4);
        System.out.println("array3 & array4 数组交集为：" + objArray3);

        System.out.println("--------------14数组并集---------------");
        String[] arr1 = { "1", "2", "3" };
        String[] arr2 = { "3", "4", "5" };
        String[] result_union = union(arr1, arr2);
        System.out.println("并集的结果如下：");
        for (String str : result_union) {
            System.out.println(str);
        }

        System.out.println("--------------15在数组中查找指定元素---------------");
        // contains () 方法来查找数组中的指定元素
        ArrayList<String> objArray5 = new ArrayList<String>();
        objArray5.add(0, "common1");
        objArray5.add(1, "common2");
        objArray5.add(2, "notcommon");
        System.out.println("objArray5 的数组元素：" + objArray5);
        System.out.println("objArray5 是否包含字符串common2? ： " + objArray5.contains("common2"));

        System.out.println("-----------16判断数组是否相等------------------");
        int[] aa = { 1, 2, 3, 4, 5, 6 };
        int[] bb = { 1, 2, 3, 4, 5, 6 };
        System.out.println("数组 ary 是否与数组 ary1相等? ：" + Arrays.equals(aa, bb));
    }

    // 打印數組
    private static void printArray(String message, int array[]) {
        System.out.print(message + ": [length: " + array.length + "] ");
        for (int i = 0; i < array.length; i++) {
            if (i != 0) {
                System.out.print(", ");
            }
            System.out.print(array[i]);
        }
        System.out.println();
    }

    private static int[] insertElement(int original[], int element, int index) {
        int length = original.length;
        int destination[] = new int[length + 1];
        System.arraycopy(original, 0, destination, 0, index);
        destination[index] = element;
        System.arraycopy(original, index, destination, index + 1, length - index);
        return destination;
    }

    // 求两个字符串数组的并集，利用set的元素唯一性
    public static String[] union(String[] arr1, String[] arr2) {
        Set<String> set = new HashSet<String>();

        for (String str : arr1) {
            set.add(str);
        }

        for (String str : arr2) {
            set.add(str);
        }

        String[] result = {};

        return set.toArray(result);
    }
}

---