简介：

集合类Collection不是Java的核心类，是Java的扩展类。集合可以用来储存任何类型的对象，给程序员提供了代码编写的灵活性，但是同时也带来了类型安全的问题。JDK1.5集以上的版本支持Generics，这种新概念的提出改变了Java传统代码的编写方式。（Generics type）编程概念和技术应用于集合类，解决了集合类的类型安全问题，这可用于对任何数据类型的定义和操作。

集合和数组有了紧密的联系又有很多的不同之处。

集合和数组的相同之处：

1、它们都用来储存多个对象

2、有些集合类，例如ArrayList，实际上应用数组结构储存对象

集合类和数组的不同之处：

1、集合类是Java的扩充的API类，而数组是Java语言本身的数据结构

2、集合储存的对象是动态可变的，而数组的大小是静态不变的

3、集合只可用于储存对象，而数组可用来储存基本类型或者对象

4、集合一般使用方法，例如add()，或者iterator()，来添加或访问对象，而数组使用下标

5、集合可使用众多的方法，而数组可使用的方法较少

从整体的角度来看，集合类由两部分组成：Collection接口和Map接口。二级接口Set和List继承了Collection接口，并且导出三个常用的集合类HashSet、ArrayList、LinkedList

接口Map提供了两个常用的集合类：HaspMap、TreeMap

Collection和Map都包括在java。util包中。

Coll2ection定义接口类的基本方法，其二级接口Set与List是将集合类分为不同功能的两大类：Set（不允许有重复元素）、List（允许有重复元素）

虽然集合类有两个独立的接口构成，但是它们有着许多相同的集合操作方式，它们之间的不同在于对元素的储存方式。

1、Collection：定义对所有集合类操作的基本方法，例如size()/isEmpty()/contains()/add()/remove()/isterator()等15个方法，这是从Iterable接口继承而来。

2、Set：定义不允许重复元素和集合类的基本操作方法，集成Collection中的所有方法

3、List：定义允许重复元素的集合类的基本操作方法，继承了Collection‘中定义的所有方法，定义对一些方法的重载签名，增添了新的方法。

4、Map：定义对所有map集合类操作的基本方法，例如containsKey()/containsValue()/keySet()/put()/values()等14个方法，它本身就是一个根接口。

（1）ArrayList：数组式结构的集合类，其大小可自动调整，保持元素添加的位置，对元素的有序和随机访问非常有效，但不在结尾添加元素时效率不高

（2）LinkedList：与ArrayList相似，但应用链接式结构，不再结尾位置添加和删除元素非常有效

（3）HashSet：应用Hash码储存五重复元素的集合类，储存的元素必须完善hashCode()方法以保证其唯一性

我们在一般情况下，就可以把ArrayList和LinkedList看成是C语言中的数组和链表，它们的优劣性都可以参照一下。

Map接口中的常用类：

（1）HashMap：与HashSet相似，但它们属于不同的接口，以key-value一一对应的方式来储存无重复元素。

（2）TreeMap：与HashMap相似，但以树tree的数据结构储存元素，元素必须是key-value意义对应的方法储存，且自动按照key对象排序。

对于Map的KeySet()方法返回类型是Set，而Values()的返回类型是Collection。（应用性比较广）

下面两个程序，比较map中key-value的一一对应：

[java] view plaincopy print?
  1. package connections;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. public class EmployeeMapTest {
  5. public static void main(String[] args) {
  6. Map<String, String> employeeMap = new HashMap<String, String>();
  7. employeeMap.put("1000", "litianpeng");
  8. employeeMap.put("115", "zuxiaoyu");
  9. employeeMap.put("1102", "lihuanhuan");
  10. //employeeMap.put("115", "surprise");
  11. System.out.println(employeeMap);
  12. }
  13. }

运行截图：

[java] view plaincopy print?
  1. package connections;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. public class EmployeeMapTest {
  5. public static void main(String[] args) {
  6. Map<String, String> employeeMap = new HashMap<String, String>();
  7. employeeMap.put("1000", "litianpeng");
  8. employeeMap.put("115", "zuxiaoyu");
  9. employeeMap.put("1102", "lihuanhuan");
  10. employeeMap.put("115", "surprise");
  11. System.out.println(employeeMap);
  12. }
  13. }

运行截图：

可以看出来key=115的键值已经被替代了。

下面介绍Collection集合类：

