程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> java SE基礎(Collection接口概述)

java SE基礎(Collection接口概述)

編輯：JAVA綜合教程

java SE基礎(Collection接口概述)

Collection接口相關集成關系如下圖

1。關於可迭代接口(Iterable)
可迭代接口僅包含一個方法,返回一個在一組T類型元素上進行迭代的迭代器：

public abstract Iterator iterator();

迭代器Iterator接口的方法聲明如下：

public interface Iterator{
    public abstract boolean hasNext();        //如果仍有元素可以迭代，則返回 true
    public abstract E        next();            //返回迭代的下一個元素
}

2。關於Collection接口
所有通用的 Collection 實現類提供兩個構造方法：
(1)無參數構造方法，用於創建空 collection；
(2)帶有Collection 類型單參數的構造方法，用於創建一個具有與其參數相同元素新的 collection。
3。關於List接口
(1)有序的 collection(也稱為序列),此接口的用戶可以對列表中每個元素的插入位置進行精確地控制
(2)列表通常允許重復的元素,如果列表本身允許 null 元素的話，通常它們允許多個 null 元素
(3)List接口提供了特殊的迭代器ListIterator，除了允許 Iterator 接口提供的正常操作外，還允許元素插入和替換，以及雙向訪問
(4)List部分方法

public interface List extends Collection{
	Iterator iterator();						//返回按適當順序在列表的元素上進行迭代的迭代器
	ListIterator listIterator();				//返回此列表元素的列表迭代器（按適當順序）。
	ListIterator listIterator(int index);	//返回列表中元素的列表迭代器（按適當順序），從列表的指定位置開始
	E set(int index, E element);				//用指定元素替換列表中指定位置的元素（可選操作
	E get(int index);							//返回列表中指定位置的元素
	void add(int index, E element);				//在列表的指定位置插入指定元素（可選操作）
	List subList(int fromIndex, int toIndex)	//返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。
}

4。關於ListIterator接口
(1)列表迭代器,允許按任一方向遍歷列表、迭代期間修改列表，並獲得迭代器在列表中的當前位置。
(2)ListIterator沒有當前元素；它的光標位置始終位於調用previous()所返回的元素和調用next()所返回的元素之間。
Element(0) Element(1) Element(2) ... Element(n-1)
cursor positions: ^ ^ ^ ^ ^ ^
(3)remove()和set(Object)方法不是根據光標位置定義的；它們是根據對調用next()或previous()所返回的最後一個元素的操作定義的
(4)ListIterator部分方法

public interface ListIterator extends Iterator{
	boolean hasNext();				//以正向遍歷列表時，如果列表迭代器有多個元素，則返回 true
	boolean hasPrevious();			//如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true 
	
	E next();						//返回列表中的下一個元素
	E previous();					//返回列表中的前一個元素
	
	int nextIndex();				//返回對 next 的後續調用所返回元素的索引
	int previousIndex();			//返回對 previous 的後續調用所返回元素的索引
	
	void add(E e);					//新元素被插入到隱式光標前：該元素直接插入到 next 返回的下一個元素的前面,或者 previous 返回的下一個元素之後,
									//不影響對 next 的後續調用，並且對 previous 的後續調用會返回此新元素
									
	void set(E e);					//用指定元素替換 next 或 previous 返回的最後一個元素
	void remove();					//從列表中移除由 next 或 previous 返回的最後一個元素
}

5。關於ArrayList類
(1)可包含重復元素、值允許為null、線程不同步
(2)每個 ArrayList 實例都有一個容量,隨著向 ArrayList 中不斷添加元素,其容量也自動增長。
在添加大量元素前，應用程序可以使用 ensureCapacity 操作來增加 ArrayList 實例的容量。這可以減少遞增式再分配的數量。
(3)ArrayList實例的線程同步一般通過對封裝該列表的對象進行同步操作來完成；
如果不存在這樣的對象，則應該使用 Collections.synchronizedList 方法將該列表“包裝”起來。
List list = Collections.synchronizedList(new ArrayList(...));
(4)ArrayList部分方法

