Java实习日记（9)

List集合的交集（retainAll）、并集（addAll）、差集（removeAll）

简单说明一下：
交集：指的是两个List集合中共同的元素
并集：指的是两个List集合中所有的元素，有可能会出现重复元素
差集：指的是从一个集合中去除另外一个个集合的元素

package com.lining.test;

import java.util.ArrayList;
import java.util.List;

public class ListTest {

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        list1.add("Alice");
        list1.add("Bob");
        list1.add("Emma");
        list1.add("Jack");
        list1.add("Kevin");

        List<String> list2 = new ArrayList<String>();
        list2.add("Rose");
        list2.add("Mary");
        list2.add("David");
        list2.add("Alice");
        list2.add("Bob");

        // 交集 ==> Alice、Bob
        getIntersection(list1, list2);

        // 差集 ==> Emma、Jack、Kevin
        // getDifference(list1, list2);

        // 并集 ==> Alice、Bob、Emma、Jack、Kevin、Rose、Mary、David、Alice、Bob
        // getUnion(list1, list2);

        // 并集(去重) ==> Emma、Jack、Kevin、Rose、Mary、David、Alice、Bob
        // getUnionWithoutDuplicate(list1, list2);
    }

    /**
     * @Title: getIntersection 
     * @Description: 取两个List<String>集合的交集
     * @param list1
     * @param list2
     * @return void
     */
    public static void getIntersection(List<String> list1, List<String> list2) {
        // List集合交集，返回值类型是Boolean
        boolean intersection = list1.retainAll(list2);
        if (intersection) {
            print(list1);
        }
    }

    /**
     * @Title: getUnion 
     * @Description: 取两个List<String>集合的并集
     * @param list1
     * @param list2
     * @return void
     */
    public static void getUnion(List<String> list1, List<String> list2) {
        // List集合并集，返回值类型是Boolean
        boolean union = list1.addAll(list2);
        if (union) {
            print(list1);
        }
    }

    /**
     * @Title: getUnionWithoutDuplicate 
     * @Description: 取两个List<String>集合的并集（去重）
     * @param list1
     * @param list2
     * @return void
     */
    public static void getUnionWithoutDuplicate(List<String> list1, List<String> list2) {
        // 先去除list1中存在的list2元素
        list1.removeAll(list2);
        // 将list2元素全部存入list1
        list1.addAll(list2);
        print(list1);
    }

    /**
     * @Title: getDifference 
     * @Description: 取两个List<String>集合的差集
     * @param list1
     * @param list2
     * @return void
     */
    public static void getDifference(List<String> list1, List<String> list2) {
        // 去除list1中存在的list2元素
        list1.removeAll(list2);
        print(list1);
    }

    /**
     * @Title: print 
     * @Description: 打印输出
     * @param list
     * @return void
     */
    public static void print(List<String> list) {
        for (String string : list) {
            System.out.println(string);
        }
    }
}

List集合中元素也可以是Object，但是需要注意的是需要重写Bean的equals方法，因为判断list中两个对象是否相等是通过equals来完成的；如果不重写equals方法，使用retainAll求集合交集时得到的元素个数就会是0。

package com.lining.test;

/** 
 * @ClassName: User 
 * @Description: 用户类
 * @author lining
 * @date 2018年5月13日 下午2:48:58 
 */
public class User {

    /**
     * 用户名
     */
    public String userName;

    /**
     * 密码
     */
    public String passWord;

    /**
     * 构造函数
     */
    public User(String userName, String passWord) {
        super();
        this.userName = userName;
        this.passWord = passWord;
    }

    // ----- getter/setter -----

    /**
     * @return the userName
     */
    public String getUserName() {
        return userName;
    }

    /**
     * @param userName the userName to set
     */
    public void setUserName(String userName) {
        this.userName = userName;
    }

    /**
     * @return the passWord
     */
    public String getPassWord() {
        return passWord;
    }

    /**
     * @param passWord the passWord to set
     */
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    /*
     * Title: toString
     * Description: 
     * @return 
     * @see java.lang.Object#toString() 
     */
    @Override
    public String toString() {
        return "User [userName=" + userName + ", passWord=" + passWord + "]";
    }

    /*
     * Title: equals
     * Description: 
     * @param obj
     * @return 
     * @see java.lang.Object#equals(java.lang.Object) 
     */
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof User) {
            User user = (User) obj;
            return (userName.equals(user.userName));
        }
        return super.equals(obj);
    }
}

package com.lining.test;

import java.util.ArrayList;
import java.util.List;

public class ListObjectTest {

    public static void main(String[] args) {
        List<User> list1 = new ArrayList<User>();
        list1.add(new User("Alice", "Alice"));
        list1.add(new User("Bob", "Bob"));
        list1.add(new User("Emma", "123456"));
        list1.add(new User("Jack", "123456"));
        list1.add(new User("Kevin", "123456"));

        List<User> list2 = new ArrayList<User>();
        list2.add(new User("Rose", "123456"));
        list2.add(new User("Mary", "123456"));
        list2.add(new User("David", "123456"));
        list2.add(new User("Alice", "Alice"));
        list2.add(new User("Bob", "Bob"));

        // 交集 
        // getIntersection(list1, list2);

        // 差集 
        // getDifference(list1, list2);

        // 并集
        // getUnion(list1, list2);

        // 并集(去重) 
        getUnionWithoutDuplicate(list1, list2);
    }

    /**
     * @Title: getIntersection 
     * @Description: 取两个List<User>集合的交集
     * @param list1
     * @param list2
     * @return void
     */
    public static void getIntersection(List<User> list1, List<User> list2) {
        // List集合交集，返回值类型是Boolean
        boolean intersection = list1.retainAll(list2);
        if (intersection) {
            System.out.println("交集元素的个数：" + list1.size());
            print(list1);
        }
    }

    /**
     * @Title: getUnion 
     * @Description: 取两个List<String>集合的并集
     * @param list1
     * @param list2
     * @return void
     */
    public static void getUnion(List<User> list1, List<User> list2) {
        // List集合并集，返回值类型是Boolean
        boolean union = list1.addAll(list2);
        System.out.println("并集元素的个数：" + list1.size());
        if (union) {
            print(list1);
        }
    }

    /**
     * @Title: getUnionWithoutDuplicate 
     * @Description: 取两个List<String>集合的并集（去重）
     * @param list1
     * @param list2
     * @return void
     */
    public static void getUnionWithoutDuplicate(List<User> list1, List<User> list2) {
        // 先去除list1中存在的list2元素
        list1.removeAll(list2);
        // 将list2元素全部存入list1
        list1.addAll(list2);
        System.out.println("并集元素的个数：" + list1.size());
        print(list1);
    }

    /**
     * @Title: getDifference 
     * @Description: 取两个List<String>集合的差集
     * @param list1
     * @param list2
     * @return void
     */
    public static void getDifference(List<User> list1, List<User> list2) {
        // 去除list1中存在的list2元素
        list1.removeAll(list2);
        System.out.println("差集元素的个数：" + list1.size());
        print(list1);
    }

    /**
     * @Title: print 
     * @Description: 打印输出
     * @param list
     * @return void
     */
    public static void print(List<User> list) {
        for (User user : list) {
            System.out.println(user.toString());
        }
    }
}

未重写equals方法：

交集元素的个数：0

重写equals方法：

交集元素的个数：2
User [userName=Alice, passWord=Alice]
User [userName=Bob, passWord=Bob]

参考链接：
https://blog.csdn.net/streetlight8023/article/details/52789840

猜你喜欢