AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

J2EE基础(集合框架之Set)

2023-10-23 41
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： J2EE基础(集合框架之Set)

结构图：

1.Set集合的特点

       1.1特点一 无序 无修改方法

特点一：无序 没有修改方法

区别于上期的List集合,set集合并没有修改方法,详解如下：

因为它是无序的,没有下标.所以也就没有修改方法。

       2.2特点二 不可重复

特点二：不可重复

接下来我们再试着加一组一模一样的数据，如下：

可以明显地看到重复的数据并没有成功地添加进set集合。然后我们试着添加不同的数据，如下：

可以看到我们已经成功把没有重复的数据添加进set集合。所以这里就可以得出set集合的第二个特点是不可重复。 在这里需要提醒的是因为set集合本身是无序的，所以我们后添加的数据才会显示在中间。

2.Set集合的遍历

       2.1方法一 加强foreach遍历

方法一：foreach增强for循环

package com.Kissship.set;
import java.util.HashSet;
/**
 * set集合的遍历方式
 * 1.foreach增强for循环
 * @author jj
 *
 */
public class Demo2 {
  public static void main(String[] args) {
    HashSet hs = new HashSet<>();
    hs.add("我用双手成就你的梦想");//增加
    hs.add("时间不在于节省多少而在于你怎样使用");
    hs.add("断剑重铸之日骑士归来之时");
    for (Object obj : hs) {
      System.out.println(obj);
    }
  }
}

       2.2方法二 ITerator迭代器遍历

方法二：迭代器ITerator

package com.Kissship.set;
import java.util.HashSet;
import java.util.Iterator;
/**
 * set集合的遍历方式
 * 1.foreach增强for循环
 * 2.迭代器Iterator
 * @author jj
 *
 */
public class Demo2 {
  public static void main(String[] args) {
    HashSet hs = new HashSet<>();
    hs.add("我用双手成就你的梦想");//增加
    hs.add("时间不在于节省多少而在于你怎样使用");
    hs.add("断剑重铸之日骑士归来之时");
    for (Object obj : hs) {
      System.out.println(obj);
    }
    Iterator it = hs.iterator();
    while(it.hasNext()) {
      System.out.println(it.next());
    }
  }
}

3.Set集合的去重

在探讨之前首先会有两个疑问需要解答：

       1.直接存重复对象，能否直接存进去？

       2.contains能否判断当前集合是否含有某个对象？

       3.1 Set集合的去重原理

package com.Kissship.set;
import java.util.HashSet;
import java.util.Iterator;
/**
 * set集合的去重原理
 * 1.直接存重复对象，能否直接存进去？
 * 2.contains能否判断当前集合是否含有某个对象？
 * @author jj
 *
 */
public class Demo3 {
  public static void main(String[] args) {
    HashSet hs = new HashSet<>();
//    hs.add("我用双手成就你的梦想");//增加
//    hs.add("时间不在于节省多少而在于你怎样使用");
//    hs.add("断剑重铸之日骑士归来之时");
    hs.add(new User(1, "野荷"));
    hs.add(new User(2, "伽马"));
    hs.add(new User(3, "龙狙"));
    System.out.println(hs.contains(new User(2, "伽马")));
  }
}
class User{
  private int id;
  private String name;
  public User(int id, String name) {
    super();
    this.id = id;
    this.name = name;
  }
  public User() {
    super();
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "User [id=" + id + ", name=" + name + "]";
  }
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + id;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
  }
}

控制台输出结果为false，也就是没有判断成功。因为我们上面输入的是相同的对象。那么我们应该怎么解决这个问题呢？我们用equals方法试试，如下：

package com.Kissship.set;
import java.util.HashSet;
import java.util.Iterator;
/**
 * set集合的去重原理
 * 1.直接存重复对象，能否直接存进去？
 * 2.contains能否判断当前集合是否含有某个对象？
 * @author jj
 *
 */
