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

J2EE集合框架（set集合）

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

1.set是什么？

set集合是一个无序不重复元素的集

2.set特点

特点：输出与添加顺序不同，只有增删查，无下标，无法修改， 足以证明无序 并且不可重复。

以下代码验证：

public static void main(String[] args) {
//      实例化
        HashSet hs=new HashSet<>();
        hs.add("jun");
        hs.add("lin");
        hs.add("yi");
        hs.add("马牛逼");
        boolean remove = hs.remove("马牛逼");
        System.out.println(remove);//true
        System.out.println(hs);
//      不可重复
        hs.add("马牛逼");
        System.out.println(hs);
    }
    //输出结果：只有一个马牛逼
            true
            [lin,yi,jun]
            [lin,yi,jun,马牛逼]

3.set集合的遍历

只有两种:1.foreach 2.iterator(迭代器)

public static void main(String[] args) {
            HashSet hs=new HashSet<>();
            hs.add("jun");
            hs.add("lin");
            hs.add("yi");
            //foreach
            for (Object object : hs) {
                System.out.println(object);
            }
            //迭代器
            Iterator it=hs.iterator();
            while(it.hasNext()) {
                System.out.println(it.next());
            }
        }
        //输出结果：
                lin     lin
                yi       yi
                jun      jun

4.set集合的去重原理

去重：它是先经过对象hashCode的值，进行筛选。如果hashCode的值相同，它就会进行下一个方法equals 在做对比，equals也相同，它就会判定为同一个对象

如果包含返回true，如果不包含返回false。

public class demo3 {
        public static void main(String[] args) {
            HashSet hs=new HashSet<>();
            hs.add("jun");
            hs.add("lin");
            hs.add("yi");
            System.out.println(hs.contains("lin"));//true
​
        }
}

4.1默认生成的，调用一次equals

public class demo3 {
        public static void main(String[] args) {
            HashSet hs=new HashSet<>();
            hs.add("jun");
            hs.add("lin");
            hs.add("yi");
            //System.out.println(hs.contains("lin"));//true
            //对象增加
            hs.add(new DX(1,"老六"));
            hs.add(new DX(2,"靓仔"));
            hs.add(new DX(3,"土狗"));
            System.out.println(hs.contains(new DX(3,"土狗")));
        }
}
//对象
class DX{
    private int id;
    private String name;
    public DX() {
        // TODO Auto-generated constructor stub
    }
​
    public DX(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
​
    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 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;
        DX other = (DX) 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;
    }
​
    @Override
    public String toString() {
        return "DX [id=" + id + ", name=" + name + "]";
    }
}

结果：

4.2写死了多次调用equals

public class demo3 {
        public static void main(String[] args) {
            HashSet hs=new HashSet<>();
            hs.add("jun");
            hs.add("lin");
            hs.add("yi");
            //System.out.println(hs.contains("lin"));//true
            //对象增加
            hs.add(new DX(1,"老六"));
            hs.add(new DX(2,"靓仔"));
            hs.add(new DX(3,"土狗"));
            System.out.println(hs.contains(new DX(3,"土狗")));
        }
}
//对象
class DX{
    private int id;
    private String name;
    public DX() {
        // TODO Auto-generated constructor stub
    }
​
    public DX(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
​
    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 int hashCode() {
        System.out.println("hashCode被调用了。。。");
        return 1;
    }
​
    @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;
        DX other = (DX) 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;
    }
​
    @Override
    public String toString() {
        return "DX [id=" + id + ", name=" + name + "]";
    }
}

结果为：

4.3几乎不相同所以几乎不会调用equals

public class demo3 {
        public static void main(String[] args) {
            HashSet hs=new HashSet<>();
            hs.add("jun");
            hs.add("lin");
            hs.add("yi");
            //System.out.println(hs.contains("lin"));//true
            //对象增加
            hs.add(new DX(1,"老六"));
            hs.add(new DX(2,"靓仔"));
            hs.add(new DX(3,"土狗"));
            System.out.println(hs.contains(new DX(3,"土狗")));
        }
}
//对象
class DX{
    private int id;
    private String name;
    public DX() {
        // TODO Auto-generated constructor stub
    }
​
    public DX(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
​
    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 int hashCode() {
        System.out.println("hashCode被调用了。。。");
        return (int) (Math.random()*1000000);
    }
​
    @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;
        DX other = (DX) 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;
    }
​
    @Override
    public String toString() {
        return "DX [id=" + id + ", name=" + name + "]";
    }
}

结果为：

5.set集合之排序

5.1TreeSet

