java集合框架

时间  2019-11-29
标签 java 集合 框架 栏目 Java 繁體版
原文   原文链接

java的集合框架最全详解（图）java

前言：数据结构对程序设计有着深远的影响，在面向过程的C语言中，数据库结构用struct来描述，而在面向对象的编程中，数据结构是用类来描述的，而且包含有对该数据结构操做的方法。程序员

在Java语言中，Java语言的设计者对经常使用的数据结构和算法作了一些规范（接口）和实现（具体实现接口的类）。全部抽象出来的数据结构和操做（算法）统称为Java集合框架（JavaCollectionFramework）。算法

Java程序员在具体应用时，没必要考虑数据结构和算法实现细节，只须要用这些类建立出来一些对象，而后直接应用就能够了，这样就大大提升了编程效率。数据库

 

1. 先说Set和List:编程

1.1. Set子接口:无序，不容许重复。List子接口:有序，能够有重复元素。具体区别是数组

Set：检索元素效率低下，删除和插入效率高，插入和删除不会引发元素位置改变。<对应类有 HashSet,TreeSet>安全

List：和数组相似，List能够动态增加，查找元素效率高，插入删除元素效率低，由于会引发其余元素位置改变。<相应类有 ArrayList,LinkedList，Vector>数据结构

Set和List具体子类：框架

2.2. <实例比较>数据结构和算法

HashSet：以哈希表的形式存放元素，插入删除速度很快。

ArrayList：动态数组，LinkedList：链表、队列、堆栈。

Vector是一种老的动态数组，是线程同步的，效率很低，通常不同意使用

1.Collection接口

Collection是最基本的集合接口，一个Collection表明一组Object，即Collection的元素（Elements）。一些 Collection容许相同的元素而另外一些不行。一些能排序而另外一些不行。JavaSDK不提供直接继承自Collection的类，JavaSDK提供的类都是继承自Collection的“子接口”如List和Set。

全部实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于建立一个空的Collection，有一个 Collection参数的构造函数用于建立一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数容许用户复制一个Collection。

如何遍历Collection中的每个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子便可逐一访问Collection中每个元素。典型的用法以下：

Iteratorit=collection.iterator();//得到一个迭代子

while(it.hasNext()){

Objectobj=it.next();//获得下一个元素

}

由Collection接口派生的两个接口是List和Set。

2.List接口

List是有序的Collection，使用此接口可以精确的控制每一个元素插入的位置。用户可以使用索引（元素在List中的位置，相似于数组下标）来访问List中的元素，这相似于Java的数组。

和下面要提到的Set不一样，List容许有相同的元素。

除了具备Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，容许添加，删除，设定元素，还能向前或向后遍历。

实现List接口的经常使用类有LinkedList，ArrayList，Vector和Stack。

2.1.LinkedList类

LinkedList实现了List接口，容许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操做使LinkedList可被用做堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。若是多个线程同时访问一个List，则必须本身实现访问同步。一种解决方法是在建立List时构造一个同步的List：

Listlist=Collections.synchronizedList(newLinkedList(...));

2.2.ArrayList类

ArrayList实现了可变大小的数组。它容许全部元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。可是add方法开销为分摊的常数，添加n个元素须要O(n)的时间。其余的方法运行时间为线性。

每一个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增长，可是增加算法并无定义。当须要插入大量元素时，在插入前能够调用ensureCapacity方法来增长ArrayList的容量以提升插入效率（自动增判断长度后增加也会浪费时间的呀！）。

和LinkedList同样，ArrayList也是非同步的（unsynchronized）。（扩展阅读：在java.util.concurrent包中定义的CopyOnWriteArrayList提供了线程安全的Arraylist，可是当进行add和set等变化操做时它是经过为底层数组建立新的副本实现的，因此比较耗费资源

（源码在此：publicboolean add(E e) {

finalReentrantLock lock =this.lock;

lock.lock();

try {

Object[] elements = getArray();

int len = elements.length;

Object[] newElements = Arrays.copyOf(elements,len + 1);

newElements[len] = e;

setArray(newElements);

return true;

} finally {

lock.unlock();

}

}），

可是若是存在频繁遍历，遍历操做比变化（写入和修改）操做多的时候这种遍历就相对于本身进行的同步遍历效果要好，并且它也容许存在null元素）

2.3.Vector类

