黑马程序员JAVA基础Java 集合之Set 接口

　　Set 集合的功能和Collection 是一致的，它没有提供任何额外的方法。实际上就是Collection ，只是行为不同（Set 不允许包含重复元素）。

　　Set 集合的特点：存入的元素的是无序的，即存入和取出的顺序不一定不一致，且元素不可以重复。 

public class SetText {
    public static void main(String[] args) 
    {
        Set books = new HashSet() ; 
//        添加一个字符串对象
        books.add(new String("笑傲江湖"))  ; 
//        添加另一的字符串对象，打印返回值
        System.out.println(books.add(new String("笑傲江湖")));
//        打印Set集合中的元素。
        System.out.println(books); 
    }
}

　　Set 不允许包含相同的元素，所以在添加元素时，会用equals 方法进行判断，如果比较返回true则表示两对象相等，所以add 方法会返回false，表示添加失败。

一：HashSet 类

　　HashSet 类是 Set 接口的实现类。其底层数据结构是哈希表，所以具有很好的存取和查找性能。 

　　1.1、HashSet 是如何保证元素唯一性的？

　　当向HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的HashCode值，然后根据该HashCode值来决定该对象在HashSet 中存储的位置。如果两个HashCode值不相等，则存入元素。（不会调用equals() 方法 。）

　　如果两个HashCode值相等，则调用equals 方法进行判断，如果两个元素通过equals 方法比较返回true ，则添加失败，否则添加成功。

　　所以：HashSet 集合判断两个元素相等的标准是两个对象通过equals 方法比较，并且两个对象的hashCode() 方法返回值也相等。在定义类时，如果要用到集合，则要重写hashCode() 和 equals() 两个方法。 

　　注意：重写hashCode() 方法的基本规则：

　　1、当两个对象通过equals 方法比较返回true 时，这两个对象的HashCode 应该相等。

　　2、对象中用作equals 比较的标准属性，都应该用来计算HashCode值。

　　不同类型属性获取HashCode值的方式：f表示对象中每一个有意义的属性。

属性类型	计算方式
boolean	HashCode = (f?0:1);
整数型	hashCode = (int)f
long	hashCode = (int)(f^(f>>>32))
float	hashCode = Float.floatToIntBits(f)
double	long l = Double.doubleToLongBits(f) hashCode = (int)(l^(l>>>32))
普通引用型	hashCode = f.hashCode()

 

 

class Person
{
    private String name ; 
    private String id  ; 
    public Person(String name , String id)
    {
        this.name = name ; 
        this.id = id ; 
    }
//    get方法
    public String getName()
    {
        return name ;
    }
    public String getId()
    {
        return id ; 
    }
//    重写equals 方法
    public boolean equals(Object obj)
    {
//        
        if (!(obj instanceof Person))
            return false  ;
        Person p = (Person) obj ; 
        return this.name.equals(p.name) && this.id.equals(p.id) ; 
    }
//    重写 hashCode 方法
    public int hashCode()
    {
        return name.hashCode()+id.hashCode() ; 
    } 
}
public class HashSetDemo {
    public static void main(String[] args)
    {
        HashSet hs = new HashSet() ; 
        hs.add(new Person("张三" , "110110")) ;
        hs.add(new Person("李四" , "120110")) ;
        hs.add(new Person("张三" , "123110")) ;  
        hs.add(new Person("张三" , "110110")) ;  
        Iterator it = hs.iterator() ; 
        while(it.hasNext())
        {
            Person p = (Person) it.next() ; 
            System.out.println("name:"+p.getName() + "," + "id:"+p.getId() );
        } 
    }
}

　　上面代码的判断两个Person 对象是否相等的条件是： name 和 id 都相等。

　　1.2、关于hashCode() 方法对于HashSet 的作用：

　　hash 算法功能：它能保证通过一个对象快速查找到另一个对象。其价值在于速度，它可以保证查询得到快速执行。当需要集合中的某个集合中某个元素时，hash算法可以直接根据元素的值得到该元素保存在何处，从而可以让程序快速找到该元素。简单来来说HashCode值 类似数组中的索引。

　　而不直接使用数组的原因：因为数组的索引是连续的，长度是固定的，无法自由增加数组的长度，而HashSet 采用每个元素的HashCode 值作为索引，可以自由增加HashSet 长度。而且因为长度不是固定的，索引不是连续的，所以HashSet 存储和删除都是比较高效的。

　　1.3、HashSet 判断和删除的依据：

