Java Set 接口语法知识点及案例代码

Java 的 Set 接口是 Collection 接口的一个子接口，它不允许包含重复的元素。Set 接口的主要实现类有 HashSet、TreeSet 和 LinkedHashSet 等。下面是一份关于 Java Set 接口的语法知识点及案例代码，内容具体且代码有注释。

Java Set 接口语法知识点

1. 主要方法：

   • boolean add(E e): 添加指定元素到集合中，如果集合已经包含该元素，则返回 false。
   • boolean remove(Object o): 从集合中移除指定元素，如果集合包含该元素，则返回 true。
   • boolean contains(Object o): 如果集合包含指定元素，则返回 true。
   • int size(): 返回集合中的元素个数。
   • void clear(): 清空集合中的所有元素。
   • boolean isEmpty(): 如果集合不包含任何元素，则返回 true。
   • Iterator<E> iterator(): 返回集合的迭代器，用于遍历集合中的元素。

2. 主要实现类：

   • HashSet：基于哈希表实现，不允许包含重复元素，且元素是无序的。
   • TreeSet：基于红黑树实现，不允许包含重复元素，且元素是有序的（自然顺序或指定顺序）。
   • LinkedHashSet：具有 HashSet 的所有特性，同时维护元素的插入顺序。

案例代码

下面是一个简单的示例，演示如何使用 HashSet 和 TreeSet。

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

public class SetExample {
    public static void main(String[] args) {
        // 使用 HashSet
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Cherry");
        hashSet.add("Apple"); // 重复添加，不会生效

        System.out.println("HashSet 内容: " + hashSet);

        // 使用 TreeSet（自然排序）
        Set<String> treeSet = new TreeSet<>();
        treeSet.add("Banana");
        treeSet.add("Apple");
        treeSet.add("Cherry");
        treeSet.add("Date");

        System.out.println("TreeSet 内容: " + treeSet);

        // 使用迭代器遍历 HashSet
        System.out.println("使用迭代器遍历 HashSet:");
        Iterator<String> hashSetIterator = hashSet.iterator();
        while (hashSetIterator.hasNext()) {
            System.out.println(hashSetIterator.next());
        }

        // 使用增强 for 循环遍历 TreeSet
        System.out.println("使用增强 for 循环遍历 TreeSet:");
        for (String fruit : treeSet) {
            System.out.println(fruit);
        }

        // 检查元素是否存在并移除元素
        if (hashSet.contains("Banana")) {
            hashSet.remove("Banana");
        }
        System.out.println("移除 Banana 后的 HashSet: " + hashSet);

        // 清空集合
        treeSet.clear();
        System.out.println("清空后的 TreeSet 是否为空: " + treeSet.isEmpty());
    }
}

代码解释

1. HashSet 示例：

   • 创建一个 HashSet 实例并添加一些字符串元素。
   • 尝试添加重复的元素（如 “Apple”），但 HashSet 不允许重复，因此不会生效。
   • 打印 HashSet 的内容，可以看到元素是无序的。

2. TreeSet 示例：

   • 创建一个 TreeSet 实例并添加一些字符串元素。
   • TreeSet 会对元素进行自然排序，因此打印出的内容是有序的。

3. 遍历集合：

   • 使用迭代器遍历 HashSet，并打印每个元素。
   • 使用增强 for 循环遍历 TreeSet，并打印每个元素。

4. 检查并移除元素：

   • 检查 HashSet 是否包含某个元素（如 “Banana”），如果包含则移除它。
   • 打印移除元素后的 HashSet 内容。

5. 清空集合：

   • 清空 TreeSet，并检查它是否为空。
     通过这些示例代码和解释，初学者可以了解 Java Set 接口的基本使用方法和常用功能。

以下是一些关于Java Set接口的更多案例，这些案例涵盖了Set接口的不同使用场景和实现类。

案例一：使用HashSet存储不重复元素

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

public class HashSetExample {
    public static void main(String[] args) {
        // 创建一个HashSet实例
        Set<String> set = new HashSet<>();

        // 添加元素到HashSet中
        set.add("apple");
        set.add("banana");
        set.add("orange");
        set.add("apple"); // 尝试添加重复元素，不会生效

        // 打印HashSet的内容
        System.out.println("HashSet内容: " + set);

        // 检查HashSet是否包含某个元素
        boolean containsApple = set.contains("apple");
        System.out.println("HashSet是否包含apple: " + containsApple);

        // 移除某个元素
        set.remove("banana");
        System.out.println("移除banana后的HashSet内容: " + set);

        // 清空HashSet
        set.clear();
        System.out.println("清空后的HashSet是否为空: " + set.isEmpty());
    }
}

案例二：使用TreeSet进行排序

import java.util.Set;
import java.util.TreeSet;

public class TreeSetExample {
    public static void main(String[] args) {
        // 创建一个TreeSet实例
        Set<Integer> set = new TreeSet<>();

        // 添加元素到TreeSet中，元素会自动排序
        set.add(3);
        set.add(1);
        set.add(4);
        set.add(1); // 尝试添加重复元素，不会生效
        set.add(2);

        // 打印TreeSet的内容
        System.out.println("TreeSet内容: " + set);

        // TreeSet还支持自定义排序，通过Comparator接口实现
        // 以下是一个简单的示例，按元素的降序排序
        Set<Integer> customSortedSet = new TreeSet<>((o1, o2) -> o2 - o1);
        customSortedSet.add(3);
        customSortedSet.add(1);
        customSortedSet.add(4);
        customSortedSet.add(2);

        // 打印自定义排序后的TreeSet内容
        System.out.println("自定义排序后的TreeSet内容: " + customSortedSet);
    }
}

案例三：使用LinkedHashSet保持插入顺序

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetExample {
    public static void main(String[] args) {
        // 创建一个LinkedHashSet实例
        Set<String> set = new LinkedHashSet<>();
        // 添加元素到LinkedHashSet中，元素会保持插入顺序
        set.add("apple");
        set.add("banana");
        set.add("orange");
        set.add("grape");

        // 打印LinkedHashSet的内容
        System.out.println("LinkedHashSet内容: " + set);

        // 遍历LinkedHashSet并打印每个元素
        for (String fruit : set) {
            System.out.println(fruit);
        }
    }
}

案例四：使用Set接口进行集合运算

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

public class SetOperationsExample {
    public static void main(String[] args) {
        // 创建两个HashSet实例
        Set<String> set1 = new HashSet<>();
        set1.add("apple");
        set1.add("banana");
        set1.add("orange");

        Set<String> set2 = new HashSet<>();
        set2.add("banana");
        set2.add("grape");
        set2.add("orange");

        // 并集运算
        Set<String> unionSet = new HashSet<>(set1);
        unionSet.addAll(set2);
        System.out.println("并集: " + unionSet);

        // 交集运算
        Set<String> intersectionSet = new HashSet<>(set1);
        intersectionSet.retainAll(set2);
        System.out.println("交集: " + intersectionSet);

        // 差集运算（set1 - set2）
        Set<String> differenceSet = new HashSet<>(set1);
        differenceSet.removeAll(set2);
        System.out.println("差集: " + differenceSet);
    }
}

以上案例涵盖了Java Set接口的基本使用方法和常见操作，包括添加元素、检查元素是否存在、移除元素、清空集合、排序、保持插入顺序以及进行集合运算等。这些案例可以帮助初学者更好地理解和掌握Java Set接口的相关知识。