Vector很是相似ArrayList，可是Vector是同步的。由Vector建立的Iterator，虽然和ArrayList建立的 Iterator是同一接口，可是，由于Vector是同步的，当一个Iterator被建立并且正在被使用，另外一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，所以必须捕获该异常。经过使用capacity和ensurecapacity操做以及capacityIncrement域能够优化存储操做，这个前面讲过，（Vector的Iterator和listIterator方法翻译的迭代器支持fail-fast机制，所以若是在使用迭代器的过程当中有其余线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。官方对此的说明是 java.util 包中的集合类都返回 fail-fast迭代器，这意味着它们假设线程在集合内容中进行迭代时，集合不会更改它的内容。若是 fail-fast迭代器检测到在迭代过程当中进行了更改操做，那么它会抛出 ConcurrentModificationException，这是不可控异常。）

2.4.Stack类

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被看成堆栈使用。基本的push和pop方法，还有peek方法获得栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚建立后是空栈。

stack 有几个比较实用的方法

boolean

empty() 
测试堆栈是否为空。

E

peek() 
查看堆栈顶部的对象，但不从堆栈中移除它。

E

pop() 
移除堆栈顶部的对象，并做为此函数的值返回该对象。

E

push(Eitem)
把项压入堆栈顶部。

int

search(Objecto)
返回对象在堆栈中的位置，以 1 为基数。

 

 

 

3. set接口：

Set具备与Collection彻底同样的接口，所以没有任何额外的功能，不像前面有两个不一样的List。实际上Set就是Collection,只是行为不一样。(这是继承与多态思想的典型应用：表现不一样的行为。)Set不保存重复的元素(至于如何判断元素相同则较为负责)
Set : 存入Set的每一个元素都必须是惟一的，由于Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的惟一性。Set与Collection有彻底同样的接口。Set接口不保证维护元素的次序。（我变换黄色背景那里的名称获得以下特色）


HashSet : 它不容许出现重复元素；不保证和政集合中元素的顺序，能够本身作个例子能够看出加入的字段顺序跟遍历出的不同，容许包含值为null的元素，但最多只能有一个null元素（不容许重复嘛！）。

 

TreeSet : 能够实现排序等功能的集合，它在讲对象元素添加到集合中时会自动按照某种比较规则将其插入到有序的对象序列中，并保证该集合元素组成按照“升序”排列。

a)（在对大量信息进行检索的时候，TreeSet比AraayList更有效率，能保证在log(n)的时间内完成）。

b)TreeSet是实用树形结构来存储信息的，每一个节点都会保存一下指针对象，分别指向父节点，左分支，右分支，相比较而言，ArrayList就是一个含有元素的简单数组了，正由于如此，它占的内存也要比ArrayList多一些。

c)想TreeSet插入元素也比ArrayList要快一些，由于当元素插入到ArrayList的任意位置时，平均每次要移动一半的列表，须要O(n)的时间， 而TreeSet深度遍历查询花费的实施只须要O(log(n))（广泛的都是，set查询慢，插入快，list查询快，插入满, .TODO:这一点我会写一个算法测试文章具体分析一下…）


LinkedHashSet : 具备HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。因而在使用迭代器遍历Set时，结果会按元素插入的次序显示。

 

 

PS:set有几个比较好的方法:

removeAll(Collection<?> c)

移除 set 中那些包含在指定 collection 中的元素（可选操做）。

boolean retainAll(Collection<?> c)

仅保留 set 中那些包含在指定 collection 中的元素（可选操做）。

containsAll(Collection<?> c)

若是此 set 包含指定 collection 的全部元素，则返回 true。

4.Queue数据结构

这方面知识涉及到线程比较多，有线程基础的口语参考这篇文章

http://blog.csdn.net/a512592151/article/details/38454745

5.Map的功能方法

java为数据结构中的映射定义了一个接口java.util.Map;它有四个实现类,分别是HashMap Hashtable LinkedHashMap 和TreeMap

Map主要用于存储健值对，根据键获得值，所以不容许键重复,但容许值重复。

Hashmap 是一个 最经常使用的Map,它根据键的HashCode 值存储数据,根据键能够直接获取它的值，具备很快的访问速度。HashMap最多只容许一条记录的键为Null;容许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻能够有多个线程同时写HashMap;可能会致使数据的不一致。若是须要同步，能够用 Collections的synchronizedMap方法使HashMap具备同步的能力.

Hashtable 与HashMap相似,不一样的是:它不容许记录的键或者值为空;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,所以也致使了Hashtale在写入时会比较慢。

LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先获得的记录确定是先插入的.在遍历 的时候会比HashMap慢。

TreeMap可以把它保存的记录根据键排序,默认是按升序排序，也能够指定排序的比较器，当用Iterator 遍历TreeMap时，获得的记录是排过序的。

 

