转载请注明出处:http://blog.csdn.net/ns_code/article/details/35787253

 

您好,我正在参加CSDN博文大赛,如果您喜欢我的文章,希望您能帮我投一票,谢谢!

投票地址:http://vote.blog.csdn.net/Article/Details?articleid=35568011

LinkedList简介

LinkedList是基于双向循环链表(从源码中可以很容易看出)实现的,除了可以当做链表来操作外,它还可以当做栈、队列和双端队列来使用。

LinkedList同样是非线程安全的,只在单线程下适合使用。

LinkedList实现了Serializable接口,因此它支持序列化,能够通过序列化传输,实现了Cloneable接口,能被克隆。

LinkedList源码剖析

LinkedList的源码如下(加入了比较详细的注释):

  1. package java.util;
  2. public class LinkedList<E>
  3. extends AbstractSequentialList<E>
  4. implements List<E>, Deque<E>, Cloneable, java.io.Serializable
  5. {
  6. // 链表的表头,表头不包含任何数据。Entry是个链表类数据结构。
  7. private transient Entry<E> header = new Entry<E>(null, null, null);
  8. // LinkedList中元素个数
  9. private transient int size = 0;
  10. // 默认构造函数:创建一个空的链表
  11. public LinkedList() {
  12. header.next = header.previous = header;
  13. }
  14. // 包含“集合”的构造函数:创建一个包含“集合”的LinkedList
  15. public LinkedList(Collection<? extends E> c) {
  16. this();
  17. addAll(c);
  18. }
  19. // 获取LinkedList的第一个元素
  20. public E getFirst() {
  21. if (size==0)
  22. throw new NoSuchElementException();
  23. // 链表的表头header中不包含数据。
  24. // 这里返回header所指下一个节点所包含的数据。
  25. return header.next.element;
  26. }
  27. // 获取LinkedList的最后一个元素
  28. public E getLast()  {
  29. if (size==0)
  30. throw new NoSuchElementException();
  31. // 由于LinkedList是双向链表;而表头header不包含数据。
  32. // 因而,这里返回表头header的前一个节点所包含的数据。
  33. return header.previous.element;
  34. }
  35. // 删除LinkedList的第一个元素
  36. public E removeFirst() {
  37. return remove(header.next);
  38. }
  39. // 删除LinkedList的最后一个元素
  40. public E removeLast() {
  41. return remove(header.previous);
  42. }
  43. // 将元素添加到LinkedList的起始位置
  44. public void addFirst(E e) {
  45. addBefore(e, header.next);
  46. }
  47. // 将元素添加到LinkedList的结束位置
  48. public void addLast(E e) {
  49. addBefore(e, header);
  50. }
  51. // 判断LinkedList是否包含元素(o)
  52. public boolean contains(Object o) {
  53. return indexOf(o) != -1;
  54. }
  55. // 返回LinkedList的大小
  56. public int size() {
  57. return size;
  58. }
  59. // 将元素(E)添加到LinkedList中
  60. public boolean add(E e) {
  61. // 将节点(节点数据是e)添加到表头(header)之前。
  62. // 即,将节点添加到双向链表的末端。
  63. addBefore(e, header);
  64. return true;
  65. }
  66. // 从LinkedList中删除元素(o)
  67. // 从链表开始查找,如存在元素(o)则删除该元素并返回true;
  68. // 否则,返回false。
  69. public boolean remove(Object o) {
  70. if (o==null) {
  71. // 若o为null的删除情况
  72. for (Entry<E> e = header.next; e != header; e = e.next) {
  73. if (e.element==null) {
  74. remove(e);
  75. return true;
  76. }
  77. }
  78. } else {
  79. // 若o不为null的删除情况
  80. for (Entry<E> e = header.next; e != header; e = e.next) {
  81. if (o.equals(e.element)) {
  82. remove(e);
  83. return true;
  84. }
  85. }
  86. }
  87. return false;
  88. }
  89. // 将“集合(c)”添加到LinkedList中。
  90. // 实际上,是从双向链表的末尾开始,将“集合(c)”添加到双向链表中。
  91. public boolean addAll(Collection<? extends E> c) {
  92. return addAll(size, c);
  93. }
  94. // 从双向链表的index开始,将“集合(c)”添加到双向链表中。
  95. public boolean addAll(int index, Collection<? extends E> c) {
  96. if (index < 0 || index > size)
  97. throw new IndexOutOfBoundsException("Index: "+index+
  98. ", Size: "+size);
  99. Object[] a = c.toArray();
  100. // 获取集合的长度
  101. int numNew = a.length;
  102. if (numNew==0)
  103. return false;
  104. modCount++;
  105. // 设置“当前要插入节点的后一个节点”
  106. Entry<E> successor = (index==size ? header : entry(index));
  107. // 设置“当前要插入节点的前一个节点”
  108. Entry<E> predecessor = successor.previous;
  109. // 将集合(c)全部插入双向链表中
  110. for (int i=0; i<numNew; i++) {
  111. Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
  112. predecessor.next = e;
  113. predecessor = e;
  114. }
  115. successor.previous = predecessor;
  116. // 调整LinkedList的实际大小
  117. size += numNew;
  118. return true;
  119. }
  120. // 清空双向链表
  121. public void clear() {
  122. Entry<E> e = header.next;
  123. // 从表头开始,逐个向后遍历;对遍历到的节点执行一下操作:
  124. // (01) 设置前一个节点为null
  125. // (02) 设置当前节点的内容为null
  126. // (03) 设置后一个节点为“新的当前节点”
  127. while (e != header) {
  128. Entry<E> next = e.next;
  129. e.next = e.previous = null;
  130. e.element = null;
  131. e = next;
  132. }
  133. header.next = header.previous = header;
  134. // 设置大小为0
  135. size = 0;
  136. modCount++;
  137. }
  138. // 返回LinkedList指定位置的元素
  139. public E get(int index) {
  140. return entry(index).element;
  141. }
  142. // 设置index位置对应的节点的值为element
  143. public E set(int index, E element) {
  144. Entry<E> e = entry(index);
  145. E oldVal = e.element;
  146. e.element = element;
  147. return oldVal;
  148. }
  149. // 在index前添加节点,且节点的值为element
  150. public void add(int index, E element) {
  151. addBefore(element, (index==size ? header : entry(index)));
  152. }
  153. // 删除index位置的节点
  154. public E remove(int index) {
  155. return remove(entry(index));
  156. }
  157. // 获取双向链表中指定位置的节点
  158. private Entry<E> entry(int index) {
  159. if (index < 0 || index >= size)
  160. throw new IndexOutOfBoundsException("Index: "+index+
  161. ", Size: "+size);
  162. Entry<E> e = header;
  163. // 获取index处的节点。
  164. // 若index < 双向链表长度的1/2,则从前先后查找;
  165. // 否则,从后向前查找。
  166. if (index < (size >> 1)) {
  167. for (int i = 0; i <= index; i++)
  168. e = e.next;
  169. } else {
  170. for (int i = size; i > index; i--)
  171. e = e.previous;
  172. }
  173. return e;
  174. }
  175. // 从前向后查找,返回“值为对象(o)的节点对应的索引”
  176. // 不存在就返回-1
  177. public int indexOf(Object o) {
  178. int index = 0;
  179. if (o==null) {
  180. for (Entry e = header.next; e != header; e = e.next) {
  181. if (e.element==null)
  182. return index;
  183. index++;
  184. }
  185. } else {
  186. for (Entry e = header.next; e != header; e = e.next) {
  187. if (o.equals(e.element))
  188. return index;
  189. index++;
  190. }
  191. }
  192. return -1;
  193. }
  194. // 从后向前查找,返回“值为对象(o)的节点对应的索引”
  195. // 不存在就返回-1
  196. public int lastIndexOf(Object o) {
  197. int index = size;
  198. if (o==null) {
  199. for (Entry e = header.previous; e != header; e = e.previous) {
  200. index--;
  201. if (e.element==null)
  202. return index;
  203. }
  204. } else {
  205. for (Entry e = header.previous; e != header; e = e.previous) {
  206. index--;
  207. if (o.equals(e.element))
  208. return index;
  209. }
  210. }
  211. return -1;
  212. }
  213. // 返回第一个节点
  214. // 若LinkedList的大小为0,则返回null
  215. public E peek() {
  216. if (size==0)
  217. return null;
  218. return getFirst();
  219. }
  220. // 返回第一个节点
  221. // 若LinkedList的大小为0,则抛出异常
  222. public E element() {
  223. return getFirst();
  224. }
  225. // 删除并返回第一个节点
  226. // 若LinkedList的大小为0,则返回null
  227. public E poll() {
  228. if (size==0)
  229. return null;
  230. return removeFirst();
  231. }
  232. // 将e添加双向链表末尾
  233. public boolean offer(E e) {
  234. return add(e);
  235. }
  236. // 将e添加双向链表开头
  237. public boolean offerFirst(E e) {
  238. addFirst(e);
  239. return true;
  240. }
  241. // 将e添加双向链表末尾
  242. public boolean offerLast(E e) {
  243. addLast(e);
  244. return true;
  245. }
  246. // 返回第一个节点
  247. // 若LinkedList的大小为0,则返回null
  248. public E peekFirst() {
  249. if (size==0)
  250. return null;
  251. return getFirst();
  252. }
  253. // 返回最后一个节点
  254. // 若LinkedList的大小为0,则返回null
  255. public E peekLast() {
  256. if (size==0)
  257. return null;
  258. return getLast();
  259. }
  260. // 删除并返回第一个节点
  261. // 若LinkedList的大小为0,则返回null
  262. public E pollFirst() {
  263. if (size==0)
  264. return null;
  265. return removeFirst();
  266. }
  267. // 删除并返回最后一个节点
  268. // 若LinkedList的大小为0,则返回null
  269. public E pollLast() {
  270. if (size==0)
  271. return null;
  272. return removeLast();
  273. }
  274. // 将e插入到双向链表开头
  275. public void push(E e) {
  276. addFirst(e);
  277. }
  278. // 删除并返回第一个节点
  279. public E pop() {
  280. return removeFirst();
  281. }
  282. // 从LinkedList开始向后查找,删除第一个值为元素(o)的节点
  283. // 从链表开始查找,如存在节点的值为元素(o)的节点,则删除该节点
  284. public boolean removeFirstOccurrence(Object o) {
  285. return remove(o);
  286. }
  287. // 从LinkedList末尾向前查找,删除第一个值为元素(o)的节点
  288. // 从链表开始查找,如存在节点的值为元素(o)的节点,则删除该节点
  289. public boolean removeLastOccurrence(Object o) {
  290. if (o==null) {
  291. for (Entry<E> e = header.previous; e != header; e = e.previous) {
  292. if (e.element==null) {
  293. remove(e);
  294. return true;
  295. }
  296. }
  297. } else {
  298. for (Entry<E> e = header.previous; e != header; e = e.previous) {
  299. if (o.equals(e.element)) {
  300. remove(e);
  301. return true;
  302. }
  303. }
  304. }
  305. return false;
  306. }
  307. // 返回“index到末尾的全部节点”对应的ListIterator对象(List迭代器)
  308. public ListIterator<E> listIterator(int index) {
  309. return new ListItr(index);
  310. }
  311. // List迭代器
  312. private class ListItr implements ListIterator<E> {
  313. // 上一次返回的节点
  314. private Entry<E> lastReturned = header;
  315. // 下一个节点
  316. private Entry<E> next;
  317. // 下一个节点对应的索引值
  318. private int nextIndex;
  319. // 期望的改变计数。用来实现fail-fast机制。
  320. private int expectedModCount = modCount;
  321. // 构造函数。
  322. // 从index位置开始进行迭代
  323. ListItr(int index) {
  324. // index的有效性处理
  325. if (index < 0 || index > size)
  326. throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size);
  327. // 若 “index 小于 ‘双向链表长度的一半’”,则从第一个元素开始往后查找;
  328. // 否则,从最后一个元素往前查找。
  329. if (index < (size >> 1)) {
  330. next = header.next;
  331. for (nextIndex=0; nextIndex<index; nextIndex++)
  332. next = next.next;
  333. } else {
  334. next = header;
  335. for (nextIndex=size; nextIndex>index; nextIndex--)
  336. next = next.previous;
  337. }
  338. }
  339. // 是否存在下一个元素
  340. public boolean hasNext() {
  341. // 通过元素索引是否等于“双向链表大小”来判断是否达到最后。
  342. return nextIndex != size;
  343. }
  344. // 获取下一个元素
  345. public E next() {
  346. checkForComodification();
  347. if (nextIndex == size)
  348. throw new NoSuchElementException();
  349. lastReturned = next;
  350. // next指向链表的下一个元素
  351. next = next.next;
  352. nextIndex++;
  353. return lastReturned.element;
  354. }
  355. // 是否存在上一个元素
  356. public boolean hasPrevious() {
  357. // 通过元素索引是否等于0,来判断是否达到开头。
  358. return nextIndex != 0;
  359. }
  360. // 获取上一个元素
  361. public E previous() {
  362. if (nextIndex == 0)
  363. throw new NoSuchElementException();
  364. // next指向链表的上一个元素
  365. lastReturned = next = next.previous;
  366. nextIndex--;
  367. checkForComodification();
  368. return lastReturned.element;
  369. }
  370. // 获取下一个元素的索引
  371. public int nextIndex() {
  372. return nextIndex;
  373. }
  374. // 获取上一个元素的索引
  375. public int previousIndex() {
  376. return nextIndex-1;
  377. }
  378. // 删除当前元素。
  379. // 删除双向链表中的当前节点
  380. public void remove() {
  381. checkForComodification();
  382. Entry<E> lastNext = lastReturned.next;
  383. try {
  384. LinkedList.this.remove(lastReturned);
  385. } catch (NoSuchElementException e) {
  386. throw new IllegalStateException();
  387. }
  388. if (next==lastReturned)
  389. next = lastNext;
  390. else
  391. nextIndex--;
  392. lastReturned = header;
  393. expectedModCount++;
  394. }
  395. // 设置当前节点为e
  396. public void set(E e) {
  397. if (lastReturned == header)
  398. throw new IllegalStateException();
  399. checkForComodification();
  400. lastReturned.element = e;
  401. }
  402. // 将e添加到当前节点的前面
  403. public void add(E e) {
  404. checkForComodification();
  405. lastReturned = header;
  406. addBefore(e, next);
  407. nextIndex++;
  408. expectedModCount++;
  409. }
  410. // 判断 “modCount和expectedModCount是否相等”,依次来实现fail-fast机制。
  411. final void checkForComodification() {
  412. if (modCount != expectedModCount)
  413. throw new ConcurrentModificationException();
  414. }
  415. }
  416. // 双向链表的节点所对应的数据结构。
  417. // 包含3部分:上一节点,下一节点,当前节点值。
  418. private static class Entry<E> {
  419. // 当前节点所包含的值
  420. E element;
  421. // 下一个节点
  422. Entry<E> next;
  423. // 上一个节点
  424. Entry<E> previous;
  425. /**
  426. * 链表节点的构造函数。
  427. * 参数说明:
  428. *   element  —— 节点所包含的数据
  429. *   next      —— 下一个节点
  430. *   previous —— 上一个节点
  431. */
  432. Entry(E element, Entry<E> next, Entry<E> previous) {
  433. this.element = element;
  434. this.next = next;
  435. this.previous = previous;
  436. }
  437. }
  438. // 将节点(节点数据是e)添加到entry节点之前。
  439. private Entry<E> addBefore(E e, Entry<E> entry) {
  440. // 新建节点newEntry,将newEntry插入到节点e之前;并且设置newEntry的数据是e
  441. Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
  442. newEntry.previous.next = newEntry;
  443. newEntry.next.previous = newEntry;
  444. // 修改LinkedList大小
  445. size++;
  446. // 修改LinkedList的修改统计数:用来实现fail-fast机制。
  447. modCount++;
  448. return newEntry;
  449. }
  450. // 将节点从链表中删除
  451. private E remove(Entry<E> e) {
  452. if (e == header)
  453. throw new NoSuchElementException();
  454. E result = e.element;
  455. e.previous.next = e.next;
  456. e.next.previous = e.previous;
  457. e.next = e.previous = null;
  458. e.element = null;
  459. size--;
  460. modCount++;
  461. return result;
  462. }
  463. // 反向迭代器
  464. public Iterator<E> descendingIterator() {
  465. return new DescendingIterator();
  466. }
  467. // 反向迭代器实现类。
  468. private class DescendingIterator implements Iterator {
  469. final ListItr itr = new ListItr(size());
  470. // 反向迭代器是否下一个元素。
  471. // 实际上是判断双向链表的当前节点是否达到开头
  472. public boolean hasNext() {
  473. return itr.hasPrevious();
  474. }
  475. // 反向迭代器获取下一个元素。
  476. // 实际上是获取双向链表的前一个节点
  477. public E next() {
  478. return itr.previous();
  479. }
  480. // 删除当前节点
  481. public void remove() {
  482. itr.remove();
  483. }
  484. }
  485. // 返回LinkedList的Object[]数组
  486. public Object[] toArray() {
  487. // 新建Object[]数组
  488. Object[] result = new Object[size];
  489. int i = 0;
  490. // 将链表中所有节点的数据都添加到Object[]数组中
  491. for (Entry<E> e = header.next; e != header; e = e.next)
  492. result[i++] = e.element;
  493. return result;
  494. }
  495. // 返回LinkedList的模板数组。所谓模板数组,即可以将T设为任意的数据类型
  496. public <T> T[] toArray(T[] a) {
  497. // 若数组a的大小 < LinkedList的元素个数(意味着数组a不能容纳LinkedList中全部元素)
  498. // 则新建一个T[]数组,T[]的大小为LinkedList大小,并将该T[]赋值给a。
  499. if (a.length < size)
  500. a = (T[])java.lang.reflect.Array.newInstance(
  501. a.getClass().getComponentType(), size);
  502. // 将链表中所有节点的数据都添加到数组a中
  503. int i = 0;
  504. Object[] result = a;
  505. for (Entry<E> e = header.next; e != header; e = e.next)
  506. result[i++] = e.element;
  507. if (a.length > size)
  508. a[size] = null;
  509. return a;
  510. }
  511. // 克隆函数。返回LinkedList的克隆对象。
  512. public Object clone() {
  513. LinkedList<E> clone = null;
  514. // 克隆一个LinkedList克隆对象
  515. try {
  516. clone = (LinkedList<E>) super.clone();
  517. } catch (CloneNotSupportedException e) {
  518. throw new InternalError();
  519. }
  520. // 新建LinkedList表头节点
  521. clone.header = new Entry<E>(null, null, null);
  522. clone.header.next = clone.header.previous = clone.header;
  523. clone.size = 0;
  524. clone.modCount = 0;
  525. // 将链表中所有节点的数据都添加到克隆对象中
  526. for (Entry<E> e = header.next; e != header; e = e.next)
  527. clone.add(e.element);
  528. return clone;
  529. }
  530. // java.io.Serializable的写入函数
  531. // 将LinkedList的“容量,所有的元素值”都写入到输出流中
  532. private void writeObject(java.io.ObjectOutputStream s)
  533. throws java.io.IOException {
  534. // Write out any hidden serialization magic
  535. s.defaultWriteObject();
  536. // 写入“容量”
  537. s.writeInt(size);
  538. // 将链表中所有节点的数据都写入到输出流中
  539. for (Entry e = header.next; e != header; e = e.next)
  540. s.writeObject(e.element);
  541. }
  542. // java.io.Serializable的读取函数:根据写入方式反向读出
  543. // 先将LinkedList的“容量”读出,然后将“所有的元素值”读出
  544. private void readObject(java.io.ObjectInputStream s)
  545. throws java.io.IOException, ClassNotFoundException {
  546. // Read in any hidden serialization magic
  547. s.defaultReadObject();
  548. // 从输入流中读取“容量”
  549. int size = s.readInt();
  550. // 新建链表表头节点
  551. header = new Entry<E>(null, null, null);
  552. header.next = header.previous = header;
  553. // 从输入流中将“所有的元素值”并逐个添加到链表中
  554. for (int i=0; i<size; i++)
  555. addBefore((E)s.readObject(), header);
  556. }
  557. }