public void ensureCapacity(int minCapacity){}		//增加此ArrayList實例的容量，以確保它至少能夠容納minCapacity所指定的元素數。
public void add(int index, E element){}				//將指定的元素插入此列表中的指定位置
public int indexOf(Object o){}						//返回此列表中首次出現的指定元素的索引，或如果此列表不包含元素，則返回 -1
protected  void removeRange(int from, int to){}		//移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素
public void trimToSize(){}							//將此 ArrayList 實例的容量調整為列表的當前大小。此操作用來最小化 ArrayList 實例的存儲量

(5)例如:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class MyArrayList {
	
	public static void main(String[] args) {
		ArrayList< Integer> arraylist = new ArrayList();	//創建ArrayList對象,默認容量為10
		for(int i = 0 ; i < 15 ; i++){								//初始化數組列表內容
			arraylist.add(i);
		}
		
		Object[] arr =arraylist.toArray();							//獲取arraylist內容，存放在數組中
		for (Object object : arr) {									//遍歷數組，輸出
			System.out.print( (int)object +"\t");
		}
		System.out.println();
		
		System.out.println(arraylist.size());						//查詢此時arraylist元素個數
		
		System.out.println(arraylist.contains(15));					//查詢是否包含某一元素
		arraylist.add(5, -1);										//指定位置插入元素
		arraylist.add(15);											//末尾插入元素
		System.out.println(arraylist.contains(15));					//查詢是否包含某一元素
		
		arr =arraylist.toArray();									//獲取arraylist內容，存放在數組中
		for (Object object : arr) {									//遍歷數組，輸出
			System.out.print( (int)object +"\t");
		}
		System.out.println();
		
		arraylist.set(5, 1);										//改變指定位置的元素
		arraylist.remove(16);										//移除指定位置的元素
		arraylist.remove(15);	
		arraylist.remove(arraylist.lastIndexOf(1));
		
		Iterator iterator = arraylist.iterator();			//迭代器遍歷
		while(iterator.hasNext()){
			System.out.print(iterator.next()+"\t");
		}
		System.out.println();
		
		arraylist.trimToSize();										//將此 ArrayList 實例的容量調整為列表的當前大小
		
		ListIterator listiterator = arraylist.listIterator();	//使用ListIterator遍歷元素
		System.out.println(listiterator.hasPrevious());
		while(listiterator.hasNext()){
			System.out.print( listiterator.next()+"\t" );
		}
		System.out.println();
		while(listiterator.hasPrevious()){
			System.out.print( listiterator.previous()+"\t" );
		}
		System.out.println();
		
		listiterator.next();										//替換元素
		listiterator.next();
		listiterator.set(-1);
		
		while(listiterator.hasPrevious())							//指針回到列表頭
			listiterator.previous();
		
		while(listiterator.hasNext())								//遍歷
			System.out.print( listiterator.next()+"\t" );
		System.out.println();
	}
}

6。LinkedList類
(1)可包含重復元素、值允許為null、線程不同步
(2)除了實現 List 接口外，LinkedList 類還為在列表的開頭及結尾 get、remove 和 insert 元素提供了統一的命名方法。
這些操作允許將鏈接列表用作堆棧、隊列或雙端隊列
(3)此類的 iterator 和 listIterator 方法返回的迭代器是快速失敗的：在迭代器創建之後，如果從結構上對列表進行修改，
除非通過迭代器自身的 remove 或 add 方法，其他任何時間任何方式的修改，迭代器都將拋出 ConcurrentModificationException
(4)LinkedList部分方法

public void addFirst(E e){}				//將指定元素插入此列表的開頭。
public void addLast(E e){}				//將指定元素添加到此列表的結尾

public E getFirst(){}					//返回此列表的第一個元素
public E getLast(){}					//返回此列表的最後一個元素

public E removeFirst(){}				//移除並返回此列表的第一個元素
public E removeLast(){}					//移除並返回此列表的最後一個元素

public ListIterator listIterator(int index){}	//返回此列表中的元素的列表迭代器,從列表中指定位置開始
public Iterator descendingIterator(){}			//返回以逆向順序在此雙端隊列的元素上進行迭代的迭代器。元素將按從最後一個到第一個的順序返回

(5)例如：

import java.util.Iterator;
import java.util.LinkedList;

public class MyLinkedList {
	