Java代码   收藏代码
  1. package com.hxw.T2;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Hashtable;  
  5. import java.util.Iterator;  
  6. import java.util.LinkedHashMap;  
  7. import java.util.Map;  
  8. import java.util.TreeMap;  
  9.   
  10.   
  11.   
  12. public class MapTester {  
  13.   
  14.     public static void init(Map map) {  
  15.         if (map != null) {  
  16.             String key = null;  
  17.             for (int i = 5; i > 0; i--) {  
  18.                 key = new Integer(i).toString() + ".0";  
  19.                 map.put(key, key.toString());  
  20.                 // Map中的键是不重复的，若是插入两个键值同样的记录，  
  21.                 // 那么后插入的记录会覆盖先插入的记录  
  22.                 map.put(key, key.toString() + "0");  
  23.             }  
  24.         }  
  25.     }  
  26.   
  27.     public static void output(Map map) {  
  28.         if (map != null) {  
  29.             Object key = null;  
  30.             Object value = null;  
  31.             // 使用迭代器遍历Map的键，根据键取值  
  32.             Iterator it = map.keySet().iterator();  
  33.             while (it.hasNext()) {  
  34.                 key = it.next();  
  35.                 value = map.get(key);  
  36.                 System.out.println("key: " + key + "; value: " + value);  
  37.             }  
  38.             // 或者使用迭代器遍历Map的记录Map.Entry  
  39.             Map.Entry entry = null;  
  40.             it = map.entrySet().iterator();  
  41.             while (it.hasNext()) {  
  42.                 // 一个Map.Entry表明一条记录  
  43.                 entry = (Map.Entry) it.next();  
  44.                 // 经过entry能够得到记录的键和值  
  45.                 // System.out.println("key: " + entry.getKey() + "; value: " +  
  46.                 // entry.getValue());  
  47.             }  
  48.         }  
  49.     }  
  50.   
  51.     public static boolean containsKey(Map map, Object key) {  
  52.         if (map != null) {  
  53.             return map.containsKey(key);  
  54.         }  
  55.         return false;  
  56.     }  
  57.   
  58.     public static boolean containsValue(Map map, Object value) {  
  59.         if (map != null) {  
  60.             return map.containsValue(value);  
  61.         }  
  62.         return false;  
  63.     }  
  64.   
  65.     public static void testHashMap() {  
  66.         Map myMap = new HashMap();  
  67.         init(myMap);  
  68.         // HashMap的键能够为null  
  69.         myMap.put(null, "ddd");  
  70.         // HashMap的值能够为null  
  71.         myMap.put("aaa", null);  
  72.         output(myMap);  
  73.     }  
  74.   
  75.     public static void testHashtable() {  
  76.         Map myMap = new Hashtable();  
  77.         init(myMap);  
  78.         // Hashtable的键不能为null  
  79.         // myMap.put(null,"ddd");  
  80.         // Hashtable的值不能为null  
  81.         // myMap.put("aaa", null);  
  82.         output(myMap);  
  83.     }  
  84.   
  85.     public static void testLinkedHashMap() {  
  86.         Map myMap = new LinkedHashMap();  
  87.         init(myMap);  
  88.         // LinkedHashMap的键能够为null  
  89.         myMap.put(null, "ddd");  
  90.         // LinkedHashMap的值能够为null  
  91.         myMap.put("aaa", null);  
  92.         output(myMap);  
  93.     }  
  94.   
  95.     public static void testTreeMap() {  
  96.         Map myMap = new TreeMap();  
  97.         init(myMap);  
  98.         // TreeMap的键不能为null  
  99.         // myMap.put(null,"ddd");  
  100.         // TreeMap的值不能为null  
  101.         // myMap.put("aaa", null);  
  102.         output(myMap);  
  103.     }  
  104.   
  105.     public static void main(String[] args) {  
  106.         System.out.println("采用HashMap");  
  107.         MapTester.testHashMap();  
  108.         System.out.println("采用Hashtable");  
  109.         MapTester.testHashtable();  
  110.         System.out.println("采用LinkedHashMap");  
  111.         MapTester.testLinkedHashMap();  
  112.         System.out.println("采用TreeMap");  
  113.         MapTester.testTreeMap();  
  114.   
  115.         Map myMap = new HashMap();  
  116.         MapTester.init(myMap);  
  117.         System.out.println("新初始化一个Map: myMap");  
  118.         MapTester.output(myMap);  
  119.         // 清空Map  
  120.         myMap.clear();  
  121.         System.out.println("将myMap clear后，myMap空了么?  " + myMap.isEmpty());  
  122.         MapTester.output(myMap);  
  123.         myMap.put("aaa", "aaaa");  
  124.         myMap.put("bbb", "bbbb");  
  125.         // 判断Map是否包含某键或者某值  
  126.         System.out.println("myMap包含键aaa?  "  
  127.                 + MapTester.containsKey(myMap, "aaa"));  
  128.         System.out.println("myMap包含值aaaa?  "  
  129.                 + MapTester.containsValue(myMap, "aaaa"));  
  130.         // 根据键删除Map中的记录  
  131.         myMap.remove("aaa");  
  132.         System.out.println("删除键aaa后，myMap包含键aaa?  "  
  133.                 + MapTester.containsKey(myMap, "aaa"));  
  134.         // 获取Map的记录数  
  135.         System.out.println("myMap包含的记录数:  " + myMap.size());  
  136.     }  
  137. }  


