用Java程序实现集合的运算（特别是增加 删除 修改 查询 交集 并集 等等幂集的快速运算）

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Test1<T> {
    Set<T> set = new HashSet<>();  //创建一个集合类

    Test1() {
    }             //?

    Test1(Set set) {     //可以用集合类的set初始化set
        this.set = set;
    }

    Test1(Test1 test1) {    //用自己的类类型来初始化自己

        this.set = test1.set;
    }


    Test1(T[] TS)          //任意的类型遍历初始化test1
    {
        for (T t : TS)
            set.add(t);
    }

    //输出：
    public void out()
    {
        System.out.println(set.toString());
    }

    public boolean insert(T element)  // 添加
    {
        return set.add(element);
    }

    public boolean delete(T element)   //删除
    {
        return set.remove(element);
    }

    public boolean searchElemnt(T element) {
        return set.contains(element);  //查找是否有这个子集
    }

    public boolean isSet(List<T> list) {
        Set set = new HashSet<>();
        for (T t : list) {
            if (!set.add(t)) {
                return false;
            }         //判断是否存在 Set集合中不能用相同的元素
        }
        return true;
    }

    public Test1<T> union(Test1<T> test1) {
        for (T t : test1.set) {                                   // 并集 把没有包含的T都包含进去
            this.set.add(t);
        }
        return this;
    }

    public Test1<T> gather(Test1<T> test1) {
        Test1<T> objectTest1 = new Test1<>();
        for (T t : set)   //自己本来的集合
        {
            if (test1.set.contains(t))   //如果有重复
            {
                objectTest1.set.add(t);
            }
        }
        return objectTest1;
    }

    public Test1<T> differ(Test1<T> test1) {
        for (T t : test1.set) {
            if (set.contains(t)) {
                set.remove(t);
            }
        }
        return this;
    }

    public Test1<T> oppsiteDiffer(Test1<T> test1) {
        for (T t : test1.set) {
            if (set.contains(t)) {                                         //  交叉并集
                set.remove(t);
            } else {
                set.add(t);
            }
        }
        return this;
    }

    public int size()              // 返回大小
    {
        int size = set.size();
        return size;
    }

    public boolean contain(Test1<T> test1) {
        if (set.containsAll(test1.set))   //判断是否包含；
        {
            return true;
        }
        return false;
    }


    //求幂集
    public Set sumSet(Set<Set<T>> sets,Set<T> set){
        //每次递归前先把当前集合加入到嵌套集合中set->sets
        sets.add(set);
        //遍历当前集合，依次减到一个元素，然后递归函数
        for(T t:set){
            Set<T> temp = new HashSet<>(set);
            temp.remove(t);
            sumSet(sets,temp);
        }
        return sets;
    }
}

前面的内容都很简单 但是幂集的部分运用到了递归的思想；意思就是 每一次算的时候都去掉一个数字 这个集合有四个数 那就有四次的循环运算：

这样的循环可以用递归的办法实现，这样以后每一次都会变化。具体你可以断点调试 会看的更明白，

总之你复制粘贴后断点调试就明白啦！