public class Demo3 {
  public static void main(String[] args) {
    HashSet hs = new HashSet<>();
//    hs.add("我用双手成就你的梦想");//增加
//    hs.add("时间不在于节省多少而在于你怎样使用");
//    hs.add("断剑重铸之日骑士归来之时");
    hs.add(new User(1, "野荷"));
    hs.add(new User(2, "伽马"));
    hs.add(new User(3, "龙狙"));
    System.out.println(hs.contains(new User(2, "伽马")));
  }
}
class User{
  private int id;
  private String name;
  public User(int id, String name) {
    super();
    this.id = id;
    this.name = name;
  }
  public User() {
    super();
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "User [id=" + id + ", name=" + name + "]";
  }
//  @Override
//  public int hashCode() {
//    final int prime = 31;
//    int result = 1;
//    result = prime * result + id;
//    result = prime * result + ((name == null) ? 0 : name.hashCode());
//    return result;
//  }
  @Override
  public boolean equals(Object obj) {
    System.out.println("equals被调用了....");
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    User other = (User) obj;
    if (id != other.id)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }
}

我们会发现，用equals最后的结果还是false，那么这时候我们再去重写hashCode方法看看，如下:

@Override
  public int hashCode() {
    System.out.println("hashCode被调用了....");
    final int prime = 31;
    int result = 1;
    result = prime * result + id;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
  }
  @Override
  public boolean equals(Object obj) {
    System.out.println("equals被调用了....");
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    User other = (User) obj;
    if (id != other.id)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }

我们会发现输出为true.

那么这里结论就来了：Set集合去重主要是调用 add 方法时，使用了 hashCode 方法和 equals 方法。去除重复的数据需要调用自定义元素的 HashCode 方法和 equals 方法，所以我们需要在 User 类中重写 HashCode 方法和 equals 方法。

假设我们把hashCode方法中的返回值写死，即return = 1 的话，会出现什么情况？

@Override
  public int hashCode() {
    System.out.println("hashCode被调用了....");
//    final int prime = 31;
//    int result = 1;
//    result = prime * result + id;
//    result = prime * result + ((name == null) ? 0 : name.hashCode());
//    return result;
    return 1;
  }

控制台输出结果如下：

所以我们可以看出当我们hashCode值写死的时候，它的方法就不能起到过滤的作用了。先前存的三个对象返回值都为1都相等，它最终还是会走向equals.那么如果不等呢？我们一起来看看：

@Override
  public int hashCode() {
    System.out.println("hashCode被调用了....");
//    final int prime = 31;
//    int result = 1;
//    result = prime * result + id;
//    result = prime * result + ((name == null) ? 0 : name.hashCode());
//    return result;
    return (int) (Math.random()*9999999);
  }

控制台输出结果如下：

如果那三个对象存进去的时候，返回值不等的话，它最终不会走向equals.

所以去重，是先经过对象的hashCode值来进行筛选，如果hashCode值相同，它就会进到下一个方法equals再做对比，如果equals值相同，那么他就会被判定为重复对象。反之同理。

4.Set集合之排序

在示例之前我们需要造数据并且把它打印出来，如下：

package com.Kissship.set;
import java.util.HashSet;
/**
 * Set集合排序
 * @author jj
 */
public class Demo4 {
  public static void main(String[] args) {
    // 造数据
    HashSet hs = new HashSet<>();
    hs.add(new Person(1, 18, "野牛", 1400));
    hs.add(new Person(2, 19, "AK", 2700));
    hs.add(new Person(3, 20, "吹风机", 1250));
    hs.add(new Person(4, 21, "大狙", 4750));
    // 遍历 将数据打印出来
    for (Object object : hs) {
      System.out.println(object);
    }
  }
}
class Person {
  private int id;
  private int age;
  private String name;
  private int money;
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getMoney() {
    return money;
  }
  public void setMoney(int money) {
    this.money = money;
  }
  public Person(int id, int age, String name, int money) {
    super();
    this.id = id;
    this.age = age;
    this.name = name;
    this.money = money;
  }
  public Person() {
    super();
  }
  @Override
  public String toString() {
    return "Person [id=" + id + ", age=" + age + ", name=" + name + ", money=" + money + "]";
  }
}

控制台结果如下：

可以清楚的看到它的输出顺序是没有任何规则的1432(id)，在这里我们反复打印。发现它的输出，看它的id排序依旧是1，4，3，2。那么这里有人就要提问了，Set集合不是无序的吗？为什么一直是1432呢？这是因为在Set集合里，它是有它默认的排序规则的，虽然它是无序的。（它是没有按照我们这里插入的任何一个属性排序的）。

       4.1通过将Treeset进行排序

我们把原来的数据从Hashset里面放到Treeset里面去，然后我们把Treeset遍历一下：

