Java实现基于位运算的集合操作

import java.util.ArrayList;

/**
 * 利用位字符串演示集合操作的程序。
 * 该程序包含用于求集合的补集、并集、交集和差集的方法。
 * 它还提供了一种将元素数组转换为位字符串的方法。
 *
 * @author XiaoyinZhao
 * @version 1.0
 */
public class Lab1 {
    public static int[] attr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    public static int[] list = new int[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
    public static int[] attr1 = new int[]{2, 3, 4, 5, 6};
    public static int[] attr2 = new int[]{1, 2, 4, 6, 7, 8};

    /**
     * 计算给定其位字符串表示形式的集合的补集。
     *
     * @param list 集合的位字符串表示形式。
     * @return 作为 ArrayList 的集合的补集。
     */
    public static ArrayList<Integer> complement(int[] list) {
        ArrayList<Integer> result = new ArrayList<>();
        for (int i = 0; i < list.length; i++) {
            if (list[i] == 0) {
                result.add(attr[i]);
            }
        }
        return result;
    }

    /**
     * 计算给定其位字符串表示形式的两个集合的并集。
     *
     * @param list1 集合 A 的位字符串表示形式。
     * @param list2 集合 B 的位字符串表示形式。
     * @return 作为 ArrayList 的集合 A 和集合 B 的并集。
     */
    public static ArrayList<Integer> union(int[] list1, int[] list2) {
        ArrayList<Integer> result = new ArrayList<>();
        int[] union = new int[list1.length];
        for (int i = 0; i < union.length; i++) {
            union[i] = list1[i] | list2[i];
            if (union[i] == 1) {
                result.add(attr[i]);
            }
        }
        return result;
    }

    /**
     * 计算给定其位字符串表示形式的两个集合的交集。
     *
     * @param list1 集合 A 的位字符串表示形式。
     * @param list2 集合 B 的位字符串表示形式。
     * @return 作为 ArrayList 的集合 A 和集合 B 的交集。
     */
    public static ArrayList<Integer> intersection(int[] list1, int[] list2) {
        ArrayList<Integer> result = new ArrayList<>();
        int[] intersection = new int[list1.length];
        for (int i = 0; i < intersection.length; i++) {
            intersection[i] = list1[i] & list2[i];
            if (intersection[i] == 1) {
                result.add(attr[i]);
            }
        }
        return result;
    }

    /**
     * 计算给定其位字符串表示形式的两个集合的差集。
     *
     * @param list1 集合 A 的位字符串表示形式。
     * @param list2 集合 B 的位字符串表示形式。
     * @return 作为 ArrayList 的集合 A 和集合 B 的差集。
     */
    public static ArrayList<Integer> difference(int[] list1, int[] list2) {
        ArrayList<Integer> result = new ArrayList<>();
        int[] difference = new int[list1.length];
        for (int i = 0; i < difference.length; i++) {
            difference[i] = list1[i] & (~list2[i]);
            if (difference[i] == 1) {
                result.add(attr[i]);
            }
        }
        return result;
    }

    /**
     * 将元素数组转换为位字符串表示形式。
     *
     * @param arr 表示集合元素的数组。
     * @return 集合的位字符串表示形式。
     */
    public static int[] bitString(int[] arr) {
        int[] list = new int[attr.length];
        for (int i = 0; i < attr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if (attr[i] == arr[j]) {
                    list[i] = 1;
                }
            }
        }
        return list;
    }

    /**
     * 用于测试集合操作方法的 main 方法。
     *
     * @param args 包含命令行参数的字符串数组的引用。
     */
    public static void main(String[] args) {
        // 使用 bitString 方法获取位字符串表示形式
        int[] list1 = bitString(attr1);
        int[] list2 = bitString(attr2);

        // 获取补集、并集、交集、差集
        ArrayList<Integer> complementA = complement(list1);
        ArrayList<Integer> complementB = complement(list2);
        ArrayList<Integer> unionAB = union(list1, list2);
        ArrayList<Integer> intersectionAB = intersection(list1, list2);
        ArrayList<Integer> differenceAB = difference(list1, list2);

        // 打印结果
        System.out.println('集合 A 的补集是：' + complementA);
        System.out.println('集合 B 的补集是：' + complementB);
        System.out.println('集合 A 和 B 的并集是：' + unionAB);
        System.out.println('集合 A 和 B 的交集是：' + intersectionAB);
        System.out.println('集合 A 和 B 的差集是：' + differenceAB);
    }
}