2. 程式人生 > >集合框架之collection類詳解

集合框架之collection類詳解

阿新 • • 發佈：2019-01-21

一、集合框架的由來

Java 集合框架主要包括兩種型別的容器，一種是集合（Collection），儲存一個元素集合，另一種是圖（Map），儲存鍵/值對對映。Collection 介面又有 3 種子型別，List、Set和Queue，再下面是一些抽象類，最後是具體實現類，常用的有ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一個用來代表和操縱集合的統一架構。所有的集合框架都包含如下內容：

  • 介面：是代表集合的抽象資料型別。例如 Collection、List、Set、Map 等。之所以定義多個介面，是為了以不同的方式操作集合物件

  • 實現（類）：是集合介面的具體實現。從本質上講，它們是可重複使用的資料結構，例如：ArrayList、LinkedList、HashSet、HashMap。

  • 演算法：是實現集合介面的物件裡的方法執行的一些有用的計算，例如：搜尋和排序。這些演算法被稱為多型，那是因為相同的方法可以在相似的介面上有著不同的實現。

除了集合，該框架也定義了幾個 Map 介面和類。Map 裡儲存的是鍵/值對。儘管Map不是集合，但是它們完全整合在集合中。

二、陣列與集合的區別

陣列的特點：

  1. 只能儲存同一種資料型別的資料。
  2. 一旦初始化，長度固定。
  3. 陣列中的元素與元素之間的記憶體地址是連續的。

注意： Object型別的陣列可以儲存任意型別的資料。

集合：集合是儲存物件資料的集合容器。

集合比陣列的優勢:

  1. 集合可以儲存任意型別的物件資料，陣列只能儲存同一種資料型別 的資料。
  2. 集合的長度是會發生變化的，陣列的長度是固定的

三、collection之繼承體系

Collection<E>介面是所有單列集合的共同父介面，下面列出了常用的Collection子類集合及其繼承關係。

集合框架概述

Collection   
    |-----List有序(儲存順序和取出順序一致)，可重複
    |----ArrayList，執行緒不安全，底層使用陣列實現，查詢快，增刪慢。效率高。
            每次容量不足時，自增長度的一半，如下原始碼可知
                  int newCapacity = oldCapacity + (oldCapacity >> 1);
    |----LinkedList ， 執行緒不安全，底層使用連結串列實現，查詢慢，增刪快。效率高
 
    |----Vector ， 執行緒安全，底層使用陣列實現，查詢快，增刪慢。效率低         每次容量不足時，預設自增長度的一倍（如果不指定增量的話），如下原始碼可知
                   int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    |-----Set   元素唯一一個不包含重複元素的 collection。更確切地講，set 不包含滿足 e1.equals(e2) 的元素對 e1 和 e2，並且最多包含一個 null 元素。
 
    |--HashSet 底層是由HashMap實現的，通過物件的hashCode方法與equals方法來保證插入元素的唯一性，無序(儲存順序和取出順序不一致)。
 
    |--LinkedHashSet 底層資料結構由雜湊表和連結串列組成。雜湊表保證元素的唯一性，連結串列保證元素有序。(儲存和取出是一致)
 
    |--TreeSet 基於 TreeMap 的 NavigableSet 實現。使用元素的自然順序對元素進行排序，或者根據建立 set 時提供的 Comparator 進行排序，具體取決於使用的構造方法。 元素唯一。

四、Collection泛型介面