package com.Kissship.set;
import java.util.HashSet;
import java.util.TreeSet;
/**
 * Set集合排序
 * 
 * @author jj
 *
 */
public class Demo4 {
  public static void main(String[] args) {
    // 造数据
    HashSet hs = new HashSet<>();
    hs.add(new Person(1, 18, "野牛", 1400));
    hs.add(new Person(2, 19, "AK", 2700));
    hs.add(new Person(3, 20, "吹风机", 1250));
    hs.add(new Person(4, 21, "大狙", 4750));
    //遍历 将数据打印出来
    for (Object object : hs) {//默认排序  相当于调用别人的接口传递回来的数据
      System.out.println(object);
    }
    //对数据进行加工
    TreeSet ts = new TreeSet<>();
    for (Object object : hs) {//把原来放在Hashset里的数据放到Treeset里
      ts.add(object);
    }
    for (Object object : ts) {//遍历Treeset
      System.out.println(object);//打印
    }
  }
}

在我们打印的时候我们会发现控制台报一个java.lang.Comparable的错误。这是因为我们先前被存放在Treeset集合里的对象没有实现Comparable接口。然后我们来实现一下Comparable接口即可。然后我们来试试按照id排序，代码如下：

@Override
  public int compareTo(Person o) {
    return this.id - o.id;
  }

解释：通过对象实现Comparable接口，重写compareTo方法根据id进行排序。

输出结果如下：

        4.2根据多重条件进行判断

详解如下（会有用到比较器排序接口因为是多重条件）： 

package com.Kissship.set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.TreeSet;
/**
 * Set集合排序
 * 
 * @author jj
 *
 */
public class Demo4 {
  public static void main(String[] args) {
    // 造数据
    HashSet hs = new HashSet<>();
    hs.add(new Person(1, 18, "野牛", 1400));
    hs.add(new Person(2, 19, "AK", 2700));
    hs.add(new Person(3, 20, "吹风机", 1250));
    hs.add(new Person(4, 21, "大狙", 4750));
    hs.add(new Person(5, 19, "连狙", 5000));
    hs.add(new Person(6, 18, "鸟狙", 1700));
    hs.add(new Person(7, 23, "沙鹰", 1700));
    // 遍历 将数据打印出来
    for (Object object : hs) {// 默认排序 相当于调用别人的接口传递回来的数据
      System.out.println(object);
    }
    // 对数据进行加工
    TreeSet ts = new TreeSet<>();
    for (Object object : hs) {// 把原来放在Hashset里的数据放到Treeset里
      ts.add(object);
    }
    System.out.println("=========id排序========");// 假设这是普通用户看到的排序数据
    for (Object object : ts) {// 遍历Treeset
      System.out.println(object);// 打印
    }
    System.out.println("========money排序=========");// VIP用户看到的数据
    TreeSet tsPlus = new TreeSet<>(new Comparator<Person>() {
      @Override
      public int compare(Person o1, Person o2) {
        return o2.getMoney() - o1.getMoney();// 我们把Money多的放前面
      }
    });
    for (Object object : hs) {
      tsPlus.add(object);
    }
    for (Object object : tsPlus) {
      System.out.println(object);
    }
    // 多重比较排序先对money进行一个升序，若money相同时，则进行年龄的升序排序
    System.out.println("========先按￥排序再按年龄排序=========");
    TreeSet tsPlusMax = new TreeSet<>(new Comparator<Person>() {
      @Override
      public int compare(Person o1, Person o2) {// 先比较双方money
        int num = o2.getMoney() - o1.getMoney();
        if (num == 0) {// 如果先前两人的money相等，再比较年龄
          return o1.getAge() - o2.getAge();
        }
        return num;
      }
    });
    for (Object object : hs) {
      tsPlusMax.add(object);
    }
    for (Object object : tsPlusMax) {
      System.out.println(object);
    }
  }
}
class Person implements Comparable<Person> {
  private int id;
  private int age;
  private String name;
  private int money;
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getMoney() {
    return money;
  }
  public void setMoney(int money) {
    this.money = money;
  }
  public Person(int id, int age, String name, int money) {
    super();
    this.id = id;
    this.age = age;
    this.name = name;
    this.money = money;
  }
  public Person() {
    super();
  }
  @Override
  public String toString() {
    return "Person [id=" + id + ", age=" + age + ", name=" + name + ", money=" + money + "]";
  }
  @Override
  public int compareTo(Person o) {
    return this.id - o.id;
  }
}
java.lang.comparable：自然排序接口 jaba.util.comparator：比较器排序接口