　　调用hashCode() 方法判断对象的hashCode值是否在集合中存在，如果不存在则返回false  ；否则再调用equals () 方法进行判断。

 　　

二.TreeSet 类

　　2.1 TreeSet 是如何保证元素唯一性的?

　　当把一个对象添加到TreeSet时，如果是第一个，不会进行任何判断；当添加第二对象时，TreeSet 就会调用对象的compareTo(Object o) 方法与集合其他元素进行比较，通过comparaTo 方法返回的值来进行判断，如果compareTo 方法返回的是值是0, 这表示集合中存在该元素；如果返回的是1这表示该对象大于比较的对象；如果返回的是-1则表示该对象小于比较的对象。

　　所以，如果试图把一个对象添加进TreeSet，则该对象必须实现Comparable 接口否则程序将会抛出异常---ClassCastException。而且向TreeSet 中添加的应该是同一类对象。

　　TreeSet 类可以确保元素集合处于排序状态，这排序状态不是根据元素的插入顺序进行排序的，而是根据元素的实际值来排序的。

public class TreeSetText {
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet() ;
        ts.add("adsfdf") ; 
        ts.add("refdas") ;
        ts.add("vceqw") ;
        ts.add("asdfe") ; 
        System.out.println(ts);
    }
}

　　输入结果：

[adsfdf, asdfe, refdas, vceqw]

　　与HashSet 集合采用的hash 算法来确定元素的存储的位置不同，TreeSet 采用二叉树的数据结构对元素进行排序。

　　TreeSet排序方式用两种：

　　1、自然顺序排序。

　　2、定义比较器排序，即制定排序。

　2.1、自然排序：

　　让元素自身具备比较性，元素需要实现Comparable 接口，覆盖compareTo 方法。

　　> int compareTo(Object o) :比较对象与指定对象的顺序，如果该对象小于、等于或大于指定对象，则分为负整数、0或正整数。

class Student implements Comparable
{
//    当两个对象的name 和 id 都相等时，表示是同一个人。
    private String name ;
    private long id ; 
    public Student(String name , long id)
    {
        this.name = name; 
        this.id = id ;
    }
//    get方法
    public String getName()
    {
        return name ;
    }
    public long getId()
    {
        return id ; 
    }
//    覆盖comparaTo 方法
//    按找id来排序。
    public int compareTo(Object obj)  
    {
        if (obj instanceof Person)
            throw new RuntimeException() ;
        Student p = (Student) obj ;  
        if(this.id > p.id  )
            return 1 ; 
        if(this.id == p.id )
        {
            return this.name.compareTo(p.name) ;
        }
        return -1 ;
    } 
    public boolean equals(Object obj)
    {
        Student p = (Student) obj ; 
        return this.name.equals(p.name)&& p.id == this.id ; 
    }
}

　　当Student 对象添加进TreeSet 时， 会调用Student 类的compareTo(Object o) 方法来进行判断要添加的对象是否在集合中已经存在，如果存在则不再添加；如果不存在，则根据compareTo 方法的返回值来进行排序。

　　

　　2.3 定义比较器（定制排序）

　　当对象自身不具备比较性时，或者具备的比较性不是所需要的，这时候就需要让集合自身具备比较性。如：TreeSet 的自然排序是根据集合元素的大小，TreeSet 将它们以升序排序的，如果要定制需要的排序，例如以降序排序，则可以通过定义比较器的方法让集合自身具备比较性。

　　如何定义比较器：

　　定义一个类，实现Comparator 接口，并且覆盖compare() 方法。然后将比较器对象作为参数传递给TreeSet 集合的构造器。

　　> int compare(Object o1 , Object o2) 比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

　　注意：其实Comparator 接口除了compare 方法外，还有equals(Object o)，由于定义的类继承了Object 类， 所以不需要覆盖equals 方法了。 

class Student implements Comparable
{
//    当两个对象的name 和 id 都相等时，表示是同一个人。
    private String name ;
    private long id ; 
    public Student(String name , long id)
    {
        this.name = name; 
        this.id = id ;
    }
//    get方法
    public String getName()
    {
        return name ;
    }
    public long getId()
    {
        return id ; 
    }
//    覆盖comparaTo 方法
//    按找id来排序。
    public int compareTo(Object obj)  
    {
        if (obj instanceof Person)
            throw new RuntimeException() ;
        Student p = (Student) obj ;  
        if(this.id > p.id  )
            return 1 ; 
        if(this.id == p.id )
        {
            return this.name.compareTo(p.name) ;
        }
        return -1 ;
    } 
    public boolean equals(Object obj)
    {
        Student p = (Student) obj ; 
        return this.name.equals(p.name)&& p.id == this.id ; 
    }
}
public class TreeSetTest {
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet( new Comparator()
        {
//            定义比较器：按id的降序排列
            public int compare(Object o1 , Object o2)
            {
                if ((o1 instanceof Person) &&(o2 instanceof Person))
                    throw new RuntimeException() ;
                Student p = (Student) o1 ;
                Student s = (Student) o2 ;
                if(p.getId() > s.getId()  )
                    return -1 ; 
                if(p.getId() == s.getId() )
                {
                    return p.getName().compareTo(s.getName()) ;
                }
                return  1 ;
            }
        }) ; 
        