boolean add(E e) 
             確保此 collection 包含指定的元素（可選操作）。    
    boolean addAll(Collection<? extends E> c) 
   將指定collection中的所有元素都新增到此collection 中（可選操作）。    
    void clear() 
             移除此 collection 中的所有元素（可選操作）。 
    boolean contains(Object o) 
             如果此 collection 包含指定的元素，則返回 true。 
    boolean containsAll(Collection<?> c) 
             如果此 collection 包含指定 collection 中的所有元素，則返回 true。 
    boolean equals(Object o) 
             比較此 collection 與指定物件是否相等。 
    int hashCode() 
             返回此 collection 的雜湊碼值。 
    boolean isEmpty() 
             如果此 collection 不包含元素，則返回 true。 
    Iterator<E> iterator() 
             返回在此 collection 的元素上進行迭代的迭代器。 
    boolean remove(Object o) 
             從此 collection 中移除指定元素的單個例項，如果存在的話（可選操作）。 
    boolean removeAll(Collection<?> c) 
             移除此 collection 中那些也包含在指定 collection 中的所有元素（可選操作）。 
    boolean retainAll(Collection<?> c) 
             僅保留此 collection 中那些也包含在指定 collection 的元素（可選操作）。 
    int size() 
             返回此 collection 中的元素數。 
    Object[] toArray() 
             返回包含此 collection 中所有元素的陣列。 
   <T> T[] 
    toArray(T[] a)

collection方法簡單示例：

    //集合轉陣列遍歷
	public static void demo1() {
	Collection coll = new ArrayList();
			coll.add(new Student("張三",23));		//Object obj = new Student("張三",23);
			coll.add(new Student("李四",24));
			coll.add(new Student("王五",25));
			coll.add(new Student("趙六",26));
			
			Object[] arr = coll.toArray();				//將集合轉換成陣列
			for (int i = 0; i < arr.length; i++) {
				Student s = (Student)arr[i];			//強轉成Student
				System.out.println(s.getName() + "," + s.getAge());
			}
	} 
	
	//集合的遍歷之迭代器遍歷
	public static void demo2() {
	Collection c = new ArrayList();
			c.add("a");
			c.add("b");
			c.add("c");
			c.add("d");
			
			Iterator it = c.iterator();						//獲取迭代器的引用
			while(it.hasNext()) {							//集合中的迭代方法(遍歷)
				System.out.println(it.next());
			}
	}

五、List泛型介面

public interface List<E>extends Collection<E>  //超級介面

方法概述：

 boolean add(E o) 
          向列表的尾部追加指定的元素（可選操作）。 
 void add(int index, E element) 
          在列表的指定位置插入指定元素（可選操作）。 
 boolean addAll(Collection<? extends E> c) 
          追加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序（可選操作）。 
 boolean addAll(int index, Collection<? extends E> c) 
          將指定 collection 中的所有元素都插入到列表中的指定位置（可選操作）。 
 void clear() 
          從列表中移除所有元素（可選操作）。 
 boolean contains(Object o) 
          如果列表包含指定的元素，則返回 true。 
 boolean containsAll(Collection<?> c) 
          如果列表包含指定 collection 的所有元素，則返回 true。 
 boolean equals(Object o) 
          比較指定的物件與列表是否相等。 
 E get(int index) 
          返回列表中指定位置的元素。 
 int hashCode() 
          返回列表的雜湊碼值。 
 int indexOf(Object o) 
          返回列表中首次出現指定元素的索引，如果列表不包含此元素，則返回 -1。 
 boolean isEmpty() 
          如果列表不包含元素，則返回 true。 
 Iterator<E> iterator() 
          返回以正確順序在列表的元素上進行迭代的迭代器。 
 int lastIndexOf(Object o) 
          返回列表中最後出現指定元素的索引，如果列表不包含此元素，則返回 -1。 
 ListIterator<E> listIterator() 
          返回列表中元素的列表迭代器（以正確的順序）。 
 ListIterator<E> listIterator(int index) 
          返回列表中元素的列表迭代器（以正確的順序），從列表的指定位置開始。 
 E remove(int index) 
          移除列表中指定位置的元素（可選操作）。 
 boolean remove(Object o) 
          移除列表中出現的首個指定元素（可選操作）。 
 boolean removeAll(Collection<?> c) 
          從列表中移除指定 collection 中包含的所有元素（可選操作）。 
 boolean retainAll(Collection<?> c) 
          僅在列表中保留指定 collection 中所包含的元素（可選操作）。 
 E set(int index, E element) 
          用指定元素替換列表中指定位置的元素（可選操作）。 
 int size() 
          返回列表中的元素數。 
 List<E> subList(int fromIndex, int toIndex) 
          返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分檢視。 
 Object[] toArray() 
          返回以正確順序包含列表中的所有元素的陣列。 