附：map 遍历的四种方法：

Java代码   收藏代码
  1. public static void main(String[] args) {  
  2.   
  3.   
  4.   Map<String, String> map = new HashMap<String, String>();  
  5.   map.put("1", "value1");  
  6.   map.put("2", "value2");  
  7.   map.put("3", "value3");  
  8.     
  9.   //第一种：广泛使用，二次取值  
  10.   System.out.println("经过Map.keySet遍历key和value：");  
  11.   for (String key : map.keySet()) {  
  12.    System.out.println("key= "+ key + " and value= " + map.get(key));  
  13.   }  
  14.     
  15.   //第二种  
  16.   System.out.println("经过Map.entrySet使用iterator遍历key和value：");  
  17.   Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();  
  18.   while (it.hasNext()) {  
  19.    Map.Entry<String, String> entry = it.next();  
  20.    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());  
  21.   }  
  22.     
  23.   //第三种：推荐，尤为是容量大时  
  24.   System.out.println("经过Map.entrySet遍历key和value");  
  25.   for (Map.Entry<String, String> entry : map.entrySet()) {  
  26.    System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());  
  27.   }  
  28.   
  29.   //第四种  
  30.   System.out.println("经过Map.values()遍历全部的value，但不能遍历key");  
  31.   for (String v : map.values()) {  
  32.    System.out.println("value= " + v);  
  33.   }  
  34.  }  

 

 

三、其余特征

*List，Set，Map将持有对象一概视为Object型别。

*Collection、List、Set、Map都是接口，不能实例化。

继承自它们的 ArrayList, Vector, HashTable, HashMap是具象class，这些才可被实例化。

*vector容器确切知道它所持有的对象隶属什么型别。vector不进行边界检查。

 

3、Collections

Collections是针对集合类的一个帮助类。提供了一系列静态方法实现对各类集合的搜索、排序、线程彻底化等操做。

至关于对Array进行相似操做的类——Arrays。

如，Collections.max(Collection coll); 取coll中最大的元素。

Collections.sort(List list); 对list中元素排序

4、如何选择？

一、容器类和Array的区别、择取

* 容器类仅能持有对象引用（指向对象的指针），而不是将对象信息copy一份至数列某位置。

* 一旦将对象置入容器内，便损失了该对象的型别信息。

二、

* 在各类Lists中，最好的作法是以ArrayList做为缺省选择。当插入、删除频繁时，使用LinkedList()；

Vector老是比ArrayList慢，因此要尽可能避免使用。

* 在各类Sets中，HashSet一般优于TreeSet（插入、查找）。只有当须要产生一个通过排序的序列，才用TreeSet。

TreeSet存在的惟一理由：可以维护其内元素的排序状态。

* 在各类Maps中

HashMap用于快速查找。

* 当元素个数固定，用Array，由于Array效率是最高的。

结论：最经常使用的是ArrayList，HashSet，HashMap，Array。并且，咱们也会发现一个规律，用TreeXXX都是排序的。

 

注意：

一、Collection没有get()方法来取得某个元素。只能经过iterator()遍历元素。

二、Set和Collection拥有如出一辙的接口。

三、List，能够经过get()方法来一次取出一个元素。使用数字来选择一堆对象中的一个，get(0)...。(add/get)

四、通常使用ArrayList。用LinkedList构造堆栈stack、队列queue。

五、Map用 put(k,v) / get(k)，还可使用containsKey()/containsValue()来检查其中是否含有某个key/value。

HashMap会利用对象的hashCode来快速找到key。

* hashing

哈希码就是将对象的信息通过一些转变造成一个独一无二的int值，这个值存储在一个array中。

咱们都知道全部存储结构中，array查找速度是最快的。因此，能够加速查找。

 

发生碰撞时，让array指向多个values。即，数组每一个位置上又生成一个梿表。

六、Map中元素，能够将key序列、value序列单独抽取出来。

使用keySet()抽取key序列，将map中的全部keys生成一个Set。

使用values()抽取value序列，将map中的全部values生成一个Collection。

为何一个生成Set，一个生成Collection？那是由于，key老是独一无二的，value容许重复。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程