两种排序为（自然排序: java.lang.comparable，比较器排序 :java.util.comparator）

特点：

自然排序:有默认排序规则

比较器排序 :同一组数据展示不同的形式 多样的处理

5.2 自然排序 Comparable的使用

public class demo4 {
    public static void main(String[] args) {
        HashSet hs=new HashSet<>();
        hs.add(new Person(1,24,"老六",100000));
        hs.add(new Person(2,18,"靓仔",120000));
        hs.add(new Person(3,28,"土狗",10000));
        hs.add(new Person(4,48,"马牛逼",100000));
        //默认排序
        for (Object object : hs) {
            System.out.println(object);
        }
        //对数据进行加工
        TreeSet ts=new TreeSet<>();
        for (Object object : hs) {
            ts.add(object);
        }
        System.out.println("----------------------------------------------");
        //java.lang.Comparable
        for (Object object : ts) {
            System.out.println(object);
        }
    }
​
}
class Person implements Comparable<Person>{
    private int id;
    private int age;
    private String name;
    private double money;
    public Person() {
        // TODO Auto-generated constructor stub
    }
    public Person(int id, int age, String name, double money) {
        super();
        this.id = id;
        this.age = age;
        this.name = name;
        this.money = 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 double getMoney() {
        return money;
    }
​
    public void setMoney(double money) {
        this.money = money;
    }
​
​
    @Override
    public String toString() {
        return "Person [id=" + id + ", age=" + age + ", name=" + name + ", money=" + money + "]";
    }
​
​
    @Override
    public int compareTo(Person o) {
//      this 被比较对象 
        return this.id - o.id;//(升序)
//      return o.id - this.id;(降序)
    }
}

结果为：横线下是升序

5.3 比较器排序Comparator 的使用

public static void main(String[] args) {
        HashSet hs=new HashSet<>();
        hs.add(new Person(1,24,"老六",100000));
        hs.add(new Person(2,18,"靓仔",120000));
        hs.add(new Person(3,28,"土狗",10000));
        hs.add(new Person(4,48,"马牛逼",140000));
        TreeSet ts2=new TreeSet<>(new Comparator<Person>() {
​
            @Override
            public int compare(Person o1, Person o2) {
                return (int) (o2.getMoney() - o1.getMoney());
            }
        });
        for (Object object : hs) {
            ts2.add(object);
        }
        for (Object object : ts2) {
            System.out.println(object);
        }
  }
  class Person implements Comparable<Person>{
    private int id;
    private int age;
    private String name;
    private double money;
    public Person() {
        // TODO Auto-generated constructor stub
    }
    public Person(int id, int age, String name, double money) {
        super();
        this.id = id;
        this.age = age;
        this.name = name;
        this.money = 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 double getMoney() {
        return money;
    }
​
    public void setMoney(double money) {
        this.money = money;
    }
​
​
    @Override
    public String toString() {
        return "Person [id=" + id + ", age=" + age + ", name=" + name + ", money=" + money + "]";
    }
​
​
    @Override
    public int compareTo(Person o) {
        return o;
    }
}

结构为：

结论：如需求比较 ，--点get属性。

文章标签：
开发框架
关键词：
集合Set
集合框架Set
框架Set
j2ee Set
君临沂
目录
相关文章
众所周知
|
5月前
|
算法 Java 数据处理
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。HashSet基于哈希表实现，提供高效的元素操作；TreeSet则通过红黑树实现元素的自然排序，适合需要有序访问的场景。本文通过示例代码详细介绍了两者的特性和应用场景。
众所周知
86 6
听白
|
5月前
|
存储 NoSQL 关系型数据库
Redis 集合(Set)
10月更文挑战第17天
听白
68 5
龙大吉
|
5月前
|
存储 Java 数据处理
Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位
【10月更文挑战第16天】Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位。本文通过快速去重和高效查找两个案例，展示了Set如何简化数据处理流程，提升代码效率。使用HashSet可轻松实现数据去重，而contains方法则提供了快速查找的功能，彰显了Set在处理大量数据时的优势。
龙大吉
65 2
爱吃香蕉的猫
|
4月前
set集合
HashSet(无序，唯一): 基于 HashMap 实现的，底层采用 HashMap 来保存元素。 LinkedHashSet: LinkedHashSet 是 HashSet 的子类，并且其内部是通过 LinkedHashMap 来实现的。 TreeSet(有序，唯一): 红黑树(自平衡的排序二叉树)。
爱吃香蕉的猫
41 1
大树营养快线
|
4月前
|
存储 Java 开发者
在 Java 中，如何遍历一个 Set 集合？
【10月更文挑战第30天】开发者可以根据具体的需求和代码风格选择合适的遍历方式。增强for循环简洁直观，适用于大多数简单的遍历场景；迭代器则更加灵活，可在遍历过程中进行更多复杂的操作；而Lambda表达式和`forEach`方法则提供了一种更简洁的函数式编程风格的遍历方式。
大树营养快线
3848 7
大树营养快线
|
4月前
|
存储 Java
判断一个元素是否在 Java 中的 Set 集合中
【10月更文挑战第30天】使用`contains()`方法可以方便快捷地判断一个元素是否在Java中的`Set`集合中，但对于自定义对象，需要注意重写`equals()`方法以确保正确的判断结果，同时根据具体的性能需求选择合适的`Set`实现类。
大树营养快线
150 7
大树营养快线
|
4月前
|
Java 开发者
从 Java 中的 Set 集合中删除元素
【10月更文挑战第30天】
大树营养快线
231 1
东方睿赢
|
5月前
|
存储 Java 数据处理
Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。
【10月更文挑战第16天】Java Set：无序之美，不重复之魅！Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。通过 hashCode() 和 equals() 方法实现唯一性，适用于需要唯一性约束的数据处理。示例代码展示了如何使用 HashSet 添加和遍历元素，体现了 Set 的高效性和简洁性。
东方睿赢
92 4
众所周知
|
5月前
|
Java 开发者
在Java集合世界中，Set以其独特的特性脱颖而出，专门应对重复元素
在Java集合世界中，Set以其独特的特性脱颖而出，专门应对重复元素。通过哈希表和红黑树两种模式，Set能够高效地识别并拒绝重复元素的入侵，确保集合的纯净。无论是HashSet还是TreeSet，都能在不同的场景下发挥出色的表现，成为开发者手中的利器。
众所周知
51 2
ephemerals__
|
7天前
|
编译器 C++ 容器
【c++丨STL】基于红黑树模拟实现set和map（附源码）
本文基于红黑树的实现，模拟了STL中的`set`和`map`容器。通过封装同一棵红黑树并进行适配修改，实现了两种容器的功能。主要步骤包括：1) 修改红黑树节点结构以支持不同数据类型；2) 使用仿函数适配键值比较逻辑；3) 实现双向迭代器支持遍历操作；4) 封装`insert`、`find`等接口，并为`map`实现`operator[]`。最终，通过测试代码验证了功能的正确性。此实现减少了代码冗余，展示了模板与仿函数的强大灵活性。
ephemerals__
29 2

