java相关知识点
Java集合框架
Java集合框架图
图片来源菜鸟驿站
Java集合主要包括两种类型集合 (都是一些常有的)
-
Collection | 存储一个元素集合
-
List
- ArrayList
- LinkedList
- Vector
- Stack
-
Set
- HashSet
- LinkedHashSet
- TreeSet
-
Queue
-
-
Map | 存储一对<key,value>元素集合
- HashMap
- LinkedHashMap
- TreeMap
Collection之List集合
ArrayList
LinkedList
Vector
Stack
Collection之Set集合
HashSet
LinkedHashSet
TreeSet
撤销:Ctrl/Command + Z
重做:Ctrl/Command + Y
加粗:Ctrl/Command + B
斜体:Ctrl/Command + I
标题:Ctrl/Command + Shift + H
无序列表:Ctrl/Command + Shift + U
有序列表:Ctrl/Command + Shift + O
检查列表:Ctrl/Command + Shift + C
插入代码:Ctrl/Command + Shift + K
插入链接:Ctrl/Command + Shift + L
插入图片:Ctrl/Command + Shift + G
查找:Ctrl/Command + F
替换:Ctrl/Command + G
Map之HashMap
底层实现
jdk1.7之前是 数组+单链表
jdk1.8之后是 数组+单链表+红黑树
图片来源
源码
HashMap 函数定义
HashMap 数据成员
如下都是重要的变量
transient 关键字
序列化过程中,默认情况下,对象中所有的变量都会转换为持久状态,但是有些情况变量在传输过程中是不需要进行持久化,这样你就可以将这些变量声明为transient变量。
什么是序列化?
首先需要了解一下什么是序列化,序列化就是将对象的状态进行持久化,它将对象的状态转换为字节流存储到一个文件当中,通过反序列化将字节文件重新转换为对象。序列化与反序列化主要应用在网络传输或本地持久化存储。需要进行网络传输的对象都需要转换为字节文件,通过实现序列化接口来达到目的。序列化接口就是一个标记接口,他没有任何的方法。
HashMap 4种构造函数
前3种HashMap()构造函数,并没有真正的初始化table,而是将table的大小放进了阈值threshold中,只有在第一次put()时(其实是在第一次putVal(),因为put()里调用的是putVal()),判断table为null,进行扩容时才会真正初始化table。
第4种在第一次putVal()时,进行扩容时才会真正初始化table
HashMap()无参构造
HashMap(int初始容量,float负载因子)
HashMap(int 初始容量)
HashMap(Map)
重要函数分析
tableSizeFor() 函数
hash()函数
put()函数
//会先用hash(key)来计算key的哈希值,用于确定当前的key存放在数组中的下标位置
public V put(K key, V value) {
//调用内部方法putVal
return putVal(hash(key), key, value, false, true);
}
//参数说明:key的hash值、key、value、onlyIfAbsent(为true,不可修改已经存在的值,所以为false)、evict(可忽略)
//evict只有在方法 afterNodeInsertion(boolean evict) { }用到,可以看到它是一个空实现,因此不用关注这个参数
//该方法在找到相等节点时,直接覆盖掉旧值,返回旧值的value;没有找到相等节点,则插入新节点,返回null
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断table是否为空,如果为空,先调用扩容resize()
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(n - 1) & hash 计算映射到数组的下标值,判断该位置是否为空,
// 如果为空的话,将key和value包装成Node节点,直接添加到该位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//该位置不为空时,即存在元素,分为3种情况
else {
Node<K,V> e; K k;
//1.如果该位置存在的元素的key的hash和hash相等 并且key也相等,把p赋给e,转到@
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//程序到这,说明存在的第一个元素和key不相等
//2.存在元素是红黑树结构,则把他加入到红黑树
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//3.存在的元素是单链表结构,尾插法插入到链表尾部
else {
for (int binCount = 0; ; ++binCount) {
//如果头结点下一个节点是空,即到达链表尾部,则插入到该节点,插入成功后,跳转到@
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插入过程,链表长度超过8,则转为红黑树,直接跳出转到@
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//若在链表中找到了相同key的话,直接退出循环,跳转到@处
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//向链表尾部移动p->p.next
p = e;
}
}
//@ 此时e的来源有两个
// 1.说明发生碰撞时,e代表是旧值,因此元素位置不变,但是需要替换为新值
// 2.e是在红黑树或单链表中插入成功后的新节点
//e != null,e是在桶中找到的key、hash值与插入元素相等的节点
if (e != null) { // existing mapping for key
//用新值替换旧值,并返回旧值
V oldValue = e.value;
//oldValue为空,有可能旧值本来就是空的,因为hashmap可存空值
if (!onlyIfAbsent || oldValue == null)
//将插入的元素中的value赋给e的value,新值覆盖旧值
e.value = value;
//看方法名字即可知,这是在node被访问之后需要做的操作。其实此处是一个空实现,
//只有在 LinkedHashMap才会实现,用于实现根据访问先后顺序对元素进行排序,hashmap不提供排序功能
afterNodeAccess(e);
//返回旧值
return oldValue;
}
}
//代码走到这,说明没有找到发生碰撞的情况,而是插入新节点到链表或红黑树中,
//增加结构变化次数
++modCount;
//增加实际大小size,判断是否超过阈值,超过则扩容
if (++size > threshold)
resize();
//插入后回调,空实现
afterNodeInsertion(evict);
//新插入节点返回空值
return null;
}
get()函数
//先计算key的hash值,然后调用getNode(hash,key),
//判断节点是否null,如果null返回null;否则,返回value值
//说明:HashMap支持value 为空,前面hash()中对key==null返回0,看出HashMap支持Key为null
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//getNode(hash,key)方法
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//判断table不为空 并且 映射下标位上存在元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//first和key相同时,返回first
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//first和key不相同,遍历单链表或红黑树
if ((e = first.next) != null) {
//如果是红黑树结构,则找到当前key所在的节点位置,并返回
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果是链表,遍历链表找到key所在的节点位置,并返回
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
//否则没有找到,返回null
return null;
}
resize()函数
//扩容函数
//由putVal()可知,当哈希表为空时 或 哈希表实际大小size>threshold时,会调用扩容函数
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//旧表为空时,旧容量=0;旧表非空时,旧容量=旧表的大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧阈值 =当前对象的阈值
int oldThr = threshold;
//初始化新表的容量和阈值
int newCap, newThr = 0;
//分3种情况
//1.oldCap > 0,说明旧表非空,也能看出不是第一次使用扩容函数,即不是初始化时调用的该函数,而是真正扩容时调用的
//为什么说他不是第一次使用扩容函数呢?初始化HashMap时,调用tableSizeFor来初始化threshold,原本tableSizeFor返回值
//是表的容量值,但是却赋给了阈值,没有看到赋给capacity,并且也没有这个容量参数,这是刚开始你我的疑惑,那么到这里这个疑惑就将解除了!!
if (oldCap > 0) {
//如果旧的容量已经是最大值,则没法在扩容,直接返回旧表
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//新表的容量和阈值都扩大到原来的两倍,跳到***
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//2.到这里,说明 oldCap <= 0,并且oldThr(threshold) > 0,这就是HashMap利用后3种有参构造函数初始化时候,第一次调用resize()
//而旧阈值等于threshold,threshold是通过调用tableSizeFor得到的,是2^n(例如16),
//也就是我们要把threshold里装的原本table容量的大小赋给新表的容量,即新容量,
//此时newThr也应该更新为 newCap*loadFactor 啊,但现在不做改变,在@处做改变
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//3.到这里,说明oldCap <= 0,并且oldThr(threshold) <= 0,这是HashMap利用第一种无参构造函数初始化时候,第一次调用resize()
//此时,新容量是默认的16,新阈值是默认的16*0.75=12
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//@这里处理第2种情况,刚才不是没有更新新的阈值,现在更新
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//更新阈值threshold,下次进行扩容时会用到,此时threshold从容量16变成16*0.75=12
threshold = newThr;
//*** 至此,处理好扩容后的新容量和新阈值,接下来是利用新容量来开辟新表
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//判断原来的数组不为空,那么我们需要把旧表中的元素重新分配到新表中来
//如果是第2、3种情况,第一次调用resize(),此时旧表肯定是空的,没有值,也就不需要处理元素
if (oldTab != null) {
//遍历旧表
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//取到当前j下标的第一个元素,如果元素存在赋给e,则分3种情况进行重分配
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//1.如果e的下一个为空,说明此桶只有一个元素e,则直接利用e的hash与新数组大小取模,放到新数组中的对应下标中
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//2.如果e是红黑树,则拆分红黑树,必要时有可能退化为链表
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//3.到这里,说明是e一个单链表结构,判断当前位置的链表是否需要移动到新位置
//其实就是按照某个规则,将一个链表拆分成两个链表,一个原链表放在原位,一个新链表放在新的位置
else { // preserve order
//初始化原链表的头结点和尾结点
Node<K,V> loHead = null, loTail = null;
//初始化新链表的头结点和尾结点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//进行拆分,两个情况,采用尾插法
//1.如果当前元素e的hash值(=e.key的hash值)和oldCap做与运算为0,则原位置不变
//下标值不变有两种情况
//假设1:oldCap=16,newCap=32,0<=e.hash<=16,下标值不变
//假设2:oldCap=16,newCap=32,32<e.hash,下标值不变
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//2.否则,改变原位置
//下标值改变有1种情况
//假设1:oldCap=16,newCap=32,16<e.hash<32,下标值改变
//e.hash=21,oldCap=16,oldIndex=21&15=5,
//newCap=32,newIndex=21&31=21,因为21&16!=0,所以oldIndex!=newIndex,位置改变5->21=5+15
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//插入拆分的两个链表
//当前原链表尾部结点不为空,置为null,并把该链表头结点放到原位置[j]
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//当前新链表尾部结点不为空,置为null,并把该链表头结点放到新位置[j+oldCap]
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回新表
return newTab;
}
其他常用函数
size()函数
public int size() {
return size;
}
isEmpty()函数
public boolean isEmpty() {
return size == 0;
}
containsKey()函数
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
containsValue()函数
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}
remove()函数
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
clear()函数
public void clear() {
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
getOrDefault()函数
@Override
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
Map之LinkedHashMap
强调文本 强调文本
加粗文本 加粗文本
标记文本
删除文本
引用文本
H2O is是液体。
210 运算结果是 1024.
Map之TreeMap
链接: link.
图片:
带尺寸的图片:
居中的图片:
居中并且带尺寸的图片:
当然,我们为了让用户更加便捷,我们增加了图片拖拽功能。
面试必考知识点
去博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示同样高亮的 代码片
.
// An highlighted block
var foo = 'bar';
生成一个适合你的列表
- 项目
- 项目
- 项目
- 项目
- 项目1
- 项目2
- 项目3
- 计划任务
- 完成任务
创建一个表格
一个简单的表格是这么创建的:
项目 | Value |
---|---|
电脑 | $1600 |
手机 | $12 |
导管 | $1 |
设定内容居中、居左、居右
使用:---------:
居中
使用:----------
居左
使用----------:
居右
第一列 | 第二列 | 第三列 |
---|---|---|
第一列文本居中 | 第二列文本居右 | 第三列文本居左 |
SmartyPants
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如:
TYPE | ASCII | HTML |
---|---|---|
Single backticks | 'Isn't this fun?' | ‘Isn’t this fun?’ |
Quotes | "Isn't this fun?" | “Isn’t this fun?” |
Dashes | -- is en-dash, --- is em-dash | – is en-dash, — is em-dash |
创建一个自定义列表
-
Markdown
- Text-to- HTML conversion tool Authors
- John
- Luke
如何创建一个注脚
一个具有注脚的文本。1
注释也是必不可少的
Markdown将文本转换为 HTML。
KaTeX数学公式
您可以使用渲染LaTeX数学表达式 KaTeX:
Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N 是通过欧拉积分
Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt.
你可以找到更多关于的信息 LaTeX 数学表达式here.
新的甘特图功能,丰富你的文章
- 关于 甘特图 语法,参考 这儿,
UML 图表
可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图:
这将产生一个流程图。:
- 关于 Mermaid 语法,参考 这儿,
FLowchart流程图
我们依旧会支持flowchart的流程图:
- 关于 Flowchart流程图 语法,参考 这儿.
导出与导入
导出
如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ,生成一个.md文件或者.html文件进行本地保存。
导入
如果你想加载一篇你写过的.md文件,在上方工具栏可以选择导入功能进行对应扩展名的文件导入,
继续你的创作。
注脚的解释 ↩︎