Set集合介绍-阿里云开发者社区

Set集合介绍

2023-10-25 38

版权

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

简介： Set集合介绍

Set集合概述

Set继承于Collection接口，是一个不允许出现重复元素，并且无序的集合，主要有HashSet和TreeSet两大实现类。

set集合结构

一.set集合特点

1.无序

2.不可重复

3.没有修改方法

package com.liaozhixiang.java;
/**
 * set集合的特点
 * 1.无序
 * 2.不可重复
 * 3.不可修改
 * @author liao
 *
 */
import java.util.HashSet;
public class Dome1 {
  public static void main(String[] args) {
    HashSet set = new HashSet();
    //增加
    set.add("java");
    set.add("c++");
    set.add("c");
    set.add("java");
    System.out.println(set);
//    //删除
//    set.remove("b");
//    System.out.println(set);
//    //查询
    System.out.println(set.contains(set));
  }
}

无序特点

不可重复

没有修改方法原因：因为set集合没有顺序没有下标

二.Set集合遍历方式

1.foreach

2.迭代器

package com.liaozhixiang.java;
/**
 * 遍历方式
 * 1.foreach
 * 2.iterator
 * @author liao
 *
 */
import java.util.HashSet;
import java.util.Iterator;
public class Dome2 {
  public static void main(String[] args) {
    HashSet set = new HashSet();
    //增加
    set.add("java");
    set.add("c++");
    set.add("c");
    System.out.println("===foreach循环===");
    //foreach循环
    for (Object object : set) {
    System.out.println(object); 
    }
    System.out.println("===Iterator迭代器===");
    //Iterator迭代器
    Iterator it = set.iterator();
    while(it.hasNext()) {
      System.out.println(it.next());
    }
  }
}

打印结果：

三.set集合去重底层原理

package com.liaozhixiang.java;
import java.util.HashSet;
/**
 * set集合去重原理
 * 问题：
 * 1.set集合能存储重复的吗？能否直接存储进去
 * 2.contains能不能判断存进去是否是对象形式的
 * 
 * 
 * @author liao
 *
 */
public class Dome3 {
  public static void main(String[] args) {
    HashSet set = new HashSet();
    //增加
//    set.add("java");
//    set.add("c++");
//    set.add("c");
    //Java 集合类中的 Set.contains() 方法判断 Set 集合是否包含指定的对象。该方法返回值为 boolean 类型，
    //如果 Set 集合包含指定的对象，则返回 true，否则返回 false。
//    
//    //返回结果为true
//    System.out.println(set.contains("c"));
    set.add(new Users(1,"张三"));
    set.add(new Users(2,"李四"));
    set.add(new Users(3,"王五"));
    //返回结果false  
    System.out.println(set.contains(new Users(2,"李四")));
  }
}
class Users {
  private int id;
  private String name;
  public int getId() {
    return id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public void setId(int id) {
    this.id = id;
  }
  @Override
  public String toString() {
    return "Users [id=" + id + ", name=" + name + "]";
  }
  public Users(int id, String name) {
    super();
    this.id = id;
    this.name = name;
  }
  public Users() {
    super();
  }
  @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;
    Users other = (Users) 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和hashCode方法时会根据什么方法去重？

只调用equals 返回结果false

调用hashCode

结论：

1.添加元素时,先通过该元素的Hash值去筛选和集合当中已经有的元素Hash值是否一样

2.如果一样则调用equals方法进行判断，不同则放入,相同则不加入

四.TreeSet(自然排序，比较器排序)

1.默认排序：set集合中的默认的排序

2.自然排序：实现java.lang.Comparable接口

3.比较器排序：实现java.util.Comparator的匿名内部类

package com.liaozhixiang.java;
import java.util.Comparator;
import java.util.HashSet;
import java.util.TreeSet;
/**
 * set排序
 * 
 * @author liao
 *
 */
public class Dome4 {
public static void main(String[] args) {
  HashSet set = new HashSet();
  set.add(new Admin(1, "张三", 18, 10000));
  set.add(new Admin(2, "李四", 20, 15000));
  set.add(new Admin(3, "王五", 25, 20000));
  set.add(new Admin(4, "赵六", 27, 25000));
  set.add(new Admin(5, "张四", 30, 30000));
  //默认排序
  System.out.println("========set集合默认排序=======");
  for (Object object : set) {
    System.out.println(object);
  }
  TreeSet ts = new TreeSet();
  //把集合数据添加到TreeSet
  //注意：需要实现java.lang.Comparable下的接口 实体类需要实现Comparable
  for (Object object : set) {
    ts.add(object);
  }
        System.out.println("========调用自然排序接口 根据id排序=======");
  for (Object object : ts) {
    System.out.println(object);
  }
  //注意:实现java.util.Comparator 匿名内部类
  TreeSet ts2 = new TreeSet(new Comparator<Admin>() {
    @Override
    public int compare(Admin o1, Admin o2) {
      //根据money排序才最有钱的 在根据年龄排序
      int  num = o2.getMoney() - o1.getMoney();
      if(num == 0) {
        return o2.getAge() - o1.getAge();
      }
      return o2.getMoney() - o1.getMoney();
    }
  } );
  for (Object object : set) {
    ts2.add(object);
  }
        System.out.println("========调用比较器排序接口 根据money排序才最有钱的 在根据年龄排序=======");
  for (Object object : ts2) {
    System.out.println(object);
  }
}
}
class Admin implements Comparable<Admin>{
  private int id;
  private String name;
  private int age;
  private int money;
  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;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public int getMoney() {
    return money;
  }
  public void setMoney(int money) {
    this.money = money;
  }
  public Admin(int id, String name, int age, int money) {
    super();
    this.id = id;
    this.name = name;
    this.age = age;
    this.money = money;
  }
  public Admin() {
    super();
  }
  @Override
  public String toString() {
    return "Admin [id=" + id + ", name=" + name + ", age=" + age + ", money=" + money + "]";
  }
  @Override
  public int compareTo(Admin o) {
    // TODO Auto-generated method stub
    return this.id - o.id;
  }
}