标签：ISE over 大小 循环 选项 iterator 通过 table 重写
public interface Set<E>
extends Collection<E>
不包含重复元素的集合。更正式地，集合不包含一对元素e1和e2 ，使得e1.equals(e2) ，并且最多一个空元素。正如其名称所暗示的那样，这个接口模拟了数学集抽象。
Set接口除了继承自Collection接口的所有构造函数的合同以及add,equals和hashCode方法的合同外 ， 还 增加了其他规定。 其他继承方法的声明也包括在这里以方便。 （伴随这些声明的规范已经量身定做Set接口，但它们不包含任何附加的规定。）
构造函数的额外规定并不奇怪，所有构造函数都必须创建一个不包含重复元素的集合（如上所定义）。
注意：如果可变对象用作设置元素，则必须非常小心。 如果对象的值以影响equals比较的方式更改，而对象是集合中的元素， 则不指定集合的行为。 这种禁止的一个特殊情况是，一个集合不允许将其本身作为一个元素。
一些集合实现对它们可能包含的元素有限制。 例如，一些实现禁止空元素，有些实现对元素的类型有限制。 尝试添加不合格元素会引发未经检查的异常，通常为NullPointerException或ClassCastException 。 尝试查询不合格元素的存在可能会引发异常，或者可能只是返回false; 一些实现将展现出前者的行为，一些实现将展现出后者。 更一般来说，尝试对不符合条件的元素的操作，其完成不会导致不合格元素插入到集合中，可能会导致异常，或者可能会成功执行该选项。 此异常在此接口的规范中标记为“可选”。
Set接口特点:
1、不允许存储重复的元素。
2、没有索引，没有带索引的方法，也不能使用普通的for循环遍历。
方法与collecion一致。
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, Serializable
此类实现Set接口，由哈希表（实际为HashMap实例）支持。对集合的迭代次序不作任何保证;特别是，它不能保证订单在一段时间内保持不变。这个类允许null元素。
这个类提供了基本操作（add，remove，contains和size）固定的时间性能，假定哈希函数将分散的桶中正确的元素。 迭代此集合需要与HashSet实例的大小（元素数量）和后台HashMap实例（桶数）的“容量”的总和成比例的时间。 因此，如果迭代性能很重要，不要将初始容量设置得太高（或负载因子太低）是非常重要的。
请注意，此实现不同步。 如果多个线程并发访问哈希集，并且至少有一个线程修改该集合，那么它必须在外部进行同步。 这通常通过在自然地封装集合的一些对象上进行同步来实现。 如果没有这样的对象存在，那么该集合应该使用Collections.synchronizedSet方法“包装”。 这最好在创建时完成，以防止对该集合的意外不同步访问：
Set s = Collections.synchronizedSet(new HashSet(...));
该类iterator方法返回的迭代器是故障快速的 ：如果集合在迭代器创建之后的任何时间被修改，除了通过迭代器自己的remove方法之外，迭代器会抛出一个ConcurrentModificationException 。 因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来未确定的时间冒着任意的非确定性行为。
请注意，迭代器的故障快速行为无法保证，因为一般来说，在不同步并发修改的情况下，无法做出任何硬性保证。 失败快速迭代器尽力投入ConcurrentModificationException 。 因此，编写依赖于此异常的程序的正确性将是错误的：迭代器的故障快速行为应仅用于检测错误。
boolean | add(E e) 将指定的元素添加到此集合（如果尚未存在）。 |
|---|---|
void |
clear() 从此集合中删除所有元素。 |
Object |
clone() 返回此 HashSet实例的浅层副本：元素本身不被克隆。 |
boolean |
contains(Object o) 如果此集合包含指定的元素，则返回 true 。 |
boolean |
isEmpty() 如果此集合不包含元素，则返回 true 。 |
Iterator |
iterator() 返回此集合中元素的迭代器。 |
boolean |
remove(Object o) 如果存在，则从该集合中删除指定的元素。 |
int |
size() 返回此集合中的元素数（其基数）。 |
Spliterator |
spliterator() 在此集合中的元素上创建late-binding和故障快速 Spliterator 。 |
HashSet接口特点:
1、不允许存储重复的元素。
2、没有索引，没有带索引的方法，也不能使用普通的for循环遍历。
3、是一个无序的集合，存储元素和取出元素的顺序有可能不一致。
4、底层是一个哈希表结构（查询速度非常快）。
public class MyHashSet {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
set.add(1);//是否存储？
Iterator<Integer> it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
System.out.println("---------------------");
for (Integer integer : set) {
System.out.println(integer);
}
}
}
运行结果：
1
2
3
---------------------
1
2
3
HashSet存储自定义类型元素：重写hashcode和equals方法
public class Person {
private String name;
private Integer age;
?
public Person() {
}
?
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
?
public String getName() {
return name;
}
?
public void setName(String name) {
this.name = name;
}
?
public Integer getAge() {
return age;
}
?
public void setAge(Integer age) {
this.age = age;
}
?
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Person person = (Person) o;
return Objects.equals(name, person.name) &&
Objects.equals(age, person.age);
}
?
@Override
public int hashCode() {
return Objects.hash(name, age);
}
?
@Override
public String toString() {
return "Person{" +
"name=‘" + name + ‘\‘‘ +
", age=" + age +
‘}‘;
}
}
//创建hashset集合存储person
HashSet<Person> hashSet = new HashSet<Person>();
Person p1 = new Person("haha", 18);
Person p2 = new Person("haha", 18);
Person p3 = new Person("haohoa", 19);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
System.out.println(p1.equals(p2));
hashSet.add(p1);
hashSet.add(p2);
hashSet.add(p3);
for (Person person : hashSet) {
System.out.println(person);
}
?
Iterator<Person> iterator = hashSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
运行结果：
99039841
99039841
true
Person{name=‘haha‘, age=18}
Person{name=‘haohoa‘, age=19}
Person{name=‘haha‘, age=18}
Person{name=‘haohoa‘, age=19}
public class LinkedHashSet<E>
extends HashSet<E>
implements Set<E>, Cloneable, Serializable
底层是一个哈希表（数组 + 链表/红黑树）+ 链表；多了一条链表（记录元素的存储顺序），保证元素的有序性。
哈希表和链表实现了Set接口，具有可预测的迭代次序。 这种实现不同于HashSet，它维持于所有条目的运行双向链表。 该链表定义了迭代排序，它是将元素插入集合（插入顺序 ） 的顺序 。 请注意，如果一个元件被重新插入到组插入顺序不受影响 。 （元件e重新插入一组s如果当s.contains(e)将返回true之前立即调用s.add(e)被调用。）
此实现可以让客户从提供的指定，通常杂乱无章的排序HashSet ，而不会导致与其相关的成本增加TreeSet 。 它可以用于生成与原始文件具有相同顺序的集合的副本，而不管原始集的实现：
void foo(Set s) {
Set copy = new LinkedHashSet(s);
...
}
如果模块在输入上进行设置，复制它，并且稍后返回其顺序由该副本确定的结果，则此技术特别有用。（客户一般都喜欢以相同的顺序返回事情。）
该类提供了所有可选的Set操作，并允许null元素。 像HashSet，它提供了基本操作（add，contains和remove）稳定的性能，假定散列函数散桶中适当的元件。 性能可能略低于HashSet ，由于维护链表的额外费用，但有一个例外：LinkedHashSet的迭代需要与集合的大小成比例的时间，无论其容量如何。 HashSet的迭代可能更昂贵，需要与其容量成比例的时间。
链接哈希集具有影响其性能的两个参数： 初始容量和负载因子 。 它们的定义精确到HashSet 。 但是请注意，该惩罚为初始容量选择非常高的值是该类比HashSet不太严重的，因为迭代次数对于这个类是由容量不受影响。
请注意，此实现不同步。 如果多个线程同时访问链接的散列集，并且至少有一个线程修改该集合，那么它必须在外部进行同步。 这通常通过在自然地封装集合的一些对象上进行同步来实现。 如果没有这样的对象存在，则应该使用Collections.synchronizedSet方法“包装”。 这最好在创建时完成，以防止对该集合的意外不同步访问：
Set s = Collections.synchronizedSet(new LinkedHashSet(...));
该类iterator方法返回的迭代器是故障快速的 ：如果在创建迭代器之后的任何时间对该集合进行了修改，除了通过迭代器自己的remove方法之外，迭代器将会抛出一个ConcurrentModificationException 。 因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来未确定的时间冒着任意的非确定性行为。
请注意，迭代器的故障快速行为无法保证，因为一般来说，在不同步并发修改的情况下，无法做出任何硬性保证。 失败快速迭代器尽力投入ConcurrentModificationException 。 因此，编写依赖于此异常的程序的正确性将是错误的：迭代器的故障快速行为应仅用于检测错误。
标签：ISE over 大小 循环 选项 iterator 通过 table 重写
原文地址：https://www.cnblogs.com/lxy522/p/12822758.html