1、ArraList：以数组作为实现的结构，氮元素不受固定空间的限制，是大小可变的数组，但是任何不再结尾处增添元素的操作，都需要移位，ArrayList可以接受任何Object对象作为它的元素，但不允许是基本类型，且对元素的访问和操作通过调用方法进行。

注意：系统预设ArrayList的元素数为10，可以指定ArrayList对象储存元素的大小，其空间将随着元素的增添和清除而自动增加或者减少。

2、LinkedList：链接表LinkedList与ArrayList相似，但应用节点node数据结构实现，因而提高了不再结尾处增添或者删除元素操作的效率。

3、HashSet：HashSet集合主要应用于简单快速、与检索有关的操作

HashSet与ArrayList和LinkedList相比，主要有下列不同的特点：

（1）应用hash表结构

（2）不允许有重复的元素

（3）元素是无序的，即按照哈希码储存

（4）自定义集合元素必须覆盖hashcode()方法来产生哈希码

4、Iterator：元素迭代器，在ArrayList和LinkedList中都提供方法iterator()，用来返回一个指定类型的元素迭代器Iterator对集合的引用，用来对各元素按次序遍历。

boolean hasNext()：如果仍有元素，返回真，否则返回假

E next()：返回下一个元素

void remove()：删除迭代器当前指向集合中的元素

下面介绍Map集合类：

主要包括HashMap和TreeMap两大类，它们中的每一个元素必须应用一对key-value来储存。由key来映射value。

注意

（1）key与value必须是对象，而不允许是基本数据类型

（2）key在一个集合中必须具有唯一性，即key不允许有重复，但允许有重复的value出现

1、HashMap：HashMap实现Map接口，它利用Hash表结构，因而集合中的元素不按次序排列。

注意：系统预设HashMap的元素数目为16，也可以自己指定HashMap储存的元素数目。

由于HashMap不支持迭代器，可以利用keySet()方法，以set引用返回HashMap集合中所有的key，再利用元素迭代器对元素进行遍历，对元素的遍历，可以调用values()实现

2、TreeMap：TreeMap与HashMap相似，实现了Map接口，所有元素都是key-value的映射。两者之间的不同点在于

（1）TreeMap是应用于Tree数据结构储存key-value元素，而HashMap利用Hash表结构

（2）TreeMap集合中的各个映射单元是按照key自动排序的，而HashMap集合中的各映射单元是无序的

（3）TreeMap集合更加有效利用存储空间，而HashMap必须指定或者使用预设映射单元存储空间

一、Set与Map

Set集合的继承体系：

Map集合的继承体系：

从上面的继承关系我们可以看出来，实现Map接口和Set接口的接口名、类名完全相似。

从上一篇博文的分析我们可以知道，Map集合的key具有一个特征：所有的key不能重复，且key之间没有顺序（TreeMap是有顺序的），如果将Map集合的所有key集中起来，那这些key就组成了一个set集合，则map集合提供了keySet()方法返回所有key组成的集合。这样就实现了Map到Set之间的转换。其实也可以实现Set到Map之间的转换。

下面简单实现一下将Set扩展成Map，自定义个一个SimpleEntry类，