	public static void main(String[] args) {
		LinkedList linkedlist = new LinkedList();//創建鏈接列表對象
		
		for(int i =0 ; i < 15 ; i++){							//初始化
			linkedlist.add(i);
		}
		
		Iterator iterator = linkedlist.iterator();//獲取迭代器，遍歷鏈接列表
		while(iterator.hasNext()){
			System.out.print( iterator.next()+"\t" );
		}
		System.out.println();
		
		linkedlist.addFirst(15);//開頭添加元素
		System.out.println( linkedlist.removeLast() );//末尾刪除元素
		
		iterator = linkedlist.iterator();//獲取迭代器，遍歷鏈接列表
		while(iterator.hasNext()){
			System.out.print( iterator.next()+"\t" );
		}
		System.out.println();
		
		Iterator descendingiterator = linkedlist.descendingIterator();	//獲取逆向迭代器
		while(descendingiterator.hasNext())
			System.out.print( descendingiterator.next()+"\t" );
		System.out.println();
	}
}

7。Set接口
(1)不包含重復元素、最多包含一個null
(2)接口聲明(部分)：

public interface Setextends Collection{
	 Iterator iterator();		//返回在此 set 中的元素上進行迭代的迭代器
	 int size();					//返回 set 中的元素數
}

8。HashSet類
(1)不包含重復元素、允許一個null、線程不同步
(2)此類由HashMap實例支持,不保證迭代順序恆久不變
(3)部分方法

public boolean add(E e){}			//如果此 set 中尚未包含指定元素，則添加指定元素
public Iterator iterator(){}		//返回對此 set 中元素進行迭代的迭代器
public boolean remove(Object o){}	//如果指定元素存在於此 set 中，則將其移除

(4)例如

import java.util.HashSet;
import java.util.Iterator;

public class MyHashSet {
	
	public static void main(String[] args) {
		HashSet hashset = new HashSet();					//創建散列集合類對象
		
		for(int i =0 ; i < 15 ; i++)										//添加元素
			hashset.add(i);
		hashset.add(null);
		
		Iterator iterator = hashset.iterator();								//獲取迭代器，遍歷hashset
		while(iterator.hasNext())
			System.out.print( iterator.next()+"\t" );
		System.out.println();
		
		System.out.println( hashset.size() ); 								//返回集合中的元素個數
		System.out.println( hashset.contains(10) );							//測試集合
		System.out.println( hashset.add(10) );								//添加重復元素
		System.out.println( hashset.add(15) );								//添加不重復元素
		System.out.println( hashset.remove(0) );							//移除已有元素
		System.out.println( hashset.remove(0) );							//移除不存在元素

		iterator = hashset.iterator();										//獲取迭代器，遍歷hashset
		while(iterator.hasNext())
			System.out.print( iterator.next()+"\t" );
		System.out.println();
		
		
		System.out.println( hashset.isEmpty() );
		hashset.clear();													//清空集合
		System.out.println( hashset.isEmpty() );
	}
}

9。SortedSet接口
(1)元素不允許為null
(2)元素使用其自然順序進行排序,或者根據在創建有序set時提供的Comparator進行排序;該set的迭代器將按元素升序遍歷set
(3)插入有序set的所有元素都必須實現Comparable接口,所有這些元素都必須是可互相比較的
(4)所有有序set實現類都應該提供4個構造方法：
1)無參數構造方法,它創建一個空的有序set,按照元素的自然順序進行排序
2)帶有一個Comparator類型參數的構造方法,它創建一個空的有序set,根據指定的比較器進行排序
3)帶有一個Collection類型參數的構造方法,它創建一個新的有序set,其元素與參數相同,按照元素的自然順序進行排序
4)帶有一個SortedSet類型參數的構造方法,它創建一個新的有序set,其元素和排序方法與輸入的有序set相同
(5)部分方法

Comparator comparator();			//返回對此set中的元素進行排序的比較器;如果此set使用其元素的自然順序,則返回null
E first();									//返回此 set 中當前第一個(最低)元素
E last();									//返回此 set 中當前最後一個(最高)元素
SortedSet subSet(E from, E to);			//返回此 set 的部分視圖，其元素從 from(包括)到 to(不包括)
SortedSet headSet(E toElement);			//返回此 set 的部分視圖，其元素嚴格小於 toElement
SortedSet tailSet(E fromElement);		//返回此 set 的部分視圖，其元素大於等於 fromElement