几点总结

关于LinkedList的源码,给出几点比较重要的总结:

1、从源码中很明显可以看出,LinkedList的实现是基于双向循环链表的,且头结点中不存放数据,如下图;

2、注意两个不同的构造方法。无参构造方法直接建立一个仅包含head节点的空链表,包含Collection的构造方法,先调用无参构造方法建立一个空链表,而后将Collection中的数据加入到链表的尾部后面。

3、在查找和删除某元素时,源码中都划分为该元素为null和不为null两种情况来处理,LinkedList中允许元素为null。

4、LinkedList是基于链表实现的,因此不存在容量不足的问题,所以这里没有扩容的方法。

5、注意源码中的Entry<E> entry(int index)方法。该方法返回双向链表中指定位置处的节点,而链表中是没有下标索引的,要指定位置出的元素,就要遍历该链表,从源码的实现中,我们看到这里有一个加速动作。源码中先将index与长度size的一半比较,如果index<size/2,就只从位置0往后遍历到位置index处,而如果index>size/2,就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历,从而提高一定的效率(实际上效率还是很低)。

6、注意链表类对应的数据结构Entry。如下;

  1. // 双向链表的节点所对应的数据结构。
  2. // 包含3部分:上一节点,下一节点,当前节点值。
  3. private static class Entry<E> {
  4. // 当前节点所包含的值
  5. E element;
  6. // 下一个节点
  7. Entry<E> next;
  8. // 上一个节点
  9. Entry<E> previous;
  10. /**
  11. * 链表节点的构造函数。
  12. * 参数说明:
  13. *   element  —— 节点所包含的数据
  14. *   next      —— 下一个节点
  15. *   previous —— 上一个节点
  16. */
  17. Entry(E element, Entry<E> next, Entry<E> previous) {
  18. this.element = element;
  19. this.next = next;
  20. this.previous = previous;
  21. }
  22. }