<T> T[] 
 toArray(T[] a) 
          返回以正確順序包含列表中所有元素的陣列；返回陣列的執行時型別是指定陣列的執行時型別。

list方法簡單示例：

	public static void demo2() {
		List list = new ArrayList();
		list.add(new Student("張三",23));
		list.add(new Student("李四",24));
		list.add(new Student("王五",25));
		list.add(new Student("趙六",26));
		
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			Student s = (Student) iterator.next(); //向下轉型
			System.out.println(s);
		}
	}
	
	public static void demo() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		
		Iterator iterator  = list.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

併發修改異常產生的原因及解決方案

假設有一個集合，請問，我想判斷裡面有沒有"world"這個元素，如果有，我就新增一個"java"元素,具體程式碼如下：

public static void demo3() {
		List list = new ArrayList();
		list.add("a");
		list.add("b");
		list.add("world");
		list.add("d");
		list.add("e");
		
		Iterator it = list.iterator();
		while(it.hasNext()) {
			String str = (String)it.next();
			if(str.equals("world")) {
				list.add("javaee");			//這裡會丟擲ConcurrentModificationException併發修改異常
			}
		}
	}

執行上面程式碼發生ConcurrentModificationException併發修改異常，檢視迭代器原始碼如下。
產生原因：迭代器是依賴於集合而存在的，在判斷成功後，集合的中新添加了元素，而迭代器卻不知道，迭代器的內容不發生改變。所以就報錯了，這個錯叫併發修改異常。

      final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

解決辦法及程式碼如下：
迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
集合遍歷元素，集合修改元素

    public static void demo() {
		ListIterator lit = list.listIterator();		//如果想在遍歷的過程中新增元素,可以用ListIterator中的add方法
			while(lit.hasNext()) {
				String str = (String)lit.next();
				if(str.equals("world")) {
					lit.add("javaee");	
					//list.add("javaee");
				}
            }	
		}

瞭解：(ListIterator)

  1. boolean hasNext()是否有下一個
  2. boolean hasPrevious()是否有前一個
  3. Object next()返回下一個元素
  4. Object previous();返回上一個元素

六、ArrayList類

方法摘要：

public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

構造方法摘要

ArrayList() 
          構造一個初始容量為 10 的空列表。 
ArrayList(Collection<? extends E> c) 
          構造一個包含指定 collection 的元素的列表，這些元素是按照該 collection 的迭代器返回它們的順序排列的。 
ArrayList(int initialCapacity) 
          構造一個具有指定初始容量的空列表。 
 

 boolean add(E o) 
          將指定的元素追加到此列表的尾部。 
 void add(int index, E element) 
          將指定的元素插入此列表中的指定位置。 
 boolean addAll(Collection<? extends E> c) 
          按照指定 Collection 的迭代器所返回的元素順序，將該 Collection 中的所有元素追加到此列表的尾部。 
 boolean addAll(int index, Collection<? extends E> c) 
          從指定的位置開始，將指定 Collection 中的所有元素插入到此列表中。 
 void clear() 
          移除此列表中的所有元素。 
 Object clone() 
          返回此 ArrayList 例項的淺表複製。 
 boolean contains(Object elem) 
          如果此列表中包含指定的元素，則返回 true。 
 void ensureCapacity(int minCapacity) 
          如有必要，增加此 ArrayList 例項的容量，以確保它至少能夠容納最小容量引數所指定的元素數。 
 E get(int index) 
          返回此列表中指定位置上的元素。 
 int indexOf(Object elem) 
          搜尋給定引數第一次出現的位置，使用 equals 方法進行相等性測試。 
 boolean isEmpty() 
          測試此列表中是否沒有元素。 
 int lastIndexOf(Object elem) 
          返回指定的物件在列表中最後一次出現的位置索引。 
 E remove(int index) 
          移除此列表中指定位置上的元素。 
 boolean remove(Object o) 
          從此列表中移除指定元素的單個例項（如果存在），此操作是可選的。 
