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)

1.Set集合的特点

1.1特点一无序无修改方法

2.2特点二不可重复

2.Set集合的遍历

2.1方法一加强foreach遍历

2.2方法二 ITerator迭代器遍历

3.Set集合的去重

3.1 Set集合的去重原理

4.Set集合之排序

4.1通过将Treeset进行排序

4.2根据多重条件进行判断

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

感谢大家的观看 !

热门文章

最新文章

相关课程

相关电子书

J2EE基础(集合框架之Set)

1.Set集合的特点

1.1特点一 无序 无修改方法

2.2特点二 不可重复

2.Set集合的遍历

2.1方法一 加强foreach遍历

2.2方法二 ITerator迭代器遍历

3.Set集合的去重

3.1 Set集合的去重原理

4.Set集合之排序

4.1通过将Treeset进行排序

4.2根据多重条件进行判断

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

感谢大家的观看 !

热门文章

最新文章

相关课程

相关电子书

1.1特点一无序无修改方法

2.2特点二不可重复

2.1方法一加强foreach遍历