代码如下：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.HashSet;
  3. import java.util.Iterator;
  4. import java.util.Map;
  5. class SimpleEntry<K, V> implements Map.Entry<K, V>, java.io.Serializable {
  6. private final K key;
  7. private V value;
  8. public SimpleEntry(K key, V value) {
  9. this.key = key;
  10. this.value = value;
  11. }
  12. public SimpleEntry(Map.Entry<? extends K, ? extends V> entry) {
  13. this.key = entry.getKey();
  14. this.value = entry.getValue();
  15. }
  16. public K getKey() {
  17. return key;
  18. }
  19. public V getValue() {
  20. return value;
  21. }
  22. public V setValue(V value) {
  23. V oldValue = this.value;
  24. this.value = value;
  25. return oldValue;
  26. }
  27. public boolean equals(Object o) {
  28. if (o == this) {
  29. return true;
  30. }
  31. if (o.getClass() == SimpleEntry.class) {
  32. SimpleEntry se = (SimpleEntry) o;
  33. return se.getKey().equals(getKey());
  34. }
  35. return false;
  36. }
  37. public int hashCode() {
  38. return key == null ? 0 : key.hashCode();
  39. }
  40. public String toString() {
  41. return key + "=" + value;
  42. }
  43. }
  44. public class Set2Map<K, V> extends HashSet<SimpleEntry<K, V>> {
  45. public void clear() {
  46. super.clear();
  47. }
  48. public boolean containsKey(K key) {
  49. return super.contains(new SimpleEntry<K, V>(key, null));
  50. }
  51. boolean containsValue(Object value) {
  52. for (SimpleEntry<K, V> se : this) {
  53. if (se.getValue().equals(value)) {
  54. return true;
  55. }
  56. }
  57. return false;
  58. }
  59. public V get(Object key) {
  60. for (SimpleEntry<K, V> se : this) {
  61. if (se.getKey().equals(key)) {
  62. return se.getValue();
  63. }
  64. }
  65. return null;
  66. }
  67. public V put(K key, V value) {
  68. add(new SimpleEntry<K, V>(key, value));
  69. return value;
  70. }
  71. public void putAll(Map<? extends K, ? extends V> m) {
  72. for (K key : m.keySet()) {
  73. add(new SimpleEntry<K, V>(key, m.get(key)));
  74. }
  75. }
  76. public V removeEntry(Object key) {
  77. for (Iterator<SimpleEntry<K, V>> it = this.iterator(); it.hasNext();) {
  78. SimpleEntry<K, V> en = (SimpleEntry<K, V>) it.next();
  79. if (en.getKey().equals(key)) {
  80. V v = en.getValue();
  81. it.remove();
  82. return v;
  83. }
  84. }
  85. return null;
  86. }
  87. public int size() {
  88. return super.size();
  89. }
  90. }

自定义的一个SimpleEntry<K,V>类，当一个Set的所有集合元素都是SimpleEntry<K,V>对象的时候，该Set就变成了一个Map<K,V>集合。接下来，程序以HashSet<SimpleEntry<K,V>>为父类派生了一个子类Set2Map<K,V>，这个扩展类完全可以被当成Map使用，因此上面程序中的Set2Map<K,V>类中也提供了Map集合应该提供的绝大部分方法。

总结：可以通过对Set加以改造，将Set变为Map，这个改造的Map集合在功能上几乎可以和系统提供的Map一样。

二、HashMap与HashSet分析比较：

1、HashMap与HashSet都是采用传统的Hash算法决定集合的存储位置，这样可以保证快速存、取集合元素。

注意：集合虽然说存储Java对象，但实际上不会真正将Java对象放入Set集合中，而只是在Set集合中保留这些对象的引用罢了。

对于HashMap、HashSet及其子类而言，它们采用了Hash算法来决定集合中元素的存储位置

当在创建HashMap的时候，有一个默认的负载因子，其默认值为0.75,，这是时间和空间成本上的一种折衷，增大负载因子就可以减少Hash表所占用的内存空间，但会增加查询数据的时间开销，而查询又是最频繁的操作。减小负载因子会提高数据查询的性能，但是增加Hash表所占用的内存空间。

2、对于HashSet，它是基于HashMap实现的，HashSet底层采用HashMap来保存所有的元素，因此HashSet的实现相对容易一些。

注意：HashSet的绝大部分方法都是通过调用HashMap来实现的，因此HashSet和HashMap两个集合在实现本质上是相同的。

如果向HashSet中添加一个已经存在的元素，新添加的集合元素不会覆盖已有的集合元素。

下面我们看一个精彩的程序：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.HashSet;
  3. import java.util.Set;
  4. public class HashSetTest {
  5. public static void main(String[] args) {
  6. Set<Name> s = new HashSet<Name>();
  7. s.add(new Name("li", "tianpeng"));
  8. System.out.println(s.contains(new Name("li", "tianpeng")));
  9. }
  10. }
  11. class Name {
  12. private String first;
  13. private String last;
  14. public Name(String first, String last) {
  15. this.first = first;
  16. this.last = last;
  17. }
  18. }

下面是结果截图：

打印出来的结果竟然是“false”，我们命名已经添加了一个new Name("abc","123")对象。

这是因为HashSet判断两个对象相等的标准除了要通过equals()方法比较返回true之外，还要两个对象的hashCode()返回值相等，而上面的程序没有没有重写Name类的hashCode()方法，两个Name对象的返回值并不相等，因此HashSet会把它们当成2个对象来处理。

