Java基础（十八）Collection

1. 去重统计

使用一个List集合存储多个元素。计算集合中共有多少个不重复元素并输出。

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

public class RemoveDuplicates01 {
    public static void main(String[] args) {
        List<String> list = List.of("1","2","1","a","b","a");
        HashSet<String> hashSet = new HashSet<>();
        // addAll 将所有元素添加到 HashSet;
        hashSet.addAll(list);
        System.out.println(hashSet.size());  // 4
    }
}

2. 交集计算

有两个List集合, 计算两个集合的交集元素。

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

public class ListIntersection02 {
    public static void main(String[] args) {
        List<String> list1 = List.of("1","2","1","a","b","a");
        List<String> list2 = List.of("1","2","c","a","0");

        List intersection = intersection(list1, list2);
        System.out.println("交集为" + intersection);
    }

    /**
     * 获取交集
     * @param list1
     * @param list2
     * @return List
     */
    public static List intersection(List<String> list1, List<String> list2) {
        // 使 list1 的长度最小
        if (list1.size() > list2.size()) {
            return intersection(list2, list1);
        }
        ArrayList list = new ArrayList();
        for (String str : list1) {
            if (list2.contains(str)) {
                list.add(str);
            }
        }
        return list;
    }
}

3. 差集运算

有两个List集合, 计算第一个集合对第二个集合的差集元素。

	/**
     * 差集
     * @param list1
     * @param list2
     * @return List
     */
    public static List differenceSet(List<String> list1, List<String> list2) {
        ArrayList list = new ArrayList();
        for (String str : list1) {
            if (!list2.contains(str)) {
                list.add(str);
            }
        }
        return list;
    }

4. 对称差集运算

有两个List集合, 计算两个集合的对称差集元素。

	/**
     * 对称差集
     * @return List
     */
    public static List<String> symmetryDifferenceSet(List<String> list1, List<String> list2) {
        ArrayList<String> list = new ArrayList<>();
        list.addAll(differenceSet(list1, list2));
        list.addAll(differenceSet(list2, list1));
        return list;
    }

5. 并集

有两个List集合, 计算两个集合的并集元素。

public static List<String> union(List<String> list1, List<String> list2) {
        ArrayList<String> list = new ArrayList<>();
        list.addAll(symmetryDifferenceSet(list1, list2));
        list.addAll(intersection(list1, list2));
        return list;
    }

6. 移除集合元素

使用Set集合存储多个字符串,移除其中长度为奇数的字符串

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class RemoveSetElements06 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("你好");
        set.add("hello");
        set.add("hello word");
        set.add("你好,世界");

        ramoveElements(set);
        System.out.println((set));
    }

    public static void ramoveElements(Set<String> set) {
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            // 判断长度是否为奇数
            if (str.length() % 2 != 0) {
                iterator.remove();
            }
        }
    }
}

7. 统计字符出现的次数

使用集合统计一段文本中各个字符出现的次数。

import java.util.HashSet;

public class Count07 {
    public static void main(String[] args) {
        String str = "Hello world!!!";
        HashSet<String> set = new HashSet<>();
        for (int i = 0; i < str.length(); i++) {
            set.add(str.charAt(i) + "");
        }
        for (String str1 : set) {
            System.out.println(str1 + ":" + count(str, str1));
        }
    }

    public static int count(String str, String c) {
        if (str == null) {
            return 0;
        }
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if (c.equals(str.charAt(i) + "")) {
                count ++;
            }
        }
        return count;
    }
}