10。TreeSet類
(1)不包含重復元素、不允許null、線程不同步
(2)使用元素的自然順序對元素進行排序，或者根據創建 set 時提供的 Comparator 進行排序，具體取決於使用的構造方法，元素必須是可比較的
(3)此實現為基本操作（add、remove 和 contains）提供受保證的 log(n) 時間開銷
(4)部分方法

public class TreeSet extends AbstractSet implements NavigableSet, Cloneable, Serializable{
	public TreeSet(){}									//構造一個新的空set,該set根據其元素的自然順序進行排序
	public TreeSet(Comparator comparator){}	//構造一個新的空 TreeSet，它根據指定比較器進行排序
	public TreeSet(Collection c){}			//構造一個包含指定 collection 元素的新 TreeSet,它按照其元素的自然順序進行排序
	public TreeSet(SortedSet s){}					//構造一個與指定有序 set 具有相同映射關系和相同排序的新 TreeSet
	
	E ceiling(E e){}									//返回此set中 >=e 的最小元素；如果不存在這樣的元素，則返回 null
	E floor(E e){}										//返回此set中 <=e 的最大元素；如果不存在這樣的元素，則返回 null
	E higher(E e){}										//返回此set中 >e 的最小元素；如果不存在這樣的元素，則返回 null
	E lower(E e){}										//返回此set中  comparator(){}				//返回對此set中的元素進行排序的比較器；如果此set使用其元素的自然順序，則返回 null
	
	Iterator iterator(){}							//返回在此 set 中的元素上按升序進行迭代的迭代器
	Iterator descendingIterator(){}					//返回在此 set 元素上按降序進行迭代的迭代器
}

(5)例如

/*例一*/
import java.util.Iterator;
import java.util.Random;
import java.util.TreeSet;

public class MyTreeSet {
	
	public static void main(String[] args) {
		TreeSet treeset = new TreeSet();			//創建樹集合對象
		
		Random r = new Random();
		for(int i =0 ; i < 15 ; i++)								//添加元素
			treeset.add( r.nextInt(50) );
		
		Iterator iterator = treeset.iterator();			//獲取迭代器，正向遍歷元素
		while(iterator.hasNext())
			System.out.print( iterator.next()+"\t" );
		System.out.println();
		
		Iterator desciterator = treeset.descendingIterator();//獲取迭代器，逆向遍歷元素
		while(desciterator.hasNext())
			System.out.print( desciterator.next()+"\t" );
		System.out.println();
	}
}

/*例二*/
public class Person{
	private int number = 0;
	private int age = 0;
	
	public Person(int number , int age) {
		this.number = number;
		this.age = age;
	}
	
	public int getAge() {
		return age;
	}
	public int getNumber() {
		return number;
	}
	
	@Override
	public String toString() {
		return "["+this.number+","+this.age+"]";
	}
}

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
import java.util.Random;

public class TreeSetCom implements Comparator{
	
	public static void main(String[] args) {
		TreeSet treeset = new TreeSet(new TreeSetCom());	//創建樹集合
		
		Random age = new Random();
		Random num = new Random();
		
		for(int i  = 0 ; i < 15 ; i++)										//添加元素
			treeset.add(new Person(num.nextInt(30), age.nextInt(20)));
		
		Iterator iterator = treeset.iterator();						//獲取迭代器，遍歷元素
		while(iterator.hasNext())
			System.out.print( iterator.next().toString()+"--" );
		System.out.println();
	}

	@Override
	public int compare(Person arg0, Person arg1) {
		return arg0.getAge() - arg1.getAge();
	}
	
/*	@Override
	public int compare(Person arg0, Person arg1) {
		return arg0.getNumber() - arg1.getNumber();
	}*/
}

11。Vector類
(1)允許重復、允許null、線程同步
(2)基於數組
(3)Vector 的 elements 方法返回的 Enumeration 不是快速失敗的
(4)如果容量的增量小於等於零，則每次需要增大容量時，向量的容量將增大一倍
(5)部分方法