下面重写了hashCode()方法：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.HashSet;
  3. import java.util.Set;
  4. public class HashSetTest {
  5. public static void main(String[] args) {
  6. Set<Name> s = new HashSet<Name>();
  7. s.add(new Name("li", "tianpeng"));
  8. System.out.println(s.contains(new Name("li", "tianpeng")));
  9. }
  10. }
  11. class Name {
  12. private String first;
  13. private String last;
  14. public Name(String first, String last) {
  15. this.first = first;
  16. this.last = last;
  17. }
  18. public int hashCode() {
  19. return first.hashCode();
  20. }
  21. public boolean equals(Object o) {
  22. if (this == o)
  23. return true;
  24. if (o.getClass() == Name.class) {
  25. Name n = (Name) o;
  26. return n.first.equals(first);
  27. }
  28. return false;
  29. }
  30. }

运行结果截图如下：

三、TreeMap与TreeSet比较分析：

1、TreeSet底层采用一个NavigableMap来保存TreeSet集合的元素，但是，由于NavigableMap只是一个接口，因此底层仍然使用TreeMap来包含集合中所有元素。

注意：TreeSet里绝大部分方法都是直接调用TreeMap的方法来实现的。

2、TreeMap则采用一种“红黑树”的排序二叉树来保存Map中的每一个元素，每个元素被当成“红黑树”的一个节点对待。

每次添加一个新元素时，此新元素作为“红黑树”的根节点被添加到已有的红黑树中。这样利用红黑树可以快速地插入与删除还有查找。

下面是TreeMap的应用程序：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.TreeMap;
  3. public class TreeMapTest {
  4. public static void main(String[] args) {
  5. TreeMap<String, Double> map = new TreeMap<String, Double>();
  6. map.put("ccc", 89.0);
  7. map.put("zzz", 89.0);
  8. map.put("aaa", 89.0);
  9. map.put("bbb", 89.0);
  10. System.out.println(map);
  11. }
  12. }

运行结果如下：


关于红黑树的介绍：以后我们会慢慢提到。

总结：Treemap本质上就是一个“红黑树”，而TreeMap上的每一个元素就是该红黑树上的节点。

四、Map和List比较分析：

1、Map的values()方法，Map集合是一个关联数组，Map可以根据key来获取对应的value，所以这些value可以组成一个List集合。但是Map的values()方法并未返回一个List集合。

可以从下面的代码中看出：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.HashMap;
  3. import java.util.TreeMap;
  4. public class MapValueTest {
  5. public static void main(String[] args) {
  6. HashMap<String, Double> scores = new HashMap<String, Double>();
  7. scores.put("语文", 89.0);
  8. scores.put("数学", 83.0);
  9. scores.put("英文", 84.0);
  10. System.out.println(scores.values());
  11. System.out.println(scores.values().getClass());
  12. TreeMap<String, Double> health = new TreeMap<String, Double>();
  13. health.put("身高", 173.0);
  14. health.put("体重", 171.0);
  15. System.out.println(health.values());
  16. System.out.println(health.values().getClass());
  17. }
  18. }

运行结果如下：

可以看出来Map中values()方法返回的值的集合不是List对象。

2、TreeMap：与HashMap优点类似，TreeMap的values()方法返回同样的Values对象，但是此处的Values类是TreeMap的私有内部类，因为TreeMap是用“红黑树”实现的，所以此时Values类当然要考虑红黑树的一些特性。

总结：HashMap和TreeMap中的values()方法并未把Map中的value重新组合成一个包含元素的集合对象，这样可以大大降低系统的开销。

五、Map和List的分析比较：

Map与Set的底层结构很相似，从用法也有一些相似的地方：

（1）Map接口提供了get(K key)方法允许Map对象根据key取得value

（2）List接口提供了get(int index)方法允许List对象根据元素索引取得value

可以把List看成所有key都是int类型的Map，也可以把Map看成key可以是任何类型的List。

六、ArrayList和LinkedList分析比较：

在List集合的实现类中，主要有3种：ArrayList、Vector和LinkedList。其中Vector还有一个Stack子类，此Stack子类仅在Vector父类的基础上增加了5个方法，这5个方法就将一个Vector扩展成了Stack，实际从本质上来讲，Stack仍然是一个Vector，它只是比Vector多了5个方法罢了。

但实际上，Java不推荐使用Stack类，而使推荐使用Deque实现类，Java提供了一个Deque接口，并为该接口提供了一个ArrayDeque实现类，在无需保证线程安全的情况下，程序完全可以使用ArrayDeque来代替Stack类。

Deque接口代表双端队列这种数据结构，它既有队列FIFO的性质，也有栈FILO的性质。

