当年面试问的最多的那批 Java 集合框架现在问的还多么? 编程十年(手动狗头) , 我把这些集合框架做成盲盒, 无论你多难, 我都想去了解你, 今天来看-----pia~,HashSet , 基于哈希表实现,存储唯一元素,无序。适用于快速查找、去重操作。常用于集合操作、数据唯一性校验。
一. Set
Set 与 Map 主要的不同有两点:Set 是继承自 Collection 的接口类,Set 中只存储了 Key 。
常见方法说明
注意:
- Set 是继承自 Collection 的一个接口类
- Set 中只存储了 key,并且要求 key 一定要唯一
- TreeSet 的底层是使用 Map 来实现的,其使用 key 与 Object 的一个默认对象作为键值对插入到 Map 中的
- Set 最大的功能就是对集合中的元素进行去重
- 实现 Set 接口的常用类有 TreeSet 和 HashSet ,还有一个 LinkedHashSet ,LinkedHashSet 是在 HashSet 的基础上维护了一个双向链表来记录元素的插入次序。
- Set 中的 Key 不能修改,如果要修改,先将原来的删除掉,然后再重新插入
- TreeSet 中不能插入 null 的 key ,HashSet 可以, 因为 TreeSet 中的 key 需要进行比较, 而 HashSet 中的 key 不需要
- TreeSet 和 HashSet 的区别
二. HashSet
1. HashSet 部分源码
属性:
private transient HashMap<E,Object> map;
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
构造函数:
public HashSet() {
map = new HashMap<>();
}
/**
* Constructs a new set containing the elements in the specified
* collection. The <tt>HashMap</tt> is created with default load factor
* (0.75) and an initial capacity sufficient to contain the elements in
* the specified collection.
*
* @param c the collection whose elements are to be placed into this set
* @throws NullPointerException if the specified collection is null
*/
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* the specified initial capacity and the specified load factor.
*
* @param initialCapacity the initial capacity of the hash map
* @param loadFactor the load factor of the hash map
* @throws IllegalArgumentException if the initial capacity is less
* than zero, or if the load factor is nonpositive
*/
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
/**
* Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
* the specified initial capacity and default load factor (0.75).
*
* @param initialCapacity the initial capacity of the hash table
* @throws IllegalArgumentException if the initial capacity is less
* than zero
*/
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
由这几个构造函数就可以看出, HashSet 的底层还是 HashMap
(所以想要了解 HashMap 和 哈希表 的话可以自取 HashMap、哈希表)
从图中可以看出 HashSet 只是利用了 HashMap 的 key, 而 value 的话是放进去一个统一固定的值。
2. HashSet 的使用
HashSet 的常用方法便是从 Set 实现的那几个常用方法
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("abc");
list.add("xyz");
list.add("uvw");
Set<String> hashSet = new HashSet<>();
// 放置元素
hashSet.add("hello");
hashSet.add("abc");
hashSet.add("the");
hashSet.add("world");
System.out.println(hashSet);
// 将一个集合中的元素全部加入到 set 中
hashSet.addAll(list);
System.out.println(hashSet);
// 判断 key 值是否存在
System.out.println(hashSet.contains("hello"));
System.out.println(hashSet.contains("hello2"));
// 删除元素
hashSet.remove("world");
String[] arr = new String[7];
// set 转数组
hashSet.toArray(arr);
for (String s : arr) {
System.out.print(s + " ");
}
}
三. TreeSet
1. 部分源码
/**
* Constructs a new, empty tree set, sorted according to the
* natural ordering of its elements. All elements inserted into
* the set must implement the {@link Comparable} interface.
* Furthermore, all such elements must be <i>mutually
* comparable</i>: {@code e1.compareTo(e2)} must not throw a
* {@code ClassCastException} for any elements {@code e1} and
* {@code e2} in the set. If the user attempts to add an element
* to the set that violates this constraint (for example, the user
* attempts to add a string element to a set whose elements are
* integers), the {@code add} call will throw a
* {@code ClassCastException}.
*/
public TreeSet() {
this(new TreeMap<E,Object>());
}
/**
* Constructs a new, empty tree set, sorted according to the specified
* comparator. All elements inserted into the set must be <i>mutually
* comparable</i> by the specified comparator: {@code comparator.compare(e1,
* e2)} must not throw a {@code ClassCastException} for any elements
* {@code e1} and {@code e2} in the set. If the user attempts to add
* an element to the set that violates this constraint, the
* {@code add} call will throw a {@code ClassCastException}.
*
* @param comparator the comparator that will be used to order this set.
* If {@code null}, the {@linkplain Comparable natural
* ordering} of the elements will be used.
*/
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
/**
* Constructs a new tree set containing the elements in the specified
* collection, sorted according to the <i>natural ordering</i> of its
* elements. All elements inserted into the set must implement the
* {@link Comparable} interface. Furthermore, all such elements must be
* <i>mutually comparable</i>: {@code e1.compareTo(e2)} must not throw a
* {@code ClassCastException} for any elements {@code e1} and
* {@code e2} in the set.
*
* @param c collection whose elements will comprise the new set
* @throws ClassCastException if the elements in {@code c} are
* not {@link Comparable}, or are not mutually comparable
* @throws NullPointerException if the specified collection is null
*/
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
/**
* Constructs a new tree set containing the same elements and
* using the same ordering as the specified sorted set.
*
* @param s sorted set whose elements will comprise the new set
* @throws NullPointerException if the specified sorted set is null
*/
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
由源码可以看出 TreeSet 底层是 TreeMap
(想了解 TreeMap 的可以自取 -> TreeMap)
2. TreeSet 使用
TreeSet与 HashSet 使用都差不多, 只不过 TreeSet底层是一颗红黑树(一种特殊的二叉搜索树), 是 关于 key 有序的, 所以存放到 TreeSet 里面的 key 必须是能够比较的。所以如果 key 是自定义类型的话, 需要实现 Comparable 接口, 或者 实现一个比较器。(Comparable、比较器)
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("abc");
list.add("xyz");
list.add("uvw");
Set<String> treeSet = new TreeSet<>();
// 放置元素
treeSet.add("hello");
treeSet.add("abc");
treeSet.add("the");
treeSet.add("world");
System.out.println(treeSet);
// 将一个集合中的元素全部加入到 set 中
treeSet.addAll(list);
System.out.println(treeSet);
// 判断 key 值是否存在
System.out.println(treeSet.contains("hello"));
System.out.println(treeSet.contains("hello2"));
// 删除元素
treeSet.remove("world");
String[] arr = new String[7];
// set 转数组
treeSet.toArray(arr);
for (String s : arr) {
System.out.print(s + " ");
}
}
同样的代码, 只是一个是用 HashSet 存储, 一个用 TreeSet 存储, 遍历的结果便不一样
上图只是简单的画了一下怎么存储(如果画错了请见谅, 因为它底层是红黑树,确实有点复杂, 中间涉及到了旋转 )。
因为它是二叉搜索树, 所以它的中序遍历就是有序的。
好啦,以上就是对 HashSet 的讲解, 希望能帮到你 !
评论区欢迎指正 !