注意：本文基于JDK1.8进行记录。

1 HashSet

1.1 简介

不允许重复的元素插入，可以插入null。

底层是HashMap，不能保证插入和输出的顺序一致。

线程不安全。

1.2 扩容机制

同HashMap。

1.3 方法说明

1.3.1 构造方法

 1 // 空参构造器，调用HashMap的构造器。
 2 public HashSet();
 3 // 指定长度的构造器，调用HashMap的构造器。
 4 public HashSet(int initialCapacity);
 5 // 指定长度和负载因子的构造器，调用HashMap的构造器。
 6 public HashSet(int initialCapacity, float loadFactor);
 7 // 传入了一个集合的构造器，调用HashMap的构造器，添加指定集合。
 8 public HashSet(Collection<? extends E> c);
 9 // 指定长度和负载因子的构造器，调用LinkedHashMap的构造器。
10 HashSet(int initialCapacity, float loadFactor, boolean dummy);

1.3.2 常用方法

 1 // 获取个数。
 2 public int size();
 3 // 判断是否为空。
 4 public boolean isEmpty();
 5 // 判断是否包含指定数据。
 6 public boolean contains(Object o);
 7 // 添加元素，并返回是否成功。
 8 public boolean add(E e);
 9 // 删除元素，并返回是否成功。
10 public boolean remove(Object o);
11 // 清除所有元素。
12 public void clear();

1.4 源码分析

1.4.1 属性

1 // 使用HashMap存储数据。
2 private transient HashMap<E,Object> map;
3 // 定义Object对象作为HashMap的value。
4 private static final Object PRESENT = new Object();

1.4.2 构造方法

 1 // 空参构造器，调用HashMap的构造器。
 2 public HashSet() {
 3     map = new HashMap<>();
 4 }
 5 // 指定长度的构造器，调用HashMap的构造器。
 6 public HashSet(int initialCapacity) {
 7     map = new HashMap<>(initialCapacity);
 8 }
 9 // 指定长度和负载因子的构造器，调用HashMap的构造器。
10 public HashSet(int initialCapacity, float loadFactor) {
11     map = new HashMap<>(initialCapacity, loadFactor);
12 }
13 // 传入了一个集合的构造器，调用HashMap的构造器，添加指定集合。
14 public HashSet(Collection<? extends E> c) {
15     map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
16     addAll(c);
17 }
18 // 指定长度和负载因子的构造器，调用LinkedHashMap的构造器。
19 HashSet(int initialCapacity, float loadFactor, boolean dummy) {
20     map = new LinkedHashMap<>(initialCapacity, loadFactor);
21 }

1.4.3 常用方法

 1 // 获取个数。
 2 public int size() {
 3     return map.size();
 4 }
 5 // 判断是否为空。
 6 public boolean isEmpty() {
 7     return map.isEmpty();
 8 }
 9 // 判断是否包含指定数据。
10 public boolean contains(Object o) {
11     return map.containsKey(o);
12 }
13 // 添加元素，并返回是否成功。
14 public boolean add(E e) {
15     return map.put(e, PRESENT)==null;
16 }
17 // 删除元素，并返回是否成功。
18 public boolean remove(Object o) {
19     return map.remove(o)==PRESENT;
20 }
21 // 清除所有元素。
22 public void clear() {
23     map.clear();
24 }

2 LinkedHashSet

2.1 简介

不允许重复的元素插入，可以插入null。

继承自HashSet，底层是LinkedHashMap，维护了数据的插入顺序。

线程不安全。

2.2 扩容机制

同LinkedHashMap。

2.3 方法说明

2.3.1 构造方法

1 // 指定长度和负载因子的构造器，调用HashSet的构造器。
2 public LinkedHashSet(int initialCapacity, float loadFactor);
3 // 指定长度的构造器，调用HashSet的构造器。
4 public LinkedHashSet(int initialCapacity);
5 // 空参构造器，调用HashSet的构造器。
6 public LinkedHashSet();
7 // 传入了一个集合的构造器，调用HashSet的构造器，添加指定集合。
8 public LinkedHashSet(Collection<? extends E> c);

2.3.2 常用方法

同HashSet。

2.4 源码分析

2.4.1 属性

同HashSet。