protected  void removeRange(int fromIndex, int toIndex) 
          移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素。 
 E set(int index, E element) 
          用指定的元素替代此列表中指定位置上的元素。 
 int size() 
          返回此列表中的元素數。 
 Object[] toArray() 
          返回一個按照正確的順序包含此列表中所有元素的陣列。 
<T> T[] 
 toArray(T[] a) 
          返回一個按照正確的順序包含此列表中所有元素的陣列；返回陣列的執行時型別就是指定陣列的執行時型別。 
 void trimToSize() 
          將此 ArrayList 例項的容量調整為列表的當前大小。 
從類 java.util.AbstractList 繼承的方法 
equals, hashCode, iterator, listIterator, listIterator, subList 
  從類 java.util.AbstractCollection 繼承的方法 
containsAll, removeAll, retainAll, toString 
  從類 java.lang.Object 繼承的方法 
finalize, getClass, notify, notifyAll, wait, wait, wait 
  從介面 java.util.List 繼承的方法 
containsAll, equals, hashCode, iterator, listIterator, listIterator, removeAll, retainAll, subList

ArrayList示例：

	public static void demo1() {
		ArrayList arr = new ArrayList();
		arr.add(new Student("張三", 23));
		arr.add(new Student("李四",24));
		
		System.out.println(arr);
		
		Iterator it = arr.iterator();
		while (it.hasNext()) {
			Student student = (Student) it.next();
			System.out.println(student.getName()+"..."+student.getAge());
		}
	}
 
	public static void demo() {
		ArrayList arr = new ArrayList();
		arr.add("a");
		arr.add("b");
		arr.add("c");
		arr.add("d");
		
		System.out.println(arr);
	}
 
}

七、LinkedList類

public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Queue<E>, Cloneable, Serializable

構造方法摘要

LinkedList() 
          構造一個空列表。 
LinkedList(Collection<? extends E> c) 
          構造一個包含指定集合中的元素的列表，這些元素按其集合的迭代器返回的順序排列。

方法摘要

 boolean add(E o) 
          將指定元素追加到此列表的結尾。 
 void add(int index, E element) 
          在此列表中指定的位置插入指定的元素。 
 boolean addAll(Collection<? extends E> c) 
          追加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序。 
 boolean addAll(int index, Collection<? extends E> c) 
          將指定集合中的所有元素從指定位置開始插入此列表。 
 void addFirst(E o) 
          將給定元素插入此列表的開頭。 
 void addLast(E o) 
          將給定元素追加到此列表的結尾。 
 void clear() 
          從此列表中移除所有元素。 
 Object clone() 
          返回此 LinkedList 的淺表複製。 
 boolean contains(Object o) 
          如果此列表包含指定元素，則返回 true。 
 E element() 
          找到但不移除此列表的頭（第一個元素）。 
 E get(int index) 
          返回此列表中指定位置處的元素。 
 E getFirst() 
          返回此列表的第一個元素。 
 E getLast() 
          返回此列表的最後一個元素。 
 int indexOf(Object o) 
          返回此列表中首次出現的指定元素的索引，如果列表中不包含此元素，則返回 -1。 
 int lastIndexOf(Object o) 
          返回此列表中最後出現的指定元素的索引，如果列表中不包含此元素，則返回 -1。 
 ListIterator<E> listIterator(int index) 
          返回此列表中的元素的列表迭代器（按適當順序），從列表中指定位置開始。 
 boolean offer(E o) 
          將指定元素新增到此列表的末尾（最後一個元素）。 
 E peek() 
          找到但不移除此列表的頭（第一個元素）。 
 E poll() 
          找到並移除此列表的頭（第一個元素）。 
 E remove() 
          找到並移除此列表的頭（第一個元素）。 
 E remove(int index) 
          移除此列表中指定位置處的元素。 
 boolean remove(Object o) 
          移除此列表中首次出現的指定元素。 
 E removeFirst() 
          移除並返回此列表的第一個元素。 
 E removeLast() 
          移除並返回此列表的最後一個元素。 
 E set(int index, E element) 
          將此列表中指定位置的元素替換為指定的元素。 
 int size() 
          返回此列表的元素數。 
 Object[] toArray() 
          以正確順序返回包含此列表中所有元素的陣列。 
