Java集合之Set

目录

• 正文
  • Set的特点？
  • Set的常用子类？
    • HashSet？
    • TreeSet？

正文

Set的特点？

• 它与List(关于List可以参考Java集合之List)不同，它是一个不包含重复元素的collection(Set所具有的方法和Collection所具有的方法一致)。

• 它是无序的，但当向集合中存储元素的顺序与Set内部存储元素的顺序一致时就可能会出现有序的情况，只不过这种情况出现的概率很小。

Set的常用子类？

关于这一部分我们的讲解思路与List相同：先明确各自的特点，知道具体的场景该用哪一种；再分析各自所具有的一些方法。这两者都可以通过查看jdk文档获悉。

HashSet？

HashSet内部的数据结构是哈希表；它是不同步的。

那么哈希表是什么呢？顾名思义，它就是一张使用哈希算法得出的表。通过哈希算法，我们存取元素的过程就变成了这样：假如我们要存储元素A，先根据哈希算法算出A元素的哈希值，再根据该哈希值得出元素A存储到集合中的位置，根据该位置存储即可；假如我们要从集合中取出元素B，还是先根据哈希算法算出B元素的哈希值，再根据该哈希值到集合中指定的位置查找，如果该位置上的元素是B，就直接取出，如果不是，就说明该集合中没有B元素。

由于哈希表的这种特点，所以哈希表中的元素是不能重复的。哈希表确定两个元素是否相同的依据是：先用hashCode()算出两个元素的哈希值，如果二者相等再使用equals()判断两者的内容，如果两者内容也相同，那么哈希表就认为这两个元素是相同的。

由于Object类中有hashCode()，所以Java中的所有对象都有哈希值。并且Object类中的hashCode()被native修饰是底层实现的。但是我们可以自定义该方法的实现。

当两个不同的元素算出的哈希值却相等时，就出现了哈希冲突。这种情况下如何进行存取元素就会视具体的哈希算法而定。

当向HashSet中存储自定义对象并且我们对这些对象是否相等有自己的逻辑时，就可以在对象所属的类中覆盖hashCode()和equals()。假设现在有这样的需求：向HashSet集合中存储Person对象并且如果姓名和年龄相同就视为同一个人。代码如下：

import java.util.HashSet;
import java.util.Iterator;

class Person {
    private String name;
    private int age;

    public Person() {
        super();

    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    /**
     * 覆盖hashCode()和equals()实现自己的判断逻辑
     * @return
     */
    @Override
    public int hashCode() {
        return name.hashCode() + age * 27;
    }
    @Override
    public boolean equals(Object obj) {
        if(this == obj)
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");

        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString(){
        return name+":"+age;
    }
}

class Demo {
    public static void main(String[] args) {

        HashSet hs = new HashSet();
        hs.add(new Person("lisi4",24));
        hs.add(new Person("lisi7",27));
        hs.add(new Person("lisi1",21));
        hs.add(new Person("lisi7",27));


        Iterator it = hs.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            System.out.println(p);
        }
    }
}

我们要注意List接口中的contains()和remove()内部使用的都是equals()进行判断，即是：如果我们需要使用contains()或equals()实现自定义判断逻辑，只需覆盖equals()即可。假设现在有这样的需求：删除ArrayList中重复的Person对象并且当Person对象的姓名和年龄相同就视为同一个人。代码如下：

import java.util.ArrayList;
import java.util.Iterator;

class Person {
    // 此处省略Person类的属性、构造函数、set/get方法、toString()，与上同

    @Override
    public boolean equals(Object obj) {    // 仅覆盖equals()即可
        if(this == obj)
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");

        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
}

class Demo {
    public static void main(String[] args) {

        ArrayList al = new ArrayList();
        al.add(new Person("lisi1", 21));
        al.add(new Person("lisi2", 22));   // 1
        al.add(new Person("lisi3", 23));
        al.add(new Person("lisi4", 24));
        al.add(new Person("lisi2", 22));
        al.add(new Person("lisi3", 23));

        al = getSingleElement(al);
        System.out.println(al);

        System.out.println(al.remove(new Person("lisi2",22)));   // 与1处的对象是两个对象，但由于我们覆盖了equals()并实现了自己的判断逻辑，所以返回true并且删除成功
	System.out.println(al);
    }

