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

J2EE集合框架（set集合）

2023-11-10 43
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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
君临沂
目录
相关文章
不摸鱼的程序员
|
2天前
|
存储 Java Serverless
Java集合利器 Map & Set
Java集合利器 Map & Set
不摸鱼的程序员
5 0
niceffking
|
7天前
|
机器学习/深度学习 存储 NoSQL
Redis -- set集合
Redis -- set集合
niceffking
14 0
长梦
|
15天前
|
存储 安全 Java
Java一分钟之-集合框架进阶：Set接口与HashSet
【5月更文挑战第10天】本文介绍了Java集合框架中的`Set`接口和`HashSet`类。`Set`接口继承自`Collection`，特征是不允许重复元素，顺序不确定。`HashSet`是`Set`的实现，基于哈希表，提供快速添加、删除和查找操作，但无序且非线程安全。文章讨论了`HashSet`的特性、常见问题（如元素比较规则、非唯一性和线程安全性）以及如何避免这些问题，并提供了代码示例展示基本操作和自定义对象的使用。理解这些概念和注意事项能提升代码效率和可维护性。
长梦
17 0
还在路上的秃头
|
15天前
|
存储 算法 Java
【JAVA】Java 中 Set集合常用方法
【JAVA】Java 中 Set集合常用方法
还在路上的秃头
21 1
JavaBuild
|
15天前
|
存储 安全 Java
Java集合篇之set，面试官：请说一说HashSet、LinkedHashSet、TreeSet的区别？
Java集合篇之set，面试官：请说一说HashSet、LinkedHashSet、TreeSet的区别？
JavaBuild
15 0
Safenetworkaccess
|
15天前
|
程序员 索引 Python
06-python数据容器-set（集合）入门基础操作
06-python数据容器-set（集合）入门基础操作
Safenetworkaccess
29 0
是阿超
|
15天前
|
存储 安全 Java
Java集合详解(List、Map、Set)
Java集合详解(List、Map、Set)
是阿超
36 4
泡沫o0
|
15天前
|
存储 Shell Linux
【Shell 命令集合 系统设置 内置命令】⭐⭐⭐Linux 设置或修改shell环境变量set命令 使用指南
【Shell 命令集合 系统设置 内置命令】⭐⭐⭐Linux 设置或修改shell环境变量set命令 使用指南
泡沫o0
47 0
仲君Johnny
|
15天前
|
存储 安全 Java
Python教程第3章 | 集合（List列表、Tuple元组、Dict字典、Set）
Python 列表、无序列表、字典、元组增删改查基本用法和注意事项
仲君Johnny
53 1
远近高低各不同
|
15天前
ES6之Set集合(通俗易懂，含实践)
ES6之Set集合(通俗易懂，含实践)
远近高低各不同
19 0