<T> T[] 
 toArray(T[] a) 
          以正確順序返回包含此列表中所有元素的陣列；返回陣列的執行時型別即為指定陣列的類。

八、vector

public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

構造方法摘要

Vector() 
          構造一個空向量，使其內部資料陣列的大小為 10，其標準容量增量為零。 
Vector(Collection<? extends E> c) 
          構造一個包含指定集合中的元素的向量，這些元素按其集合的迭代器返回元素的順序排列。 
Vector(int initialCapacity) 
          使用指定的初始容量和等於零的容量增量構造一個空向量。 
Vector(int initialCapacity, int capacityIncrement) 
          使用指定的初始容量和容量增量構造一個空的向量

特有方法摘要

 boolean add(E o) 
          將指定元素追加到此向量的末尾。 
 void add(int index, E element) 
          在此向量的指定位置插入指定的元素。 
 boolean addAll(Collection<? extends E> c) 
          將指定 Collection 中的所有元素追加到此向量的末尾，按照指定集合的迭代器所返回的順序追加這些元素。 
 boolean addAll(int index, Collection<? extends E> c) 
          在指定位置將指定 Collection 中的所有元素插入到此向量中。 
 void addElement(E obj) 
          將指定的元件新增到此向量的末尾，將其大小增加 1。 
 int capacity() 
          返回此向量的當前容量。 
 void clear() 
          從此向量中移除所有元素。 
 Object clone() 
          返回向量的一個副本。 
 boolean contains(Object elem) 
          測試指定的物件是否為此向量中的元件。 
 boolean containsAll(Collection<?> c) 
          如果此向量包含指定 Collection 中的所有元素，則返回 true。 
 void copyInto(Object[] anArray) 
          將此向量的元件複製到指定的陣列中。 
 E elementAt(int index) 
          返回指定索引處的元件。 
 Enumeration<E> elements() 
          返回此向量的元件的列舉。 
 void ensureCapacity(int minCapacity) 
          增加此向量的容量（如有必要），以確保其至少能夠儲存最小容量引數指定的元件數。 
 boolean equals(Object o) 
          比較指定物件與此向量的相等性。 
 E firstElement() 
          返回此向量的第一個元件（位於索引 0 處的項）。 
 E get(int index) 
          返回向量中指定位置的元素。 
 int hashCode() 
          返回此向量的雜湊碼值。 
 int indexOf(Object elem) 
          搜尋給定引數的第一個匹配項，使用 equals 方法測試相等性。 
 int indexOf(Object elem, int index) 
          搜尋給定引數的第一個匹配項，從 index 處開始搜尋，並使用 equals 方法測試其相等性。 
 void insertElementAt(E obj, int index) 
          將指定物件作為此向量中的元件插入到指定的 index 處。 
 boolean isEmpty() 
          測試此向量是否不包含元件。 
 E lastElement() 
          返回此向量的最後一個元件。 
 int lastIndexOf(Object elem) 
          返回指定的物件在此向量中最後一個匹配項的索引。 
 int lastIndexOf(Object elem, int index) 
          向後搜尋指定的物件，從指定的索引處開始搜尋，並返回一個索引。 
 E remove(int index) 
          移除此向量中指定位置的元素。 
 boolean remove(Object o) 
          移除此向量中指定元素的第一個匹配項，如果向量不包含該元素，則元素保持不變。 
 boolean removeAll(Collection<?> c) 
          從此向量中移除包含在指定 Collection 中的所有元素。 
 void removeAllElements() 
          從此向量中移除全部元件，並將其大小設定為零。 
 boolean removeElement(Object obj) 
          從此向量中移除變數的第一個（索引最小的）匹配項。 
 void removeElementAt(int index) 
          刪除指定索引處的元件。 