7、LinkedList是基于链表实现的,因此插入删除效率高,查找效率低(虽然有一个加速动作)。
    8、要注意源码中还实现了栈和队列的操作方法,因此也可以作为栈、队列和双端队列来使用。

转:【Java集合源码剖析】LinkedList源码剖析的更多相关文章

  1. 【Java集合】试读LinkedList源码

    LinkedList的本质是双向链表.(01) LinkedList继承于AbstractSequentialList,并且实现了Dequeue接口. (02) LinkedList包含两个重要的成员 ...

  2. java集合树状结构及源码

    java集合树状结构及源码 最近一直想看一下java集合的源码,毕竟平时用的比较多,但总是感觉是跟着习惯new出来一个对象,比如ArrayList,HashMap等等,所以就简单的看了一下,了解了一下 ...

  3. Java 集合 JDK1.7的LinkedList

    Java 集合 JDK1.7的LinkedList @author ixenos LinkedList LinkedList是List接口的双向链表实现,JDK1.7以前是双向循环链表,以后是双向非循 ...

  4. Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例

    概要  前面,我们已经学习了ArrayList,并了解了fail-fast机制.这一章我们接着学习List的实现类——LinkedList.和学习ArrayList一样,接下来呢,我们先对Linked ...

  5. 【转】Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例

    概要  前面,我们已经学习了ArrayList,并了解了fail-fast机制.这一章我们接着学习List的实现类——LinkedList.和学习ArrayList一样,接下来呢,我们先对Linked ...

  6. Java集合详解及List源码分析

    对于数组我们应该很熟悉,一个数组在内存中总是一块连续的存储空间,数组的创建使用new关键字,数组是引用类型的数据,一旦第一个元素的位置确定,那么后面的元素位置也就确定了,数组有一个最大的局限就是数组一 ...

  7. Java -- 基于JDK1.8的LinkedList源码分析

    1,上周末我们一起分析了ArrayList的源码并进行了一些总结,因为最近在看Collection这一块的东西,下面的图也是大致的总结了Collection里面重要的接口和类,如果没有意外的话后面基本 ...

  8. Java 集合系列Stack详细介绍(源码解析)和使用示例

    Stack简介 Stack是栈.它的特性是:先进后出(FILO, First In Last Out). java工具包中的Stack是继承于Vector(矢量队列)的,由于Vector是通过数组实现 ...

  9. java集合【13】——— Stack源码分析走一波

    前言 集合源码分析系列:Java集合源码分析 前面已经把Vector,ArrayList,LinkedList分析完了,本来是想开始Map这一块,但是看了下面这个接口设计框架图:整个接口框架关系如下( ...

  10. 1.Java集合-HashMap实现原理及源码分析

    哈希表(Hash  Table)也叫散列表,是一种非常重要的数据结构,应用场景及其丰富,许多缓存技术(比如memcached)的核心其实就是在内存中维护一张大的哈希表,而HashMap的实现原理也常常 ...

随机推荐

  1. NYOJ--86--set.find()--找球号(一)

    /* Name: NYOJ--86--找球号(一) Date: 20/04/17 14:45 Description: 理想很美好,现实很残酷,准备用字符串水过,结果TLE了 ╮(╯▽╰)╭ */ # ...

  2. 基于ubuntu14视觉识别乒乓球_1

    串口通信,opencv3.0 窗口大小可调 编译 cmake ../ make ./color 正常光线下运行比较稳定,找圆比较准确.程序设置了圆的半径区间以及圆心最小间距,以满足产品的需求,可自行修 ...

  3. Mook第八周习题 单词长度(4分)(1)题

    题目内容: 你的程序要读入一行文本,其中以空格分隔为若干个单词,以'.'结束.你要输出这行文本中每个单词的长度.这里的单词与语言无关,可以包括各种符号,比如"it's"算一个单词, ...

  4. NYOJ116 士兵杀敌(二)

    士兵杀敌(二) 时间限制:1000 ms  |  内存限制:65535 KB 难度:5   描述 南将军手下有N个士兵,分别编号1到N,这些士兵的杀敌数都是已知的. 小工是南将军手下的军师,南将军经常 ...

  5. ajax轮询实时获取数据

    最近做一个评论功能时,想要实现实时异步刷新评论功能,于是使用了ajax轮询,这里简单记录一下ajax轮询的原理及使用方法. ajax轮询的原理就是客户端定时向服务端发送ajax请求,服务器接到请求后马 ...

  6. 0711HTML初体验

    今天是正式上课的第一天.这边先记下初学的时候容易忘记的问题.在图片上链接汉子显示是<title="想在图片显示的内容">. 合并单元格,合并行<td colspa ...

  7. 如何用CSS和jQuery实现一个侧滑导航菜单

    为了建立导航菜单,让我们先看看html结构:<!DOCTYPE html><html lang="en"><head> <meta cha ...

  8. C#使用Xamarin开发可移植移动应用(5.进阶篇显示弹出窗口与通讯中心)附源码

    前言 系列目录 C#使用Xamarin开发可移植移动应用目录 源码地址:https://github.com/l2999019/DemoApp 可以Star一下,随意 - - 说点什么.. 没啥好说的 ...

  9. VRTK实现瞬移需要添加的脚本

    进入一个新的公司,boss让实现漫游,但是新公司的Unity版本是5.6,我之前的瞬移插件不好用了,无奈之下找到一个我不熟悉的插件VRTK,但是查了很多资料也没有实现瞬移.经过自己查脚本与实验终于得到 ...

  10. ABP module-zero +AdminLTE+Bootstrap Table+jQuery权限管理系统第十二节--小结,Bootstrap Table之角色管理

    返回总目录:ABP+AdminLTE+Bootstrap Table权限管理系统一期 很多人说ABP不适合高并发大型,有一定的道理,但是我觉得还是可以的,就看架构师的能力了,哈哈,我之前公司就是ABP ...