热门文章

最新文章

  • 1
    别再用双层遍历循环来做新旧数组对比，寻找新增元素了！使用array.includes和Set来提升代码可读性
  • 2
    【c++丨STL】set/multiset的使用
  • 3
    【c++丨STL】基于红黑树模拟实现set和map（附源码）
  • 4
    【YashanDB知识库】YAS-02507 base incremental backup set does not exist
  • 5
    【YashanDB知识库】update (子查询) set ORG_ID_STAN -ID 改写
  • 6
    成功解决A value is trying to be set on a copy of a slice from a DataFrame. Try using .loc[row_indexer,co
  • 7
    Error: Failed to set Event Logging
  • 8
    Parameter \&#39; \&#39;: No size set for variable length data type: String
  • 9
    【Flutter】Dart 面向对象 ( get 方法 | set 方法 | 静态方法
  • 10
    cf 168 k-Multiple Free Set bin_search
  • 1
    Redis深度解析：核心数据类型之hash、list、set
    83
  • 2
    mysql中find_in_set()函数用法详解及增强函数
    1096
  • 3
    【C++】开散列实现unordered_map与unordered_set的封装
    80
  • 4
    【C++】map和set封装
    58
  • 5
    【C++】map和set深度讲解（下）
    84
  • 6
    【C++】map和set深度讲解（上）
    68
  • 7
    【Python】已解决：SettingWithCopyWarning: A value is trying to be set on a copy of a slice from a DataFram
    1156
  • 8
    JS【详解】Set 集合 （含 Set 集合和 Array 数组的区别，Set 的 API，Set 与 Array 的性能对比，Set 的应用场景）
    180
  • 9
    【C++高阶】探索STL的瑰宝 map与set：高效数据结构的奥秘与技巧
    112
  • 10
    Redis16-RedisTemplate快速入门，max -idle，min-idle，max-wait，用set的方法，opsForValue().set的方法
    88

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    阿里云oss简介和如何对接使用