protected  void removeRange(int fromIndex, int toIndex) 
          從此 List 中移除其索引位於 fromIndex（包括）與 toIndex（不包括）之間的所有元素。 
 boolean retainAll(Collection<?> c) 
          在此向量中僅保留包含在指定 Collection 中的元素。 
 E set(int index, E element) 
          用指定的元素替換此向量中指定位置處的元素。 
 void setElementAt(E obj, int index) 
          將此向量指定 index 處的元件設定為指定的物件。 
 void setSize(int newSize) 
          設定此向量的大小。 
 int size() 
          返回此向量中的元件數。 
 List<E> subList(int fromIndex, int toIndex) 
          返回此 List 的部分檢視，元素範圍為從 fromIndex（包括）到 toIndex（不包括）。 
 Object[] toArray() 
          返回一個數組，包含此向量中以正確順序存放的所有元素。 
<T> T[] 
 toArray(T[] a) 
          返回一個數組，包含此向量中以正確順序存放的所有元素；返回陣列的執行時型別為指定陣列的型別。 
 String toString() 
          返回此向量的字串表示形式，其中包含每個元素的 String 表示形式。 
 void trimToSize() 
          對此向量的容量進行微調，使其等於向量的當前大小。

vector 使用示例：

	public static void demo1() {
		Vector v = new Vector();
		v.add(new Student("張三", 23));
		v.add(new Student("李四", 24));
		v.add(new Student("王五", 25));
		
		Iterator it = v.iterator();
		while (it.hasNext()) {
			Object s = (Student) it.next();
			System.out.println(s);
		}
	}
	
	public static void demo() {
		Vector v = new Vector();
		v.add("a");
		v.add("b");
		v.add("c");
		v.add("d");
		
		System.out.println(v);
		System.out.println(v.capacity());
		System.out.println(v.size());
		System.out.println(v.contains("a"));
	}

相關推薦

集合框架之collection類詳解

一、集合框架的由來 Java 集合框架主要包括兩種型別的容器，一種是集合（Collection），儲存一個元素集合，另一種是圖（Map），儲存鍵/值對對映。Collection 介面又有 3 種子型別，List、Set和Queue，再下面是一些抽象類，最後是具體實現類，常用

Struts2框架之struts.xml詳解

Struts2框架之struts.xml詳解 文章目錄 Struts2框架之struts.xml詳解 一個struts.xml的配置示例 package標籤的配置 action標籤的配置 result標

梳理Python 框架之中介軟體詳解（用途和機制）

什麼是中介軟體？ 中介軟體是一個Python程式設計師用來處理Django的請求和響應的框架級別的鉤子，它是一個輕量，低級別的外掛系統，用於全域性範圍內改變Django的輸入，輸出。每個中介軟體元件都負責做一些特定的功能。 說的直白一點是中介軟體就是幫我們程式設計

OpenCV參考手冊之Mat類詳解（二）

譯文參考The OpenCV Reference Manual （Release 2.3）August 17 2011 Mat::~Mat Mat的解構函式。 C++: Mat::~Mat() 解構函式呼叫Mat::release()。 Mat::operato

媽媽再也不用擔心我的面試之String類詳解

其實在java中String並不能算是一個基本型別，迴歸到String的本質其實在jdk1.8以前他是一個final修飾的char陣列，1.9以後他是一個final修飾的byte陣列；由開發者將其封裝成String類；其實我們也可以從程式碼中來證明String是一個類的事實：

SQLite之CppSQLite3Query類詳解

