ps:本人小菜一枚，所以本文是自我学习后的一篇总结，大虾请您飘过
Set类概述
Set是最简单的集合，集合中的对象不按照特定的方式排序，并且没有重复的对象。
Set集合里多个对象之间没有明显的顺序，基本与Collection方法相同。只是行为不同（Set不允许包含重复元素）。
HashSet
HashSet按Hash算法来存储集合的元素，因此具有很好的存取和查找性能。
特点：
HashSet不是同步的，多个线程访问是需要通过代码保证同步
集合元素值可以使null。
注意：HashSet存储自定义对象必须重写hashCode()和equals()方法
重写hashCode基本的指导：
1.初始化一个整形变量，为此变量赋予一个非零的常数值，比如下文：int result = 1;
2.为对象内每个有意义的域f(即每个可以做equals()操作的域)计算出一个int散列码c
boolean c=(f?0:1) byte,char,short,int c=(int)f long c=(int)(f^(f>>>32)) float c=Float.floatToIntBits(f) double c=Double.doubleToLongBits(f) 若结果为long类型则用上述规则处理long得到int Object c=f.hashCode() 数组 对每个元素应用上述规则
3.合并计算得到散列码：
result = 31 * result + c;
4.返回 result
5.检查hashCode() 最后生成的结果，确保相同的对象有相同的散列码
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/*
* 为什么选择31?
* 1,31是一个质数,质数是能被1和自己本身整除的数,减少了相乘出现同值的情况
* 2,31这个数既不大也不小
* 3,31这个数好算,2的五次方-1,2向左移动5位
*/
@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 == null)//传入的对象为null
return false;
if (getClass() != obj.getClass())//判断两个对象对应的字节码文件是否是同一个字节码
return false;
Person other = (Person) obj;
if (age != other.age)//以下比较对象的域
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
测试类：
public static void main(String[] args) {
HashSet<Person> hashSet = new HashSet<>();
hashSet.add(new Person("张三", 23));
hashSet.add(new Person("张三", 23));
hashSet.add(new Person("李四", 24));
hashSet.add(new Person("李四", 23));
hashSet.add(new Person("王五", 25));
hashSet.add(new Person("赵六", 25));
for (Person person : hashSet) {
System.out.println(person);
}
}
结果
Person [name=赵六, age=25] Person [name=张三, age=23] Person [name=李四, age=24] Person [name=李四, age=23] Person [name=王五, age=25]
看到了吧，上面的结果是不是去除了重复，而且是无序的
HashSet如何保证元素的唯一性呢？
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable{
private transient HashMap<E,Object> map;
private static final Object PRESENT = new Object();
public HashSet() {
map = new HashMap<>();
}
public Iterator<E> iterator() {
return map.keySet().iterator();
}
public int size() {
return map.size();
}
public boolean isEmpty() {
return map.isEmpty();
}
public boolean contains(Object o) {
return map.containsKey(o);
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public boolean remove(Object o) {
return map.remove(o)==PRESENT;
}
public void clear() {
map.clear();
}
}
看其源码(JDK1.8)可知，其底层依靠的是HashMap,由于未涉及到HashMap,便对其原理做简单概述，后面会详细介绍
使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
当存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
如果没有哈希值相同的对象就直接存入集合
如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存
自定义类的对象存入HashSet去重复
类中必须重写hashCode()和equals()方法
hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)
equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储
LinkedHashSet
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, java.io.Serializable{
HashSet(int initialCapacity, float loadFactor, boolean dummy) {
map = new LinkedHashMap<>(initialCapacity, loadFactor);
}
}
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, java.io.Serializable {
public LinkedHashSet() {
super(16, .75f, true);
}
}
看其源码(JDK1.8)可知，其底层依靠的是LinkedHashMap，然而LinkedHashMap也是继承于HashMap的，所以归根结底他还是依赖HashMap
看其名字便可知，其与HashSet的不同之处是，他是有序的，所以他可以保证怎么存就怎么取
在其LinkedHashMap维持了一个双向链表
transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
linkNodeLast(p);
return p;
}
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
tail = p;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
}
简单使用
public static void main(String[] args) {
LinkedHashSet<Person> Set = new LinkedHashSet<>();
Set.add(new Person("张三", 23));
Set.add(new Person("张三", 23));
Set.add(new Person("李四", 24));
Set.add(new Person("李四", 23));
Set.add(new Person("王五", 25));
Set.add(new Person("赵六", 25));
for (Person person : Set) {
System.out.println(person);
}
}
结果
Person [name=张三, age=23] Person [name=李四, age=24] Person [name=李四, age=23] Person [name=王五, age=25] Person [name=赵六, age=25]
和上面的HashSet的结果比较，是不是存入的顺序与取出的顺序一致了
TreeSet
TreeSet是SortedSet接口的唯一实现，TreeSet可以确保集合元素处于排序状态（元素是有序的）。
TreeSet提供的几个额外方法：
Comparator comparttor()： 返回当前Set使用的Compara投入，或者返回null，表示以自然方式排序。 Object first()：返回集合中的第一个元素。 Object last()：返回集合中的最后一个元素。 Objiect lower(Object e)：返回集合中位于指定元素之前的元素（即小于指定元素的最大元素，参考元素可以不是TreeSet的元素）。 Object higher(Object e)：返回集合中位于指定元素之后的元素（即大于指定元素的最小元素，参考元素可以不需要TreeSet的元素）。 SortedSet subSet(fromElement， toElement)：返回此Set的子集，范围从fromElement(包含大于等于）到toElement(不包含小于）。 SortedSet headSet(toElement)：返回此Set的子集，由小于toElement的元素组成。 SortedSet tailSet(fromElement)：返回此Set的子集，由大于或等于fromElement的元素组成。
来简单使用下：
public static void main(String[] args) {
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("efg");
treeSet.add("abc");
treeSet.add("abd");
treeSet.add("abc");
treeSet.add("bcd");
treeSet.add("cde");
System.out.println(treeSet);
}
//outPut:[abc, abd, bcd, cde, efg]
看其结果既去除了重复，又进行了自然排序
使用自定义类会如何？
public static void main(String[] args) {
TreeSet<Person> treeSet = new TreeSet<>();
treeSet.add(new Person("张三", 23));
treeSet.add(new Person("张三", 23));
treeSet.add(new Person("李四", 23));
}
//Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to java.lang.Comparable
很遗憾，报错了，Person这个类不能转化为Comparable
我们看下String类的声明：
public final class Stringextends Objectimplements Serializable, Comparable<String>, CharSequence
我们看到了String这个类实现了Comparable这个接口，查看API可得，此接口强行对实现它的每个类的对象进行整体排序，这意味着我们的Person类必须实现其Comparable接口吗？
答案当然是不一定的，查看TreeSet的API
public TreeSet(Comparator<? super E> comparator)
在其构造方法内可以传入一个比较器：Comparator
大家可能会混淆了Comparator和Comparable，先来看看代码的实现(以年龄排序从大到小排序，年龄相同比较姓名自然排序)
先来Comparator,在构造器内传入我们的比较器
public static void main(String[] args) {
TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
@Override//匿名内部类，在其内部实现其如何比较
public int compare(Person per1, Person per2) {
int num = per2.getAge() - per1.getAge();
return num == 0 ? per1.getName().compareTo(per2.getName()) : num;
}
});
treeSet.add(new Person("张三", 23));
treeSet.add(new Person("张三", 23));
treeSet.add(new Person("李四", 24));
treeSet.add(new Person("李四", 23));
treeSet.add(new Person("王五", 25));
treeSet.add(new Person("赵六", 25));
for (Person person : treeSet) {
System.out.println(person);
}
}
结果
Person [name=王五, age=25] Person [name=赵六, age=25] Person [name=李四, age=24] Person [name=张三, age=23] Person [name=李四, age=23]
你可能对中文的字符的排序有疑问，你可以将其替换为英文字符串，或者看其下面代码，你就知道了如何比较
System.out.println("王："+('王'+0));//char字符对应的Unicode码表值
System.out.println("赵："+('赵'+0));
//王：29579
//赵：36213
再来看看Comparable实现：
改造我们的Person
class Person implements Comparable<Person> {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Person per) {
//这部分代码是和Comparator.compare方法中内容是一样的
int num = per.getAge() - this.getAge();
return num == 0 ? getName().compareTo(per.getName()) : num;
}
}
测试：
public static void main(String[] args) {
TreeSet<Person> treeSet = new TreeSet<>();
treeSet.add(new Person("张三", 23));
treeSet.add(new Person("张三", 23));
treeSet.add(new Person("李四", 24));
treeSet.add(new Person("李四", 23));
treeSet.add(new Person("王五", 25));
treeSet.add(new Person("赵六", 25));
for (Person person : treeSet) {
System.out.println(person);
}
}
可以想象，这个结果和上面代码的结果是一样的。通俗点的方式说Comparable是将比较的代码写在了自己的内部，而Comparator需单独定义一个类对其进行比较。
Comparable & Comparator
Comparator位于包java.util下，而Comparable位于包 java.lang下
都是用来实现集合中元素的比较、排序的，只是 Comparable 是在集合内部定义的方法实现的排序，Comparator 是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义 Comparator 接口的方法或在集合内实现 Comparable 接口的方法。
两种方法各有优劣, 用Comparable 简单, 只要实现Comparable 接口的对象直接就成为一个可以比较的对象,但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义的对象需要作比较的时候,把比较器和对象一起传递过去就可以比大小了, 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。
两种比较小结一下
a.自然顺序(Comparable)
TreeSet类的add()方法中会把存入的对象提升为Comparable类型
调用对象的compareTo()方法和集合中的对象比较
根据compareTo()方法返回的结果进行存储
b.比较器顺序(Comparator)
创建TreeSet的时候可以制定 一个Comparator
如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
add()方法内部会自动调用Comparator接口中compare()方法排序
调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
两种方式的区别
TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)
TreeSet如果传入Comparator, 就优先按照Comparator
TreeSet其底层依靠的是TreeMap，其内部维护着一颗二叉排序树，之后会详细讲解
public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable{
private transient NavigableMap<E,Object> m; //TreeMap实现的接口
private static final Object PRESENT = new Object();
public TreeSet() {
this(new TreeMap<E,Object>());
}
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
public int size() {
return m.size();
}
public boolean isEmpty() {
return m.isEmpty();
}
public boolean contains(Object o) {
return m.containsKey(o);
}
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
public boolean remove(Object o) {
return m.remove(o)==PRESENT;
}
public void clear() {
m.clear();
}
}
对List和Set迭代进行一下总结
List
a.普通for循环, 使用get()逐个获取
b.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
c.增强for循环, 只要可以使用Iterator的类都可以用
d.Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法
Set
a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
b.增强for循环, 只要可以使用Iterator的类都可以用