java基础——使用数组存储数据并计算交集，并集（个人笔记）

        最近复习java基础知识，老师要求用创建两个数组存储数据，并计算他们之间的交集和并集（偷偷说一句，其实还要求计算差集，只不过这篇写的时候差集还有点问题）。弱弱说一句：本人萌新一枚，有错误的地方欢迎指出。

生成随机测试数组：

  public static int[] produceArr(int[] arr) {//用于随机生成元素为1-10的数组，方便测试。
        if (arr.length == 0) {
            System.out.println("请输入一个已经分配空间的数组");
        }
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(10);
        }
        return arr;
    }

将用于计算的数组升序排序并生成新的数组：

    public static int[] generateArrOneAndSortArr(int[] arr01, int[] arr02) {
        //给arr01和02进行升序排序，并返回一个新的只有默认值的数组
        int[] arr;
        if (arr01.length >= arr02.length) {
            arr = new int[arr02.length];
        } else {
            arr = new int[arr01.length];
        }
        Arrays.sort(arr01);
        Arrays.sort(arr02);
        return arr;
    }

计算交集：

public static int[] intersection(int[] arr01, int[] arr02) {
        int length01 = arr01.length;
        int length02 = arr02.length;
        int[] arr = generateArrOneAndSortArr(arr01, arr02);
        int count = 0;//记录交集数组arr的元素个数，同时充当下标
        int sign = 0;//用于记录下次内循环开始的下标
        int sign02 = 0;//用于标记比较过且相等的数的下标
        for (int i = 0; i < length01; i++) {//两层循环计算交集
            for (int j = sign; j < length02; j++) {
                if (arr01[i] == arr02[j]) {
                    if (i != 0 && j == sign02 && j != 0) {
                        //避免下一次外层循环的数与上一次比较过的内层循环比较，然后重复计算。
                        // 如A{6,6}，B{6,6}，避免A中的第二个6与B中的第一个6重复比较并记录
                        //当i == 0 或 j == 0时说明还没有交集元素产生
                        continue;
                    }
                    arr[count] = arr01[i];
                    count++;
                    sign++;
                    sign02 = j;//记录这次相同的数的下标
                    break;
                }
            }
        }
        if (count == 0) {//当count == 0说明arr中一个元素也没有，arr01和arr02没有交集
            System.out.println("该数组之间没有交集");
            return null;
        } else {//给交集数组缩容和去掉原本数组中的默认值，arr不经过这一步，
            // 得到的交集数组中含有原本数组初始化时的数，也就是0，因为在计算交集时arr01和02完成了升序排序，所以，3后面的0都是初始化时的默认值,
            //比如arr{1,2,3,0,0,0}，经过这一步后会得到arr{1,2,3}，
            int index = 0;
            for (int k = arr.length - 1; k >= 0; k--) {//计算用于缩容的新数组的最大下标值
                if (arr[k] != 0) {
                    index = k;
                    break;
                }
            }

            if (index != arr.length - 1) {//如果index == arr.length - 1相等说明arr没有初始化时的默认值，不需要缩容。
             
                //int[]  arr03 = new int[index + 1];//最大下标加一就是新数组所需的空间大小
               // for (int c = 0; c <= index; c++) {
                //    arr03[c] = arr[c];
               // }
                int[] arr03 = Arrays.copyOf(arr,index + 1);
                return arr03;
            }
        }
        return arr;
    }

这个计算方法太长，奈何本人实力不济，无法在只使用基础语句的情况下再精简了

并集：

    public static int[] union(int[] arr01, int[] arr02) {//并集
        //以arr01为模板进行扩容，扩容后的数组空间大小为arr02.length + arr01.length，并且保留arr01中的元素
        int[] arr = Arrays.copyOf(arr01, arr02.length + arr01.length);
        for (int j = arr01.length, k = 0; j < arr01.length + arr02.length; j++, k++) {
            arr[j] = arr02[k];
        }
        return arr;
    }

剩下的差集有机会在记录上去，如果有什么问题欢迎指出。