Set集合

其他集合类

父类Collection类

集合类的遍历方式

具体信息请查看 API 帮助文档

Lambda表达式

实现类：
HashSet （无序，不重复，无索引）
TreeSet （可排序，不重复，无索引）
LinkedHashSet （有序，不重复，无索引）

1. 概述

Set（集合）是一种不允许重复元素且无序的数据结构。它是许多编程语言中的内置数据类型，用于存储一组唯一的元素。与列表或数组不同，集合中的元素没有特定的顺序，并且不能通过索引访问。

Set有以下主要特点：

1. 唯一性：集合中的元素是唯一的，重复的元素将自动被忽略。

2. 无序性：集合中的元素没有特定的顺序，无法通过索引进行访问。

3. 可变性：可以向集合中添加或移除元素。

4. 数学中的集合运算：可以执行交集、并集、差集等数学中的集合运算。

集合适用于需要存储一组唯一的元素并且不关心顺序的场景。常见的应用包括去重、成员检查和集合运算等操作。

2. 方法

 Set集合是Collection集合的子类，Collection集合的方法Set集合都能使用

Collection类

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

【注意点】：

• boolean add(E e) ：添加元素

  • 如果要往List系列的集合中添加元素，那么该方法永远返回true，因为List系列的集合石允许元素重复的；

  • 如果要往Set系列的集合中添加元素，如果要添加的元素在集合中不存在，则添加成功返回true，如果要添加的元素在集合中存在，则添加失败返回false。因为Set系列的集合不允许重复。

• boolean remove(Object o) ：从集合中移除指定的元素

  • 因为Collection里面定义的是共性的方法，所以不能通过索引删除元素，而是通过元素的对象进行删除

  • 方法会有一个布尔类型的返回值，删除成功返回true，删除失败返回false

• boolean contains(Object o) ： 判断集合中是否存在指定的元素

  • 底层是依赖equals方法进行判断是否存在，因此如果想要用contains方法判断的是自定义对象，则需在Javabean类中重写equals方法

3. 遍历方式

【注意】Set集合没有索引，因此只能用迭代器遍历、增强 for ，Lambda表达式遍历。

与共有的 集合遍历方式 一样

3.1 迭代器遍历

1. 方法

Iterator中的常用方法 :

方法	描述
Iterator iterator()	获取一个迭代器对象，用于遍历集合中的元素。
boolean hasNext()	判断当前位置是否有元素可以被取出。如果集合还有下一个元素，则返回 true；否则返回 false。
E next()	获取当前位置的元素，并将迭代器对象移向下一个位置。
void remove()	删除迭代器对象当前位置的元素。

例如：

       Iterator<String> it = coll.iterator();
       while (it.hasNext()) {
           //next方法的作用：获取元素并移动指针
           String str = it.next();
           System.out.print(str );
       }

细节：

• 如果迭代器已经指向空元素了，依旧强行调用next方法，则会报错NoSuchElementException；

• 迭代器遍历完毕，指针不会复位，依旧指向集合最后，如果想要再次将集合遍历一遍，只能再次创建一个新的迭代器对象，用新的迭代器对象再次遍历；

• 循环中只能用一次next方法；

• 迭代器遍历时，不能用集合的方法进行增加或者删除（例如：集合提供的remove方法）。
  如果非要删除，可以用迭代器提供的remove方法进行删除。

2. 代码示例

package text.text02;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
迭代器遍历：
    Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

细节：
    1.如果迭代器已经指向空元素了，依旧强行调用next方法，则会报错NoSuchElementException；
    2.迭代器遍历完毕，指针不会复位，依旧指向集合最后，如果想要再次将集合遍历一遍，只能再次创建一个新的迭代器对象，用新的迭代器对象再次遍历；
    3.循环中只能用一次next方法；
    4.迭代器遍历时，不能用集合的方法进行增加或者删除（例如：集合提供的remove方法）。
      如果非要删除，可以用迭代器提供的remove方法进行删除。
 */
