Java基础知识——HashSet_TreeSet_Comparator

一、Set

（一）set概述（摘自API文档）

 

public interface Set<E>

extends Collection<E>

set是一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从Collection 接口所继承的内容。出于方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对Set 接口进行了修改，但是没有包含任何其他的规定）。

对这些构造方法的其他规定是（不要奇怪），所有构造方法必须创建一个不包含重复元素的 set（正如上面所定义的）。

注：如果将可变对象用作 set 元素，那么必须极其小心。如果对象是 set 中某个元素，以一种影响 equals 比较的方式改变对象的值，那么 set 的行为就是不确定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。

（二）set集合通用方法

boolean

add(E e) 
          如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。

boolean

addAll(Collection<? extends E> c) 
          如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。

void

clear() 
          移除此 set 中的所有元素（可选操作）。

boolean

contains(Object o) 
          如果 set 包含指定的元素，则返回 true。

boolean

containsAll(Collection<?> c) 
          如果此 set 包含指定 collection 的所有元素，则返回 true。

boolean

equals(Object o) 
          比较指定对象与此 set 的相等性。

 int

hashCode() 
          返回 set 的哈希码值。

boolean

isEmpty() 
          如果 set 不包含元素，则返回 true。

Iterator<E>

iterator() 
          返回在此 set 中的元素上进行迭代的迭代器。

boolean

remove(Object o) 
          如果 set 中存在指定的元素，则将其移除（可选操作）。

 boolean

removeAll(Collection<?> c) 
          移除 set 中那些包含在指定 collection 中的元素（可选操作）。

 boolean

retainAll(Collection<?> c) 
          仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。

 int

size() 
          返回 set 中的元素数（其容量）。

 Object[]

toArray() 
          返回一个包含 set 中所有元素的数组。

<T> T[]

toArray(T[] a) 
          返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。

 

 

二、     HashSet：

（1）概述

此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

注意，此实现不是同步的。如果多个线程同时访问一个哈希 set，而其中至少一个线程修改了该 set，那么它必须 保持外部同步。这通常是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSet 方法来“包装” set。最好在创建时完成这一操作，以防止对该 set 进行意外的不同步访问：

   Set s = Collections.synchronizedSet(new HashSet(...));

 

 

|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、

       |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。

                    

（2）HashSet是如何保证元素唯一性的呢？

是通过元素的两个方法，hashCode和equals来完成。

如果元素的HashCode值相同，才会判断equals是否为true。

如果元素的hashcode值不同，不会调用equals。

 

注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

 

Set集合的功能和Collection是一致的。

 

(3)自练

