AI 助理
备案控制台
开发者社区 云计算 文章 正文

set集合

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

1，set集合的特点：

1.1，set集合添加的数据不可重复

public static void main(String[] args) {
    Set s = new HashSet();
    s.add("b");
    s.add("a");
    s.add("c");
    s.add("b");
    System.out.println(s);
}

通过上一行代码输出的结果为：

由此可以说明set集合里的数据不可重复。

但是若存放的数据为对象时:

public static void main(String [] args) {
  HashSet<Object> set =new HashSet<Object>();
  set.add(new person("zs",12));
  set.add(new person("ww",12));
  set.add(new person("ls",12));
  System.out.println(set.size());
  set.add(new person("ww",12));
  System.out.println(set.size());
}

运行此段代码的结果如图：

由此可以说明但我们在set集合添加属性值一样的对象时，因为地址同所以可以存放进去，那我们该怎么解决？我们尝试用list集合去重原理试一下。

 

package com.xzs.set;
import java.util.HashSet;
import java.util.Set;
public class demo1 {
public static void main(String [] args) {
  HashSet<Object> set =new HashSet<Object>();
  set.add(new person("zs",12));
  set.add(new person("ww",12));
  set.add(new person("ls",12));
  System.out.println(set.size());
  set.add(new person("ww",12));
  System.out.println(set.size());
}
}
class person{
  private String name;
  private int age;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  public person() {
    super();
  }
  @Override
  public String toString() {
    return "person [name=" + name + ", age=" + age + "]";
  }
  @Override
//  public int hashCode() {
//    final int prime = 31;
//    int result = 1;
//    result = prime * result + age;
//    result = prime * result + ((name == null) ? 0 : name.hashCode());
//    return result;
//  }
//  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    person other = (person) obj;
    if (age != other.age)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }
}

以上代码运行结果是

同样集合的长度还是3和4由此说明set集合与list集合判定的底层逻辑就不同

package com.xzs.set;
import java.util.HashSet;
import java.util.Set;
public class demo1 {
public static void main(String [] args) {
  HashSet<Object> set =new HashSet<Object>();
  set.add(new person("zs",12));
  set.add(new person("ww",12));
  set.add(new person("ls",12));
  System.out.println(set.size());
  set.add(new person("ww",12));
  System.out.println(set.size());
}
}
class person{
  private String name;
  private int age;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  public person() {
    super();
  }
  @Override
  public String toString() {
    return "person [name=" + name + ", age=" + age + "]";
  }
  @Override
  public int hashCode() {
    System.out.println("hashcode被调用了");
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    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;
    person other = (person) obj;
    if (age != other.age)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }
}

同样是上一行代码，这时候运行的结果为

 

由此可以说明，set集合在判定数据是先通过hascode，并且在上类代码中当我们的hashcode被注释的时候equlas，也不会被调用，所以set集合的判定是否为重复数组的原理是：“先来通过hashcode判定，才会进入equals判定”

1.2  hashset无序   Treeset有序

要想判定set集合是否为有序的我们可以遍历他的元素即可

1.2.1set集合的遍历方法

1.为迭代器也就是图中的Iterator

2.增强for也就是foreach

public static void main(String[] args) {
        Set s = new HashSet();
        s.add("a");
        s.add("c");
        s.add("b");
        for (Object o : s) {
            System.out.println(o);
        }
        System.out.println("==============================");
        Iterator it = s.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }

结果为：

证明 string 类型是可以自动排序的

1.2.2Treeset自定义对象无法排序，hashSet因为是无序所以会无规则遍历

package com.xzs.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class demo1 {
public static void main(String [] args) {
  TreeSet<Object> set =new TreeSet<Object>();
  set.add(new person("zs",3,12));
  set.add(new person("ww",6,92));
  set.add(new person("ls",1,17));
  System.out.println(set.size());
  for (Object object : set) {
    System.out.println(object);
  }
}
}
class person{
  private String name;
  private int level;
  private int age;
  public int getLevel() {
    return level;
  }
  public void setLevel(int level) {
    this.level = level;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  @Override
  public String toString() {
    return "person [name=" + name + ", level=" + level + ", age=" + age + "]";
  }
  public person(String name, int level, int age) {
    super();
    this.name = name;
    this.level = level;
    this.age = age;
  }
  public person() {
    super();
  }
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + level;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
  }
  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    person other = (person) obj;
    if (age != other.age)
      return false;
    if (level != other.level)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }
}