public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable{
	public Vector(){}						//構造一個空向量，使其內部數據數組的大小為 10，其標准容量增量為零			
	public Vector(int initialCapacity){}	//使用指定的初始容量和等於零的容量增量構造一個空向量
	public Vector(int initialCapacity,int capacityIncrement){}	//使用指定的初始容量和容量增量構造一個空的向量
	
	public void ensureCapacity(int minCapacity){}		//增加此向量的容量,以確保其至少能夠保存最小容量參數指定的組件數
	public void setSize(int newSize){}	//設置此向量的大小。如果新大小大於當前大小,則會在向量的末尾添加相應數量的 null 項;
										//如果新大小小於當前大小，則丟棄索引 newSize 處及其之後的所有項
	public Enumeration elements(){}	//返回此向量的組件的枚舉。返回的Enumeration對象將生成此向量中的所有項,第一項為索引0處的項,然後是索引1處的項...
	public void addElement(E obj){}		//將指定的組件添加到此向量的末尾，將其大小增加 1。如果向量的大小比容量大，則增大其容量
	
	public E get(int index){}			//返回向量中指定位置的元素
	public E set(int index,E element)	//用指定的元素替換此向量中指定位置處的元素
	protected void removeRange(int from,int to){}	//從此 List 中移除其索引位於from(包括)與to(不包括)之間的所有元素
}

(6)例如

import java.util.Enumeration;
import java.util.Vector;
import java.util.Iterator;
import java.util.Random;

public class MyVector {
	public static void main(String[] args) {
		
		Vector vector = new Vector();			//創建無參向量對象
		
		Random r = new Random();											//初始化向量對象
		for(int i = 0 ; i < 9 ; i++)
			vector.add( r.nextInt(30) );
		
		Iterator iterator = vector.iterator();					//獲取迭代器，遍歷向量
		while(iterator.hasNext())
			System.out.print(iterator.next()+"\t");
		System.out.println();
		
		Enumeration enumeration = vector.elements();	//獲取向量組件的枚舉，遍歷向量
		while( enumeration.hasMoreElements() )
			System.out.print( enumeration.nextElement()+"\t" );
		System.out.println();
		
		System.out.println( vector.size() );									//對向量容量的操作
		System.out.println( vector.capacity() );
		vector.setSize(12);
		System.out.println(vector.size());
		vector.trimToSize();
		System.out.println(vector.capacity());
		
		vector.addElement(null);
		vector.add(10, 9);
		vector.add(13);
		iterator = vector.iterator();					//獲取迭代器，遍歷向量
		while(iterator.hasNext())
			System.out.print(iterator.next()+"\t");
		System.out.println();
		
		System.out.println(vector.capacity());
		System.out.println(vector.size());
	}
}

12。Stack類
(1)Stack類表示堆棧,對類Vector進行了擴展,提供了push、pop操作
(2)部分方法

public class Stack extends Vector{
	public Stack(){}			//創建一個空堆棧
	
	public E push(E item){}		//把項壓入堆棧頂部
	public E pop(){}			//移除堆棧頂部的對象,並作為此函數的值返回該對象
	
	public E peek(){}			//查看堆棧頂部的對象,但不從堆棧中移除它
	
	public int search(Object o){}	//對象到堆棧頂部的位置,以 1 為基數；返回值 -1 表示此對象不在堆棧中
	
	public boolean empty(){}	//測試堆棧是否為空
}

(3)例如

import java.util.Stack;
import java.util.Iterator;

public class MyStack {
	public static void main(String[] args) {
		Stack stack = new Stack();				//創建棧
		
		for(int i = 0 ; i < 11 ; i++)												//初始化棧
			stack.add(i);
		
		Iterator iterator = stack.iterator();									//獲取迭代器，遍歷棧
		while(iterator.hasNext())
			System.out.print( iterator.next()+"\t" );
		System.out.println();
		
		System.out.println( stack.search(4) );	 							//查詢元素到棧頂的距離
		System.out.println( stack.search(15) );
		
		System.out.println( stack.capacity() );
		System.out.println( stack.size() );
		
		System.out.println( stack.push(10) );//push and pop
		System.out.println( stack.push(11) );
		
		iterator = stack.iterator();									//獲取迭代器，遍歷棧
		while(iterator.hasNext())
			System.out.print( iterator.next()+"\t" );
		System.out.println();
		
		System.out.println( stack.peek() );
		System.out.println( stack.pop() );
		
		iterator = stack.iterator();									//獲取迭代器，遍歷棧
		while(iterator.hasNext())
			System.out.print( iterator.next()+"\t" );
		System.out.println();
		
		while( !stack.isEmpty() )//依次出棧
			System.out.print( stack.pop()+"\t" );
		System.out.println();
	}
}