服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|

服务器之家 - 编程语言 - JAVA教程 - java中set接口使用方法详解

java中set接口使用方法详解

2020-04-27 12:19lijiao JAVA教程

这篇文章主要为大家详细介绍了java中set接口使用方法,介绍了Java中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,则是同一个对象,不能重复存放。

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

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

 2.TreeSet

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

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

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

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

 

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

输出结果为:

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

 

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

输出结果为:

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

 

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

输出结果为:
[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等类的对象在集合中均比较他们的内容,内容相同则覆盖已存在的对象。

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

延伸 · 阅读

精彩推荐