控制台输出结果：

总结：Set集合去重主要是调用 add 方法时，使用了 hashCode 方法和 equals 方法：如果在 Set集合 中找不到与该元素 hashCode 值相同的元素，则说明该元素是新元素，会被添加到 Set 集合中；如果两个元素的 hashCode 值相同，并且使用 equals 方法比较后，返回值为 true，那么就说明两个元素相同，新元素不会被添加到 Set 集合中；如果 hashCode 值相同，但是 equals 方法比较后，返回值为 false ，则两个元素不相同，新元素会被添加到 Set 集合中。

最后J2EE基础(集合框架之Set)就到这里，祝大家在敲代码的路上一路通畅!

感谢大家的观看 !

文章标签：
开发框架
关键词：
集合Set
集合框架Set
框架Set
j2ee Set
Kissship
目录
相关文章
听白
|
3月前
|
存储 NoSQL 关系型数据库
Redis 集合(Set)
10月更文挑战第17天
听白
50 5
众所周知
|
3月前
|
算法 Java 数据处理
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。HashSet基于哈希表实现，提供高效的元素操作；TreeSet则通过红黑树实现元素的自然排序，适合需要有序访问的场景。本文通过示例代码详细介绍了两者的特性和应用场景。
众所周知
57 6
龙大吉
|
3月前
|
存储 Java 数据处理
Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位
【10月更文挑战第16天】Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位。本文通过快速去重和高效查找两个案例，展示了Set如何简化数据处理流程，提升代码效率。使用HashSet可轻松实现数据去重，而contains方法则提供了快速查找的功能，彰显了Set在处理大量数据时的优势。
龙大吉
40 2
爱吃香蕉的猫
|
2月前
set集合
HashSet(无序，唯一): 基于 HashMap 实现的，底层采用 HashMap 来保存元素。 LinkedHashSet: LinkedHashSet 是 HashSet 的子类，并且其内部是通过 LinkedHashMap 来实现的。 TreeSet(有序，唯一): 红黑树(自平衡的排序二叉树)。
爱吃香蕉的猫
27 1
大树营养快线
|
2月前
|
存储 Java
判断一个元素是否在 Java 中的 Set 集合中
【10月更文挑战第30天】使用`contains()`方法可以方便快捷地判断一个元素是否在Java中的`Set`集合中，但对于自定义对象，需要注意重写`equals()`方法以确保正确的判断结果，同时根据具体的性能需求选择合适的`Set`实现类。
大树营养快线
50 7
大树营养快线
|
2月前
|
存储 Java 开发者
在 Java 中，如何遍历一个 Set 集合？
【10月更文挑战第30天】开发者可以根据具体的需求和代码风格选择合适的遍历方式。增强for循环简洁直观，适用于大多数简单的遍历场景；迭代器则更加灵活，可在遍历过程中进行更多复杂的操作；而Lambda表达式和`forEach`方法则提供了一种更简洁的函数式编程风格的遍历方式。
大树营养快线
61 1
大树营养快线
|
2月前
|
Java 开发者
从 Java 中的 Set 集合中删除元素
【10月更文挑战第30天】
大树营养快线
97 1
东方睿赢
|
3月前
|
存储 Java 数据处理
Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。
【10月更文挑战第16天】Java Set：无序之美，不重复之魅！Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。通过 hashCode() 和 equals() 方法实现唯一性，适用于需要唯一性约束的数据处理。示例代码展示了如何使用 HashSet 添加和遍历元素，体现了 Set 的高效性和简洁性。
东方睿赢
52 4
众所周知
|
3月前
|
Java 开发者
在Java集合世界中，Set以其独特的特性脱颖而出，专门应对重复元素
在Java集合世界中，Set以其独特的特性脱颖而出，专门应对重复元素。通过哈希表和红黑树两种模式，Set能够高效地识别并拒绝重复元素的入侵，确保集合的纯净。无论是HashSet还是TreeSet，都能在不同的场景下发挥出色的表现，成为开发者手中的利器。
众所周知
31 2
刘大猫.
|
1月前
|
算法
你对Collection中Set、List、Map理解？
你对Collection中Set、List、Map理解？
刘大猫.
61 18
你对Collection中Set、List、Map理解？