结果为：会出现数据转化异常

1.2.3如何让Treeset集合进行排序（自然排序.比较器排序 ）

package com.xzs.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
public class demo1 {
  public static void main(String[] args) {
        Set s = new TreeSet();
       s.add(new Student("zs",17));
       s.add(new Student("ls",19));
       s.add(new Student("ww",18));
        System.out.println("目前集合容器中的元素："+s);
    }
}
class Student implements Comparable{
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        System.out.println("调用了equals方法。。。");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && name.equals(student.name);
    }
    @Override
    public int hashCode() {
        System.out.println("调用了hashCode方法。。。");
        return Objects.hash(name, age);
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Object o) {
        Student student = (Student) o;
        return this.age - student.age;
    }
}

结果为：

当然我们也可以用TreeSet构造器使用实现java.util.Comparator的匿名内部类

如

package com.xzs.set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
import java.util.TreeSet;
public class demo1 {
  public static void main(String[] args) {
    TreeSet s=new TreeSet(new Comparator() {
      public int compare(Object o1, Object o2) {
                System.out.println("调用了compare方法。。。");
                Student s1 = (Student) o1;
                Student s2 = (Student) o2;
                if (s1.getAge()-s2.getAge() == 0)
                    return s1.getName().compareTo(s2.getName());
                return s1.getAge()-s2.getAge();
            }
    });
        s.add(new Student("zs",16));
        s.add(new Student("ls",17));
        s.add(new Student("zs",17));
        s.add(new Student("ww",18));
        System.out.println("目前集合容器中的元素："+s);
    }
}
class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        System.out.println("调用了equals方法。。。");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && name.equals(student.name);
    }
    @Override
    public int hashCode() {
        System.out.println("调用了hashCode方法。。。");
        return Objects.hash(name, age);
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

得到的结果为：

 


现在是571
目录
相关文章
听白
|
3月前
|
存储 NoSQL 关系型数据库
Redis 集合(Set)
10月更文挑战第17天
听白
48 5
众所周知
|
3月前
|
算法 Java 数据处理
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。HashSet基于哈希表实现，提供高效的元素操作；TreeSet则通过红黑树实现元素的自然排序，适合需要有序访问的场景。本文通过示例代码详细介绍了两者的特性和应用场景。
众所周知
54 6
龙大吉
|
3月前
|
存储 Java 数据处理
Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位
【10月更文挑战第16天】Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位。本文通过快速去重和高效查找两个案例，展示了Set如何简化数据处理流程，提升代码效率。使用HashSet可轻松实现数据去重，而contains方法则提供了快速查找的功能，彰显了Set在处理大量数据时的优势。
龙大吉
39 2
东方睿赢
|
3月前
|
存储 算法 Java
Java Set因其“无重复”特性在集合框架中独树一帜
【10月更文挑战第14天】Java Set因其“无重复”特性在集合框架中独树一帜。本文深入解析Set接口及其主要实现类（如HashSet、TreeSet）如何通过特定的数据结构（哈希表、红黑树）确保元素唯一性，并提供最佳实践建议，包括选择合适的Set实现类和正确实现自定义对象的`hashCode()`与`equals()`方法。
东方睿赢
38 3
爱吃香蕉的猫
|
2月前
set集合
HashSet(无序，唯一): 基于 HashMap 实现的，底层采用 HashMap 来保存元素。 LinkedHashSet: LinkedHashSet 是 HashSet 的子类，并且其内部是通过 LinkedHashMap 来实现的。 TreeSet(有序，唯一): 红黑树(自平衡的排序二叉树)。
爱吃香蕉的猫
26 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天】
大树营养快线
96 1
东方睿赢
|
3月前
|
存储 Java 数据处理
Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。
【10月更文挑战第16天】Java Set：无序之美，不重复之魅！Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。通过 hashCode() 和 equals() 方法实现唯一性，适用于需要唯一性约束的数据处理。示例代码展示了如何使用 HashSet 添加和遍历元素，体现了 Set 的高效性和简洁性。
东方睿赢
51 4
众所周知
|
3月前
|
存储 Java 数据处理
Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。
Java Set：无序之美，不重复之魅！Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。它通过 hashCode() 和 equals() 方法确保元素唯一性，适用于需要唯一性约束的数据处理。示例代码展示了如何使用 HashSet 实现这一特性。
众所周知
42 5