importjava.util.*;/* 用HashSet存储自定义对象 */ class HashSetDemo{       public static void main(String[] args)       {              Set<Person> hs= newHashSet<Person>();               hs.add(newPerson("zhangsan",20));              hs.add(newPerson("zhangsan3",23));              hs.add(newPerson("zhangsan2",22));              hs.add(newPerson("zhangsan6",26));              hs.add(newPerson("zhangsan2",22));//重复元素无法放入集合内               sop(hs);               Person p1 = newPerson("zhangsan6",26);               sop(hs.contains(p1));//判断对象是否存在               sop(hs.remove(p1));//删除对象               sop(hs);                    }        public static void sop(Object obj)       {              System.out.println(obj);       }}  class Person{       private String name;       private int age;        Person(String name,int age)       {              this.name = name;              this.age = age;       }        public boolean equals(Object obj)       {              if (!(obj instanceof Person))              {                     throw newClassCastException("不是Person类");              }               Person p = (Person)obj;               return this.name.equals(p.name)&& this.age == age;       }        public int hashCode()       {              returnthis.name.hashCode()+age*39;       }        public String toString()       {              returnthis.name+"_"+this.age;       }} 

 

三、     TreeSet

 

（1）  概述

 

基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的Comparator 进行排序，具体取决于使用的构造方法。

此实现为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。

注意，如果要正确实现 Set 接口，则 set 维护的顺序（无论是否提供了显式比较器）必须与 equals 一致。（关于与 equals 一致 的精确定义，请参阅 Comparable 或 Comparator。）这是因为 Set 接口是按照 equals 操作定义的，但 TreeSet 实例使用它的 compareTo（或 compare）方法对所有元素进行比较，因此从 set 的观点来看，此方法认为相等的两个元素就是相等的。即使 set 的顺序与 equals 不一致，其行为也是 定义良好的；它只是违背了 Set 接口的常规协定。

注意，此实现不是同步的。

|--TreeSet：可以对Set集合中的元素进行排序。

                            底层数据结构是二叉树。

保证元素唯一性的依据：compareTo方法return 0.

（2）TreeSet排序

TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。

TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。

 

（3）构造方法

构造方法摘要

TreeSet() 
          构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。

 

TreeSet(Collection<? extends E> c) 
          构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。

 

TreeSet(Comparator<? super E> comparator) 
          构造一个新的空 TreeSet，它根据指定比较器进行排序。

 

TreeSet(SortedSet<E> s) 
          构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。

 

 

（4）自练

 

import java.util.*; /* 需求：在TreeSet中存储学生类的自定义对象学生类中有姓名和年龄，首先按照姓名排序，若姓名相同，则按照年龄排序 */ class TreeSetDemo{       publicstatic void main(String[] args)       {              Set<Student>ts = new TreeSet<Student>();               ts.add(newStudent("Dabao",28));              ts.add(newStudent("Sibao",25));                                         ts.add(newStudent("Sanbao",26));              ts.add(newStudent("Sibao",24));              ts.add(newStudent("Erbao",27));                           Iterator<Student>it = ts.iterator();               while(it.hasNext())              {                     sop(it.next());              }        }        publicstatic void sop(Object obj)       {              System.out.println(obj);       }} class Student implements Comparable//此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序{       privateString name;       privateint age;        Student(Stringname,int age)       {              this.name= name;              this.age= age;       }        publicString getName()       {              returnthis.name;       }        public intgetAge()       {              returnthis.age;       }        public intcompareTo(Object obj)//compareTo 方法被称为它的自然比较方法       {              if(!(obj instanceof Student))//比较之前要先判断类型是否匹配              {                     thrownew ClassCastException("不是学生类");              }                           Studentstu = (Student)obj;               intnum = (this.name).compareTo(stu.getName());//将比较结果存入变量中待返回               if(num==0)  //如果姓名相同，则判断年龄              {                     returnstu.getAge()-this.age;              }              returnnum;       }        publicString toString()       {              returnname+"_"+age;       }}  

四、比较器Comparator

 

强行对某个对象 collection 进行整体排序 的比较函数。可以将Comparator 传递给 sort 方法（如Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

 

自练

import java.util.*;/* 需求：使用比较器对TreeSet进行排序 */ class CompDemo{       publicstatic void main(String[] args)       {              Set<Student>ts = new TreeSet<Student>();               ts.add(newStudent("Dabao",28));              ts.add(newStudent("Sibao",25));                                     ts.add(newStudent("Sanbao",26));              ts.add(newStudent("Sibao",24));              ts.add(newStudent("Erbao",27));                           Iterator<Student>it = ts.iterator();               while(it.hasNext())              {                     sop(it.next());              }             }        publicstatic void sop(Object obj)       {              System.out.println(obj);       }} class MyComparator implements Comparator  //比较器接口，实现该接口需要重写compare()方法{       publicint compare(Object o1, Object o2)//这次按照年龄排序       {              if(!(o1 instanceof Student && o2 instanceof Student))              {                     thrownew ClassCastException("不是学生类");              }               Students1 = (Student)o1;              Students2 = (Student)o2;               intnum = ((Integer)s1.getAge()).compareTo((Integer)s2.getAge());              if(num == 0)              {                     returns1.getName().compareTo(s2.getName());              }              returnnum;       } }/* 继续用上个例子中的学生类，当类既有自然顺序，又有比较器时，使用比较器排序 */ class Student implements Comparable//此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序{       privateString name;       privateint age;        Student(Stringname,int age)       {              this.name= name;              this.age= age;       }        publicString getName()       {              returnthis.name;       }        publicint getAge()       {              returnthis.age;       }        publicint compareTo(Object obj)//compareTo 方法被称为它的自然比较方法       {              if(!(obj instanceof Student))//比较之前要先判断类型是否匹配              {                     thrownew ClassCastException("不是学生类");              }                           Studentstu = (Student)obj;               intnum = (this.name).compareTo(stu.getName());//将比较结果存入变量中待返回               if(num==0)  //如果姓名相同，则判断年龄              {                     returnstu.getAge()-this.age;              }              returnnum;       }        publicString toString()       {              returnname+"_"+age;       }}