java中set接口應用辦法詳解。本站提示廣大學習愛好者：（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，則是統一個對象，不克不及反復寄存。
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寄存天然排序的對象：
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寄存客戶排序的對象：
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聚集排序，年夜家請看：
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等類的對象在聚集中均比擬他們的內容，內容雷同則籠罩已存在的對象。
以上就是本文的全體內容，願望對年夜家的進修有所贊助。
