设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

java中set接口使用方法详解

2016-7-29 15:34| 发布者: zhangjf| 查看: 625| 评论: 0

摘要: java中的set接口有如下的特点： 不允许出现重复元素； 集合中的元素位置无顺序； 有且只有一个值为null的元素。 因为java中的set接口模仿了数学上的set抽象，所以，对应的数学上set的特性为： 互异性：一个集合中， ...

java中的set接口有如下的特点：

不允许出现重复元素；
集合中的元素位置无顺序；
有且只有一个值为null的元素。

因为java中的set接口模仿了数学上的set抽象，所以，对应的数学上set的特性为：

互异性：一个集合中，任何两个元素都认为是不相同的，即每个元素只能出现一次。
无序性：一个集合中，每个元素的地位都是相同的，元素之间是无序的。集合上可以定义序关系，定义了序关系后，元素之间就可以按照序关系排序。但就集合本身的特性而言，元素之间没有必然的序。
空集的性质：空集是一切集合的子集

Set不保存重复的元素。Set中最常被使用的是测试归属性，你可以很容易的询问某个对象是否在某个Set中。Set具有与Collection完全一样的接口，因此没有任何额外的功能。实际上Set就是Collection，只是行为不同。

　　实现了Set接口的主要有HashSet、TreeSet、LinkedHashSet这几个共同点就是每个相同的项只保存一份。他们也有不同点，区别如下：

1.HashSet：

　　HashSet使用的是相当复杂的方式来存储元素的，使用HashSet能够最快的获取集合中的元素，效率非常高（以空间换时间）。会根据hashcode和equals来庞端是否是同一个对象，如果hashcode一样，并且equals返回true，则是同一个对象，不能重复存放。

  2. package cn.set;
  4. import java.util.HashSet;
  5. import java.util.Set;
  7. class Student{
  8. int id;
  9. public Student(int id) {
  10. this.id = id;
  11. }
  12. @Override
  13. public String toString() {
  14. return this.id+"";
  15. }
  16. @Override
  17. public int hashCode() {
  18. return this.id;
  19. }
  20. @Override
  21. public boolean equals(Object obj) {
  22. if (obj instanceof Student){
  23. Student stu = (Student) obj;
  24. if (stu.id == this.id)
  25. return true;
  26. }
  27. return false;
  28. }
  29. }
  30. public class HashSetTest {
  31. public static void main(String[] args) {
  32. Set<Student> set = new HashSet<Student>();
  33. Student s1 = new Student(1);
  34. Student s2 = new Student(1);
  35. Student s3 = new Student(2);
  36. set.add(s1);
  37. set.add(s2);
  38. set.add(s3);
  39. for (Student s : set) {
  40. System.out.println(s);
  41. }
  42. }
  43. }
复制代码

正如上例所示，重写了hashCode()和equals()方法来区分同意对象后，就不能存放同以对象了。如果注释这两个方法，则所有Student对象视为不同对象，都可以存放。

2.TreeSet

　　TreeSet也不能存放重复对象，但是TreeSet会自动排序，如果存放的对象不能排序则会报错，所以存放的对象必须指定排序规则。排序规则包括自然排序和客户排序。

　　①自然排序：TreeSet要添加哪个对象就在哪个对象类上面实现java.lang.Comparable接口，并且重写comparaTo()方法，返回0则表示是同一个对象，否则为不同对象。

　　②客户排序：建立一个第三方类并实现java.util.Comparator接口。并重写方法。定义集合形式为TreeSet ts = new TreeSet(new 第三方类());

下面一个例子用TreeSet存放自然排序的对象：

  2. package cn.set;
  4. import java.util.Set;
  5. import java.util.TreeSet;
  7. class Student1 implements Comparable<Student1>{
  8. int id;
  9. public Student1(int id) {
  10. this.id = id;
  11. }
  12. @Override
  13. public String toString() {
  14. return this.id+"";
  15. }
  16. @Override
  17. public int hashCode() {
  18. return this.id;
  19. }
  20. @Override
  21. public boolean equals(Object obj) {
  22. if (obj instanceof Student1){
  23. Student1 stu = (Student1) obj;
  24. if (stu.id == this.id)
  25. return true;
  26. }
  27. return false;
  28. }
  29. public int compareTo(Student1 o) {
  30. return (this.id-o.id);
  31. }
  32. }
  34. public class TreeSetTest {
  35. public static void main(String[] args) {
  36. Set<Student1> set = new TreeSet<Student1>();
  37. Student1 s1 = new Student1(5);
  38. Student1 s2 = new Student1(1);
  39. Student1 s3 = new Student1(2);
  40. Student1 s4 = new Student1(4);
  41. Student1 s5 = new Student1(3);
  42. set.add(s1);
  43. set.add(s2);
  44. set.add(s3);
  45. set.add(s4);
  46. set.add(s5);
  47. for (Student1 s : set) {
  48. System.out.println(s);
  49. }
  50. }
  52. }