1、Vector与ArrayList区别：

（1）从序列化机制来看，ArrayList的实现比Vector实现更安全

（2）但Vector是ArrayList的线程安全版本，Vector和ArrayList的绝大部分方法都是相同的，只是Vector的方法增加了synchronized关键字

注意：在多线程条件下使用List集合，而且需要保证List集合的线程安全，仍然可以不使用Vector，考虑将ArrayList包装成线程安全的集合类。Java提供了一个Collections工具类，通过该工具类synchronizedList方法可以将一个普通的ArrayList包装成线程安全的ArrayList。

2、ArrayList和LinkedList区别：

（1）ArrayList是一种顺序存储的线性表

（2）LinkedList是一种链式存储的线性表，其本质就是一个双向链表，因为它不仅实现了List接口，而且实现了Deque接口。

总结：ArrayList取数的性能优越，LinkedList插入、删除的性能优越。

七、Iterator迭代器：

下面看关于迭代器的几个代码：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. public class ArrayListRemove {
  5. public static void main(String[] args) {
  6. ArrayList<String> list = new ArrayList<String>();
  7. list.add("111");
  8. list.add("222");
  9. list.add("333");
  10. Iterator<String> it = list.iterator();
  11. while (it.hasNext()) {
  12. String ele = it.next();
  13. if (ele.equals("222"))
  14. list.remove(ele);
  15. }
  16. }
  17. }

此时并没有产生异常，

下面再看一个代码：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. public class ArrayListRemove {
  5. public static void main(String[] args) {
  6. ArrayList<String> list = new ArrayList<String>();
  7. list.add("111");
  8. list.add("222");
  9. list.add("333");
  10. Iterator<String> it = list.iterator();
  11. while (it.hasNext()) {
  12. String ele = it.next();
  13. if (ele.equals("333"))
  14. list.remove(ele);
  15. }
  16. }
  17. }

此时会产生如下异常：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.Iterator;
  3. import java.util.TreeSet;
  4. public class ArrayListRemove {
  5. public static void main(String[] args) {
  6. TreeSet<String> set = new TreeSet<String>();
  7. set.add("111");
  8. set.add("222");
  9. set.add("333");
  10. Iterator<String> it = set.iterator();
  11. while (it.hasNext()) {
  12. String ele = it.next();
  13. if (ele.equals("333"))
  14. set.remove(ele);
  15. }
  16. }
  17. }

此时并不会产生异常，

再看下面的代码：

[java] view plaincopy print?
  1. package com.crazyit;
  2. import java.util.Iterator;
  3. import java.util.TreeSet;
  4. public class ArrayListRemove {
  5. public static void main(String[] args) {
  6. TreeSet<String> set = new TreeSet<String>();
  7. set.add("111");
  8. set.add("222");
  9. set.add("333");
  10. Iterator<String> it = set.iterator();
  11. while (it.hasNext()) {
  12. String ele = it.next();
  13. if (ele.equals("222"))
  14. set.remove(ele);
  15. }
  16. }
  17. }

此时产生如下异常：

总结：

（1）实际上，对于ArrayList、Vector、LinkedList等List集合而言，如果正在遍历倒数第2个集合元素，使用List集合的remove()方法删除集合的任意一个元素并不会发生异常，当正在遍历其他元素时删除其他元素就会发生相关异常。

（2）对于TreeSet、HashSet等Set集合而言，当使用Iterator遍历它们时，如果正在遍历最后一个集合元素时，使用Set集合的remove()方法删除结婚的元素并不会引发异常，但是如果在遍历其他集合元素时删除其他元素，就会引发相关异常。

因为对于List集合，如果在遍历最后第2个元素时执行删除操作，则List调用Iterator对应的hashNext()方法判断已经没有下一个元素了，则不会取next()了。

而对于Set集合，在遍历最后一个元素时，此时遍历操作已经完成，删除Set中元素不会产生任何影响。

from: http://blog.csdn.net/litianpenghaha/article/details/22575639?utm_source=tuicool&utm_medium=referral

http://blog.csdn.net/litianpenghaha/article/details/22601041