    private static ArrayList getSingleElement(ArrayList al) {
        ArrayList temp = new ArrayList();

        Iterator it = al.iterator();

        while(it.hasNext()){
            Object obj = it.next();

            if(!temp.contains(obj)){
                temp.add(obj);
            }
        }
        return temp;
    }
}

所以我们可以总结：如果涉及到判断两个对象是否相等，最好hashCode()和equals()都进行覆盖，这样对List和HashSet都适用。

如果我们希望集合在唯一时还能保证有序性，我们就可以使用LinkedHashSet。它内部是由链表和哈希表共同实现的。

TreeSet？

TreeSet的内部的数据结构是二叉树；它使用元素的自然顺序对元素进行排序；它是不同步的。

TreeSet判断元素是否唯一的根据是：判断比较方法的返回结果，如果是0，就说明是同一个元素。

我们需要注意：TreeSet对元素进行排序有两种方式，第一种就是让需要排序的类实现Comparable接口并且覆盖compareTo()。假设现在有这样的需求：以Person对象的年龄进行从小到大的排序。代码如下：

// 此处省略Person类的属性、构造函数、set/get方法、toString()，与上同

import java.util.Iterator;
import java.util.TreeSet;

class Person implements Comparable {   // 实现Comparable接口 
    @Override
    public boolean equals(Object obj) {    // 仅覆盖equals()即可
        if(this == obj)
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");

        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }

    @Override  
    public int compareTo(Object o) {   // 覆盖compareTo()并实现自己的判断逻辑
        Person p = (Person)o;

        int  temp = this.age - p.age;
        return temp == 0 ? this.name.compareTo(p.name) : temp;
    }
}

class Demo {
    public static void main(String[] args) {

        TreeSet ts = new TreeSet();

        ts.add(new Person("zhangsan",28));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("wangu",24));

        Iterator it = ts.iterator();

        while(it.hasNext()){
            Person p = (Person)it.next();

            System.out.println(p.getName() + ":" + p.getAge());
        }
    }
}

有很多类都实现了Comparable接口，意味着这些类都自定义了排序方式，这种排序方式被称为类的自然排序，那么当我们不想要按照这种自然排序方式进行排序时，就可以使用第二种方法：定义一个类(比较器)让其实现Comparator接口并且覆盖compare()，并将该类对象作为参数传递给TreeSet集合的构造函数。代码如下：

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class Person {
// 此处省略Person类的属性、构造函数、set/get方法、toString()，与上同

    @Override
    public int hashCode() {
        return name.hashCode() + age * 27;
    }
    @Override
    public boolean equals(Object obj) {
        if(this == obj)
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");

        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
}

/**
 * 一个根据Person类的name进行排序的比较器
 */
class ComparatorByName implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {

        Person p1 = (Person)o1;
        Person p2 = (Person)o2;

        int temp = p1.getName().compareTo(p2.getName());

        return temp == 0 ? p1.getAge() - p2.getAge() : temp;
    }

    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new ComparatorByName());


        ts.add(new Person("zhangsan",28));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("wangu",24));

        Iterator it = ts.iterator();

        while(it.hasNext()){
            Person p = (Person)it.next();

            System.out.println(p.getName() + ":" + p.getAge());
        }
    }
}

由于HashSet可以实现任意方式的排序，那我们也可以实现HashSet的有序，代码见下：

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class Person {
// 此处省略Person类的属性、构造函数、set/get方法、toString()，与上同

    @Override
    public int hashCode() {
        return name.hashCode() + age * 27;
    }
    @Override
    public boolean equals(Object obj) {
        if(this == obj)
            return true;
        if(!(obj instanceof Person))
            throw new ClassCastException("类型错误");

        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;
    }
}

/**
 * 一个实现HashSet有序的比较器
 */
class ComparatorByName implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {

        Person p1 = (Person)o1;
        Person p2 = (Person)o2;

        return 1; 
    }

    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new ComparatorByName());


        ts.add(new Person("zhangsan",28));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("wangu",24));

        Iterator it = ts.iterator();

        while(it.hasNext()){
            Person p = (Person)it.next();

            System.out.println(p.getName() + ":" + p.getAge());
        }
    }
}