复制代码

输出结果为：

下面一个例子用TreeSet存放客户排序的对象：

  2. package com.set;
  4. import java.util.Set;
  5. import java.util.TreeSet;
  7. class Student1 implements Comparable<Student1>{
  8. int id;
  9. public Student1(int id) {
  10. this.id = id;
  11. }
  12. @Override
  13. public String toString() {
  14. return this.id+"";
  15. }
  16. @Override
  17. public int hashCode() {
  18. return this.id;
  19. }
  20. @Override
  21. public boolean equals(Object obj) {
  22. if (obj instanceof Student1){
  23. Student1 stu = (Student1) obj;
  24. if (stu.id == this.id)
  25. return true;
  26. }
  27. return false;
  28. }
  29. public int compareTo(Student1 o) {
  30. return (this.id-o.id);
  31. }
  32. }
  34. public class TreeSetTest {
  35. public static void main(String[] args) {
  36. Set<Student1> set = new TreeSet<Student1>();
  37. Student1 s1 = new Student1(5);
  38. Student1 s2 = new Student1(1);
  39. Student1 s3 = new Student1(2);
  40. Student1 s4 = new Student1(4);
  41. Student1 s5 = new Student1(3);
  42. set.add(s1);
  43. set.add(s2);
  44. set.add(s3);
  45. set.add(s4);
  46. set.add(s5);
  47. for (Student1 s : set) {
  48. System.out.println(s);
  49. }
  50. }
  52. }
复制代码

输出结果为：

大家都知道List存放时按照插入顺序排序的，其实也可以用自然排序和客户排序对List集合排序，大家请看：

  2. package cn.set;
  4. import java.util.ArrayList;
  5. import java.util.Collections;
  6. import java.util.List;
  8. class MySort1 implements java.util.Comparator<Student3>{
  9. public int compare(Student3 o1, Student3 o2) {
  10. return o2.id-o1.id;
  11. }
  12. }
  13. class Student3 implements Comparable<Student3>{
  14. int id;
  15. public Student3(int id) {
  16. this.id = id;
  17. }
  18. @Override
  19. public String toString() {
  20. return this.id+"";
  21. }
  22. public int compareTo(Student3 o) {
  23. return (this.id-o.id);
  24. }
  25. }
  27. public class ListSort {
  28. public static void main(String[] args) {
  29. List<Student3> list = new ArrayList<Student3>();
  30. Student3 s1 = new Student3(5);
  31. Student3 s2 = new Student3(1);
  32. Student3 s3 = new Student3(2);
  33. Student3 s4 = new Student3(4);
  34. Student3 s5 = new Student3(3);
  35. list.add(s1);
  36. list.add(s2);
  37. list.add(s3);
  38. list.add(s4);
  39. list.add(s5);
  40. System.out.println(list);
  41. //自然排序：
  42. Collections.sort(list);
  43. System.out.println(list);
  44. //客户排序
  45. Collections.sort(list, new MySort1());
  46. System.out.println(list);
  47. }
  48. }
复制代码

输出结果为：
[5, 1, 2, 4, 3]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

下面为大家介绍Java中的Set集合接口实现插入对象不重复的原理：

在java的集合中，判断两个对象是否相等的规则是：

1)、判断两个对象的hashCode是否相等
如果不相等，认为两个对象也不相等，完毕
如果相等，转入2)
（这一点只是为了提高存储效率而要求的，其实理论上没有也可以，但如果没有，实际使用时效率会大大降低，所以我们这里将其做为必需的。后面会重点讲到这个问题。）
2)、判断两个对象用equals运算是否相等
如果不相等，认为两个对象也不相等
如果相等，认为两个对象相等（equals()是判断两个对象是否相等的关键）

对于一般类的对象（除String等封装类型对象外）：

若普通类没有重写hashcode()和equals()方法，，那么其对象在比较时，是继承的object类中的hashcode()方法，object类中的hashcode()方法是一个本地方法，对该方法的返回值进行比较时，比较的是对象的地址（引用地址），使用new方法创建内容相同的对象，两次生成的当然是不同的对象。除非重写hashcode()方法。在object类中定义的equals()方法也是对对象地址的比较。一句话总结：若不重写普通类的hashcode()和equals()方法，在Set集合中对象引用地址不一样，对象即不重复。

对于String等对象（String、Integer、Double····等等）：

由于这些封装类本身已经重写了hashcode()方法，并且重写的方法的返回值跟对象的内容相关，而不是跟引用地址相关。这些封装类中的equals()方法同样进行了重写，比较的是对象的内容，而非引用地址。一句话总结：String等类的对象在集合中均比较他们的内容，内容相同则覆盖已存在的对象。

以上就是本文的全部内容，希望对大家的学习有所帮助。

收藏 邀请
上一篇：Java解析xml的四种方法汇总下一篇：简单谈谈java中final,finally,finalize的区别

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-5-4 02:45

Copyright 2015-2025 djqfx

返回顶部