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 list1 集合 A 的位字符串表示。
     * @param list2 集合 B 的位字符串表示。
     */
    public static void Complement(int[] list1, int[] list2){
        ArrayList<Integer> resultA = new ArrayList<>();
        ArrayList<Integer> resultB = new ArrayList<>();
        for(int i = 0; i < list.length; i++){
            if(list1[i] == 0){
                resultA.add(attr[i]);
            }
        }
        System.out.println('The Complement of A is: ' + resultA);
        for(int i = 0; i < list.length; i++){
            if(list2[i] == 0){
                resultB.add(attr[i]);
            }
        }
        System.out.println('The Complement of B is: ' + resultB);
    }

    /**
     * 计算给定两个集合的位字符串表示的并集。
     *
     * @param list1 集合 A 的位字符串表示。
     * @param list2 集合 B 的位字符串表示。
     */
    public static void Union(int[] list1, int[] list2){
        ArrayList<Integer> result = new ArrayList<>();
        int[] union = new int[]{0,0,0,0,0,0,0,0,0,0};
        for(int i = 0; i < union.length; i++){
            if(list1[i] == 1 || list2[i] == 1){
                union[i] = 1;
            }
        }
        for(int i = 0; i < list.length; i++){
            if(union[i] == 1){
                result.add(attr[i]);
            }
        }
        System.out.println('The Union of A and B is: ' + result);
    }

    /**
     * 计算给定两个集合的位字符串表示的交集。
     *
     * @param list1 集合 A 的位字符串表示。
     * @param list2 集合 B 的位字符串表示。
     */
    public static void Intersection(int[] list1, int[] list2){
        ArrayList<Integer> result = new ArrayList<>();
        int[] intersection = new int[]{0,0,0,0,0,0,0,0,0,0};
        for(int i = 0; i < intersection.length; i++){
            if(list1[i] == 1 && list2[i] == 1){
                intersection[i] = 1;
            }
        }
        for(int i = 0; i < list.length; i++){
            if(intersection[i] == 1){
                result.add(attr[i]);
            }
        }
        System.out.println('The Intersection of A and B is: ' + result);
    }

    /**
     * 计算给定两个集合的位字符串表示的差集。
     *
     * @param list1 集合 A 的位字符串表示。
     * @param list2 集合 B 的位字符串表示。
     */
    public static void Difference(int[] list1, int[] list2){
        ArrayList<Integer> result = new ArrayList<>();
        int[] difference = new int[]{0,0,0,0,0,0,0,0,0,0};
        for(int i = 0; i < difference.length; i++){
            if(list1[i] != list2[i]){
                difference[i] = 1;
            }
        }
        for(int i = 0; i < list.length; i++){
            if(difference[i] == 1){
                result.add(attr[i]);
            }
        }
        System.out.println('The Difference of A and B is: ' + result);
    }

    /**
     * 将元素数组转换为位字符串表示。
     *
     * @param list 集合的位字符串表示。
     * @param arr  表示集合元素的数组。
     */
    public static void BitString(int[] list, int[] arr){
        for(int i = 0; i < attr.length; i++){
            for(int j = 0; j < arr.length; j++){
                if(attr[i] == arr[j]){
                    list[i] = 1;
                }
            }
        }
        System.out.print('[ ');
        for(int i = 0; i < list.length; i++){
            System.out.print(list[i] + ' ');
        }
        System.out.println(']');
    }

    /**
     * 用于测试集合运算方法的main方法。
     *
     * @param args 包含命令行参数的字符串数组的引用。
     */
    public static void main(String[] args){
        // 创建两个数组以获取位字符串
        int[] list1 = new int[]{0,0,0,0,0,0,0,0,0,0};
        int[] list2 = new int[]{0,0,0,0,0,0,0,0,0,0};

        // 使用该方法获取位字符串
        BitString(list1, attr1);
        BitString(list2, attr2);

        // 获取补码、并集、交集、差集
        Complement(list1, list2);
        Union(list1, list2);
        Intersection(list1, list2);
        Difference(list1, list2);
    }
}