Java中Set解析

关系

在JAVA集合的这里会设计到比较多的东西，所以我们先看一下继承关系，连接一下在Set这里到底的先后顺序是什么，有一个宏观的了解：

Set:用于存储无序(存入和取出的顺序不一定相同)元素，值不能重复。

不重复性：

Set中判断是否相等通过两个方法：通过计算hashCode值和equals方法来比较。

如果想要让两个不同的Person对象视为相等的，就必须覆盖Object继下来的hashCode方法和equals方法，因为Object  hashCode方法返回的是该对象的内存地址，所以必须重写hashCode方法，才能保证两个不同的对象具有相同的hashCode，同时也需要两个不同对象比较equals方法会返回true。

如下图是Object类源码中的hashCode()方法，和String继承后重写的hashCode()函数，所以说，每一个对象都有一个hashCode值，如果hashCode值不一样，那么还要比较equals函数计算是否相同，如果相同就判断是相同元素，就不加入，如果不同就会加入。

在这里顺便提一句，equals和==的区别。equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。在开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较，也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较。

String类重写的equals()函数，源码如下：

我们自己也可以重写equals()方法，如下：

class Person extends Object{
    int age ;
    public boolean equals(Object obj) {
        if(this == obj){
            return true;
        }
        if(!(obj instanceof Person)){
            return false;
        }
        Person p = (Person)obj;
        return this.age == p.age;
    }
}

此时重写后的equals()方法便和==是有区别的了。

对equals()重新需要注意五点：

　　1 、 对任意引用值X，x.equals(x)的返回值一定为true；
　　2  、 对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true；
　　3  、 如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true ；
　　4  、如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变；
　　5  、任何非空的引用值X，x.equals(null)的返回值一定为false 。

言归正传，继续看hashCode，Object的hashCode封装在了本地，String继承自Object，它就从写了hashCode函数，可以看到它自己定义了计算方法来计算出不同的hashCode，源码如下：

Object类：

String类：

hashSet():

HashSet类，也叫哈希表，存放的是哈希值。HashSet存储元素的顺序并不是按照存入时的顺序（set的通性），是按照哈希值来存的所以取数据也是按照哈希值取得。该容器中只能存储不重复的对象。看一下HashSet的继承关系，因为它继承了Set函数，所以它也具有set的集合，对于判断重复元素，采用的也是hashCode和equals函数。

对于hashCode相同，equals不同是怎么存储的呢？这里就要看下hashSet的哈希桶结构。

图中的1、2、3、4是hashCode不同，那么存在了不同的位置，而1、5、6则属于hashCode相同，equals不同的三个元素，通过像挂灯笼一样，一个挂一个的存储起来。

一个小例子如下：

public class Student {
	private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if(!(obj instanceof Student)){
			System.out.println("类型错误");
			return false;
		}
		Student other = (Student) obj;
		return this.age ==  other.age && this.name.equals(other.name);
	}
}

public class HashSetDemo {
	public static void main(String[] args) {
		//创建HashSet对象
		HashSet hs = new HashSet();
		//给集合中添加自定义对象
		hs.add(new Student("zhangsan",21));
		hs.add(new Student("lisi",22));
		hs.add(new Student("wangwu",23));
		hs.add(new Student("zhangsan",21));
		//取出集合中的每个元素
		Iterator it = hs.iterator();
		while(it.hasNext()){
			Student s = (Student)it.next();
			System.out.println(s);
		}
	}
}

TreeSet：

现在有序的容器不能去重和排序，去重的容器不能排序，那么有没有可以排序且去重的集合呢？当然有，这就是我们要说的TreeSet。

public class test {
    public static void main(String[] args) {
        HashSet<Integer> hs = new HashSet<>();
        hs.add(14);
        hs.add(14);
        hs.add(12);
        hs.add(11);
        hs.add(15);
        hs.add(13);
        for (Integer h : hs) {
            System.out.println(h);
        }
    }
}

TreeSet既然能有排序的输出数据，那么它一定有自己的排序算法。上面的例子传入的是一个具体的数字，那么如果我传入一个Object类型对象呢？答案是它会报java.lang.ClassCastException异常，那么没有办法传入了吗？肯定是有的，这时候就需要我们重写hs里面的排序函数了。

看例子：

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<People> ts = new TreeSet<>();
        ts.add(new People("aa",19));
        ts.add(new People("aa",10));
        ts.add(new People("ee",14));
        ts.add(new People("cc",13));
        ts.add(new People("cc",15));
        for (People t : ts) {
            System.out.println(t);
        }
    }
}

class People implements Comparable {
    private String name;
    private int age;
    public People(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return this.name+"..."+this.age;
    }
    public int compareTo(Object o) {
        People p = (People) o;
        int num = this.name.compareTo(p.name);
        return num == 0 ? this.age - p.age : num;
    }
}

在这里，我用People类要实现Comparable接口，如果我们要实现接口，首要的就是要重写接口里面的方法了。在JAVA的api中是这么写Comparable接口的。

意思就是说commpareTo函数的返回值很重要，如果是一个负整数，那么说明此对象小于指定对象；返回0，说明相等；返回正整数，则说明是大于指定对象的。根据此我们就可以重写符合我们规则的commpareTo函数了，具体也如上面的例子所示。

LinkedHashSet:

在HashSet下面有一个子类LinkedHashSet，它是哈希表和双向链表组合的一个数据存储结构，可以保证元素的插入顺序，示例如下。

public class LinkedHashSetDemo {
	public static void main(String[] args) {
   		Set<String> set = new LinkedHashSet<String>();
		set.add("bbb");
		set.add("aaa");
		set.add("abc");
		set.add("bbc");
   		Iterator it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}
}