2.4.2 构造方法

 1 // 指定长度和负载因子的构造器，调用HashSet的构造器。
 2 public LinkedHashSet(int initialCapacity, float loadFactor) {
 3     super(initialCapacity, loadFactor, true);
 4 }
 5 // 指定长度的构造器，调用HashSet的构造器。
 6 public LinkedHashSet(int initialCapacity) {
 7     super(initialCapacity, .75f, true);
 8 }
 9 // 空参构造器，调用HashSet的构造器。
10 public LinkedHashSet() {
11     super(16, .75f, true);
12 }
13 // 传入了一个集合的构造器，调用HashSet的构造器，添加指定集合。
14 public LinkedHashSet(Collection<? extends E> c) {
15     super(Math.max(2*c.size(), 11), .75f, true);
16     addAll(c);
17 }

2.4.3 常用方法

同HashSet。

3 TreeSet

3.1 简介

不允许重复的元素插入，不可以插入null。

底层TreeMap，使用二叉树结构存储数据，支持自然排序和定制排序。

线程不安全。

3.2 扩容机制

同TreeMap。

3.3 方法说明

3.3.1 构造方法

 1 // 指定NavigableMap的构造器。
 2 TreeSet(NavigableMap<E,Object> m);
 3 // 空参构造器，调用TreeMap的构造器。
 4 public TreeSet();
 5 // 指定比较器的构造器，调用TreeMap的构造器。
 6 public TreeSet(Comparator<? super E> comparator);
 7 // 传入了一个集合的构造器，调用空参的构造器，添加指定集合。
 8 public TreeSet(Collection<? extends E> c);
 9 // 传入了一个有序集合的构造器，调用指定比较器的构造器，添加指定集合。
10 public TreeSet(SortedSet<E> s);

3.3.2 常用方法

 1 // 获取个数。
 2 public int size();
 3 // 判断是否为空。
 4 public boolean isEmpty();
 5 // 判断是否包含指定数据。
 6 public boolean contains(Object o);
 7 // 添加元素，并返回是否成功。
 8 public boolean add(E e);
 9 // 删除元素，并返回是否成功。
10 public boolean remove(Object o);
11 // 清除所有元素。
12 public void clear();

3.4 源码分析

3.4.1 属性

1 // 使用NavigableMap存储数据。
2 private transient NavigableMap<E,Object> m;
3 // 定义Object对象作为NavigableMap的value。
4 private static final Object PRESENT = new Object();

3.4.2 构造方法

 1 // 指定NavigableMap的构造器。
 2 TreeSet(NavigableMap<E,Object> m) {
 3     this.m = m;
 4 }
 5 // 空参构造器，调用TreeMap的构造器。
 6 public TreeSet() {
 7     this(new TreeMap<E,Object>());
 8 }
 9 // 指定比较器的构造器，调用TreeMap的构造器。
10 public TreeSet(Comparator<? super E> comparator) {
11     this(new TreeMap<>(comparator));
12 }
13 // 传入了一个集合的构造器，调用空参的构造器，添加指定集合。
14 public TreeSet(Collection<? extends E> c) {
15     this();
16     addAll(c);
17 }
18 // 传入了一个有序集合的构造器，调用指定比较器的构造器，添加指定集合。
19 public TreeSet(SortedSet<E> s) {
20     this(s.comparator());
21     addAll(s);
22 }

3.4.3 常用方法

 1 // 获取个数。
 2 public int size() {
 3     return m.size();
 4 }
 5 // 判断是否为空。
 6 public boolean isEmpty() {
 7     return m.isEmpty();
 8 }
 9 // 判断是否包含指定数据。
10 public boolean contains(Object o) {
11     return m.containsKey(o);
12 }
13 // 添加元素，并返回是否成功。
14 public boolean add(E e) {
15     return m.put(e, PRESENT)==null;
16 }
17 // 删除元素，并返回是否成功。
18 public boolean remove(Object o) {
19     return m.remove(o)==PRESENT;
20 }
21 // 清除所有元素。
22 public void clear() {
23     m.clear();
24 }

 

标签：调用,LinkedHashSet,HashMap,HashSet,构造,007Java,boolean,public
来源： https://www.cnblogs.com/zhibiweilai/p/15351385.html