Java集合容器全面分析相关推荐

  1. Java 集合容器篇面试题（上）-王者笔记《收藏版》

    前期推荐阅读: Java基础知识学习总结(上) Java 基础知识学习总结(下) 大学生一个暑假学会5个神仙赚钱技能 | 你学会了几个? 毕设/私活/大佬必备,一个挣钱的开源前后端分离脚手架 目录 一 ...

  2. Java集合源码分析（二）ArrayList

    ArrayList简介 ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,类似于C语言中的动态申请内存,动态增长内存. ArrayList不是线程安全的,只能用在单线程环境下,多线 ...

  3. Java集合容器面试题

    文章目录 集合容器概述 什么是集合 集合的特点 集合和数组的区别 使用集合框架的好处 常用的集合类有哪些? List,Set,Map三者的区别?List.Set.Map 是否继承自 Collectio ...

  4. 编程体系结构(03)：Java集合容器

    本文源码:GitHub·点这里 || GitEE·点这里 一.集合容器简介 集合容器是Java开发中最基础API模块,通常用来存储运行时动态创建的元素,基本特点如下: 泛型特点,存储任意类型对象: 动 ...

  5. Java集合容器面试题重点汇总

    集合容器概述 什么是集合 **集合框架:**用于存储数据的容器. 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构. 任何集合框架都包含三大块内容:对外的接口.接口的实现和对集合运算的算 法 ...

  6. Java集合容器系列04-HashMap

    2019独角兽企业重金招聘Python工程师标准>>> 一.HashMap介绍     HashMap是基于哈希表实现的Map容器,存储的元素是键值对映射.继承自AbstractMa ...

  7. Java集合Set性能分析

    Set性能分析 HashSet 和 TreeSet HashSet性能要好于TreeSet(特别是最常用的添加.查询元素等操作) 原因:因为TreeSet需要额外的红黑树算法维护集合元素的次序.只有需 ...

  8. java集合源码分析之HashMap

    UML类图: 基本简介: 底层的数据结构是数组,数组的元素类型是链表或者红黑树. 元素的添加可能会触发数组的扩容,会使元素重新哈希放入桶中,效率比较低. 元素在不扩容的情况下添加效率高,查找.删除.修 ...

  9. java集合源码分析

    List,Set,Map都是接口,前两个继承Collection接口,Map为独立接口 Set的实现由HashSet,LinkedHashSet,TreeSet List下有ArrayList,Vec ...

最新文章

  1. 【Maven学习】Nexus私服代理其他第三方的Maven仓库
  2. Qt 获取文件夹下所有文件
  3. linux下mkdir
  4. ERP实施成功与否，企业文化是致命因素？
  5. 群晖docker_利用群晖docker搭建Minecraft服务器：图形界面操作，傻瓜式教程（附官方服务器端地址）_NAS存储...
  6. 视频光端机园区出入口监控项目应用方案详解
  7. Javassist实现JDK动态代理
  8. xml分析错误:注释未终止_错误：C中的未终止注释（无效的注释块） 常见的C程序错误...
  9. JAVA设置输入数据范围,如何使用Apache POI（SXSSF）为特定单元格设置数据（数字）格式区域设置？...
  10. UEBA能够检测的七大类安全风险
  11. jqGrid Pager、Navigator和自定义按钮（转）
  12. 《学习opencv》笔记——关于一些画图的函数
  13. [C++]VC自定义发IP包例子
  14. uva10105 - Polynomial Coefficients(多项式系数)
  15. 数据结构常见问题系列(二)
  16. 笔记本电脑能连接WiFi但浏览器无法打开网页的解决办法
  17. ubuntu 18.04 桌面版应用、美化、配置备忘录[更新中]
  18. lsmod,insmod
  19. python的学习笔记案例1--汇率兑换4.0
  20. 如何实现丝滑般的数据库扩容

热门文章

  1. 今日头条成功的核心技术秘诀是什么？深度解密个性化资讯推荐技术 本文作者：AI研习社 2017-07-05 12:24 导语：从“内行”的角度解密个性化资讯推荐技术。 雷锋网按：本文系知名 IT 技术资
  2. php 表单提交及验证 tp,ThinkPHP表单自动提交验证实例教程
  3. Apache ZooKeeper - ZK的数据和文件
  4. MySQL - 索引优化案例实操
  5. Spring-AOP @AspectJ进阶之绑定连接点方法入参
  6. asp.net 检测是否关注公众号_实木板材开裂和变形是什么情况，出现后该怎么检测？...
  7. 小米算法题判断直线相交
  8. 用python打开视频_python读取视频流提取视频帧的两种方法
  9. java反编译工具_漫话：如何给女朋友解释什么是编译与反编译
  10. 数据结构特性解析 (一) 数组