資料庫中資料查詢 程式碼： CppSQLite3Queryquery = db.execQuery("select * fromtarget_table"); while(!query.eof()) { cout<<"name:"<<q

Java重要類之LinkList類詳解

一.LinkList概述 LinkedList是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。 LinkedList 實現 List 介面，能進行佇列操作。 LinkedList 實現Deq

Java集合框架之Collection例項解析

0、集合引入 1)集合的由來? Java是面向物件程式語言，經常需要操作很多物件，必要時需儲存物件（對Java語言而言，儲存的通常是物件的引用，以達到複用或管理等目的），常見容器如陣列和StringBuffer（執行緒安全但效率較低，為了提高效率而

JAVAORM框架之Mybatis (Ibatis) 詳解

agen r.java文件 conn soc 部分 ppr jdbc project shm 目錄 Mybatis基礎概念 Mybatis開放方式演進 Mybatis框架核心要點 關聯查詢 延遲加載(懶加載) 動態SQL Mybatis緩存 Mybatis逆向工程 Pag

Java集合框架 之Collection介面

Collection介面是集合的根介面，它有兩個子介面分別是List介面和Set介面。 Collection介面的具體實類有ArrayList，LinkedList等對集合元素的增，刪，改，查。 使用前需要匯入相應的包import java.util.*; (1)

unittest之TestCase類詳解

TestCase 測試用例類，我們做單元測試時編寫的測試用例就是繼承TestCase類來實現具體的測試用例 \ 例如： import unittest class UserCase(unittest.TestCase): def testAd

java基本型別、陣列、集合對應的包裝類詳解

本文主要是整理了近期所閱書籍而成。 第一個，基本型別的包裝類： 基本資料型別：byte，int，       short， long， boolean，char，       float，double等 包裝型別     ： Byte，Integer，Short，L

Android 網路框架之Retrofit2使用詳解及從原始碼中解析原理

就目前來說Retrofit2使用的已相當的廣泛，那麼我們先來了解下兩個問題： 1 . 什麼是Retrofit？ Retrofit是針對於Android/Java的、基於okHttp的、一種輕量級且安全的、並使用註解方式的網路請求框架。 2 . 我們為什麼要

OpenCV參考手冊之Mat類詳解1

類 Mat導言 OpenCV c + + n 維稠密陣列類 類 CV_EXPORTS Mat { public： / / … …很多的方法... ... int flags;（Note ：目前還不知道flags做什麼用的） //!陣列的維數，> =

JAVA 快取陣列之----ByteArrayInputStream類詳解

Java ByteArrayInputStream類 位元組陣列輸入流在記憶體中建立一個位元組陣列緩衝區，從輸入流讀取的資料儲存在該位元組陣列緩衝區中。建立位元組陣列輸入流物件有以下幾種方式。 接收位元組陣列作為引數建立： ByteArrayInputStream

Android資料庫三：xutils3框架之資料庫使用詳解！

1.新增依賴 compile 'org.xutils:xutils:3.5.0' 2.github地址 https://github.com/wyouflf/xUtils3 3.新增許可權 <uses-permission andro

unittest之TestSuite類詳解

TestSuite 測試套件類，如何理解測試套件這個概念呢，從它的類定義來看，可以理解為：多個獨立的測試用例（test case）或者多個獨立的測試套件（test suite，可以理解為子套件）可以構成一個測試套件，那麼我們寫好了一個用例之後，如果去構建一個測

重新開始學Java——集合框架之Collection

為什麼需要集合框架呢？因為之前使用陣列進行儲存物件的時候，會發現，經常不能夠確定大小的存在，那麼這裡就需要使用集合框架的存在。集合

java_集合體系之Collection框架相關抽象類介面詳解、原始碼——02

java_集合體系之Collection框架相關抽象類介面詳解、原始碼——02 一：Collection相關介面、抽象類結構圖   二：Collection相關         1、介面簡介：                   Collection作為佇列形式儲

java之集合類詳解

面試常見問題ArrayList和LinkedList的聯絡和區別                  1. ArrayList是實現了基於動態陣列的資料結構，LinkedList基於連結串列的資料結構。                  2. 對於隨機訪問get和set，Ar