public class text24A {
    public static void main(String[] args) {
        //创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");
        coll.add("eee");

        //调用iterator()方法创建迭代器对象(返回值为迭代器对象)
        Iterator<String> it = coll.iterator();


        //利用循环遍历集合，获取集合中的每一个元素
        while (it.hasNext()) {
            //next方法的作用：获取元素并移动指针
            String str = it.next();
            System.out.print(str + "  ");      //aaa  bbb  ccc  ddd  eee
        }
        System.out.println();


        //1.如果迭代器已经指向空元素了，依旧强行调用next方法，则会报错NoSuchElementException；
        //System.out.println(it.next());       //Exception in thread "main" java.util.NoSuchElementException
        //at java.util.ArrayList$Itr.next(ArrayList.java:864)
        //at text.text02.text24A.main(text24A.java:45)


        //2.迭代器遍历完毕，指针不会复位，依旧指向集合最后
        System.out.println(it.hasNext());      //false，说明该位置没有元素，即指针没有复位
        //如果想要再次将集合遍历一遍，只能再次创建一个新的迭代器对象，用新的迭代器对象再次遍历；
        Iterator<String> iterator = coll.iterator();    //新的迭代器对象
        while (iterator.hasNext()) {
            String str = iterator.next();
            System.out.print(str + "  ");       //aaa  bbb  ccc  ddd  eee
        }
        System.out.println();


        //3.循环中只能用一次next方法；
        /*Iterator iterator1 = coll.iterator();
        while (iterator1.hasNext()) {
            String str1 = iterator1.next();
            String str2 = iterator1.next();
            System.out.println(str1);           //aaa   ccc        Exception in thread "main" java.util.NoSuchElementException at java.util.ArrayList$Itr.next(ArrayList.java:864) at text.text02.text24A.main(text24A.java:65)
            System.out.println(str2);           //bbb   ddd
        }
         */


        //4.迭代器遍历时，不能用集合的方法进行增加或者删除。
        //出现的问题
        /*Iterator iterator2 = coll.iterator();
        while (iterator2.hasNext()) {
            String str = iterator2.next();
            if (str.equals("aaa")) {
                coll.remove(str);
            }
        }
        System.out.println(coll);     //Exception in thread "main" java.util.ConcurrentModificationException(并发修改异常) at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911) at java.util.ArrayList$Itr.next(ArrayList.java:861) at text.text02.text24A.main(text24A.java:75)   */

        //解决方法
        Iterator<String> iterator3 = coll.iterator();
        while (iterator3.hasNext()) {
            String str = iterator3.next();
            if (str.equals("aaa")) {
                iterator3.remove();
            }
        }
        System.out.println(coll);        //[bbb, ccc, ddd, eee]
    }
}

3. 输出结果

• 利用循环遍历集合，获取集合中的每一个元素

  

• 如果迭代器已经指向空元素了，依旧强行调用next方法，则会报错NoSuchElementException；
  

• 迭代器遍历完毕，指针不会复位，依旧指向集合最后
  

• 如果想要再次将集合遍历一遍，只能再次创建一个新的迭代器对象，用新的迭代器对象再次遍历；
  

• 循环中只能用一次next方法；
  

• 迭代器遍历时，不能用集合的方法进行增加或者删除

  • 出现的问题
    

  • 解决方法
    

3.2 增强for遍历

1. 方法

格式：

for(数据类类型 变量名 : 集合/数组){

    }

细节：

1. 变量名其实是一个第三方变量，在循环的过程中一次表示集合中的每一个数据

2. 修改增强for中的变量值，不会改变集合中的原有数据

2. 代码示例

package text.text02;

import java.util.ArrayList;
import java.util.Collection;

/*
增强for循环：
- 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
- 实现Iterable接口的类才可以使用迭代器和增强for
- 简化数组和Collection集合的遍历

格式：for(数据类类型 变量名 : 集合/数组){

    }

细节：
    1，变量名其实是一个第三方变量，在循环的过程中一次表示集合中的每一个数据
    2. 修改增强for中的变量值，不会改变集合中的原有数据
 */
public class text25A {
    public static void main(String[] args) {
        //创建集合并添加数据
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //利用增强for循环遍历集合
        //String为数据类型
        //s：为变量名
        //coll：为集合的名字
        for (String s : coll) {
            System.out.print(s + "\t");   //aaa	bbb	ccc	ddd
        }
        System.out.println();
        System.out.println(coll);       //[aaa, bbb, ccc, ddd]
    }
}

3. 输出结果

• 利用增强for循环遍历集合

3.3 Lambda表达式遍历

Lambda表达式

1. 方法

Lambda表达式遍历：

     default void forEach(Consumer<? super T> action)

2. 代码示例

package text.text02;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

/*
Lambda表达式遍历：
     default void forEach(Consumer action):
 */
public class text26A {
    public static void main(String[] args) {
        //创建集合并添加元素
        Collection<String> coll = new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //先利用匿名内部类遍历
        coll.forEach(new Consumer<String>() {
            //底层原理：其实也会自己遍历集合，一次得到每一个元素，把得到的每一个元素，传递给下面的accep方法
            //s依次表示集合中的每一个元素
            @Override
            public void accept(String s) {
                System.out.print(s + "\t");       //aaa	bbb	ccc	ddd
            }
        });

        System.out.println();

        //利用Lambda表达式遍历
        coll.forEach(s -> System.out.print(s + "\t"));      //aaa	bbb	ccc	ddd
    }
}

3. 输出结果

• 先利用匿名内部类遍历
  

• 利用Lambda表达式遍历
  

4. 注意事项

1. 唯一性：Set集合中的元素是唯一的，不会存在重复的元素。当尝试向Set中添加重复的元素时，Set会自动忽略该元素。

2. 无序性：Set集合中的元素没有确定的顺序。这意味着无法通过索引来访问Set中的元素，也无法保证元素的存储顺序。如果需要有序遍历Set中的元素，可以使用其他数据结构进行排序或转换。

3. 效率：Set集合通常以哈希表（Hash table）的形式实现，这使得Set在查找、插入和删除操作上具有很高的效率。因此，当需要高效地检查成员是否存在或进行去重操作时，Set是一个很好的选择。

4. 可变性：Set集合是可变的，可以通过添加或删除元素来修改集合。当修改Set集合时，会影响原始集合，因此请注意原地修改和复制操作的区别。

5. 元素类型：Set集合中的元素类型通常是一致的，因为Set需要使用哈希函数对元素进行唯一性的判断。对于某些编程语言，例如Java，Set中的元素类型需要实现equals()和hashCode()方法来进行比较和哈希计算。