        ts.add(new Student("hezuoan001",12)) ;
        ts.add(new Student("hezuoan005",11)) ;
        ts.add(new Student("hezuoan003",1)) ;
        ts.add(new Student("hezuoan004",4)) ;
        ts.add(new Student("hezuoan002",11)) ;
        
        Iterator it = ts.iterator() ; 
        while(it.hasNext())
        {
            Student s = (Student) it.next() ; 
            System.out.println("name:"+s.getName()+"    id:"+s.getId());
        }
    }
} 

 　　当没有定义比较器时（第44行没有向TreeSet 集合构造器传递参数 ）打印的结果如下： 

name:hezuoan003    id:1
name:hezuoan004    id:4
name:hezuoan002    id:11
name:hezuoan005    id:11
name:hezuoan001    id:12

 　　定义比较器时，且在Student 类实现了Comparable 接口并覆盖了compareTo(Object o) 方法的情况下，打印的结果如下：

name:hezuoan001    id:12
name:hezuoan002    id:11
name:hezuoan005    id:11
name:hezuoan004    id:4
name:hezuoan003    id:1

 　　所以，当两种排序都存在时，以比较器为主。

 　　注意：当通过Comparator 对象来实现TreeSet 定制排序时，依然不可以向TreeSet 中添加类型不同的对象。

 　　2.4 练习：按字符串的长度排序： 

　　字符串本身具备比较性：字符串实现了Comparable 接口，并且覆盖了CompareTo（Object obj) 方法，其比较是按自然循序排序的。而我们想要的排序是按字符串的长度来排序，所以这时候只能使用比较器。代码如下： 

public class ComparatorTest {
    public static void main(String[] args)
    {
//        定义比较器：按字符串的长度排序
        TreeSet ts = new TreeSet(new Comparator()
        {
            public int compare(Object o1 , Object o2)
            {
                String s1 = (String) o1 ; 
                String s2 = (String) o2 ;
//                定义 Integer 对象来进行 s1 和 s2 长度的比较。
                int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
                if (num == 0)
                {
                    return s1.compareTo(s2) ; 
                }
                return num ;
            }
        }) ; 
        ts.add("adfwefad");
        ts.add("adfadsfwefawefad");
        ts.add("adfwfadfaefad");
        ts.add("adfwedfafad");
        ts.add("adfwedfasfad"); 
        for (Object obj : ts)
        { 
            System.out.println(obj);
        } 
    }
}

　　总结：

　　Java 的一些常用类已经实现了 Comparable 接口，并提供了比较大小的标准。下面是实现了Comparable 接口的常用类：

　　> 所有数值类型对应的包装类：Integer、Double等，按他们的数值进行大小比较。

　　> Character : 按字符的UNICODE 值进行比较。

　　> Boolean : true 对应的包装类实例大于false 对应的包装实例。

　　> String : 按字符串中字符的UNICODE 值进行比较。

　　> Date、Time : 后面的时间、日期比前面的时间、日期大。

 　　

　　2.5 TreeSet 提供的额外方法：

　　因为TreeSet 中的元素是有序的，所以增加了访问第一个、前一个、后一个、最后一个元素的方法，并且提供了三个从TreeSet 中截取子TreeSet 的方法。如下：

　　> Object first() : 返回第一个元素。

　　> Object last() : 返回最后一个元素。

　　> Object lower(Object o) : 返回集合中位于指定元素之前的元素。

　　> Object higher(Object o) : 返回集合中位于指定元素之后的元素。

　　> SortedSet subSet(fromElement , toElement) ： 返回此Set 的子集合 ，范围从fromElement（包含）到toElement（不包含）。

　　> SortedSet headSet(toElement) ： 返回此Set 子集合，由小于toElement 的元素组成。

　　> SortedSet tailSet(fromElement) : 返回次Set 子集合，有大于fromElement 的元素组成。