1. 程式人生 > >java SE基礎(Collection接口概述)

java SE基礎(Collection接口概述)

tracking 方向遍歷 urn cts tail 正常 hset ati elements

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

技術分享

1。

關於可叠代接口(Iterable)
可叠代接口僅包括一個方法,返回一個在一組T類型元素上進行叠代的叠代器:

public abstract Iterator<T> iterator();

叠代器Iterator接口的方法聲明例如以下:

public interface Iterator<E>{
    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<E> extends Collection<E>{
	Iterator<E> iterator();						//返回按適當順序在列表的元素上進行叠代的叠代器
	ListIterator<E> listIterator();				//返回此列表元素的列表叠代器(按適當順序)。

ListIterator<E> listIterator(int index); //返回列表中元素的列表叠代器(按適當順序)。從列表的指定位置開始 E set(int index, E element); //用指定元素替換列表中指定位置的元素(可選操作 E get(int index); //返回列表中指定位置的元素 void add(int index, E element); //在列表的指定位置插入指定元素(可選操作) List<E> subList(int fromIndex, int toIndex) //返回列表中指定的 fromIndex(包含 )和 toIndex(不包含)之間的部分視圖。

}

4。關於ListIterator<E>接口
(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<E> extends Iterator<E>{
	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<Integer>();	//創建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<Integer> iterator = arraylist.iterator();			//叠代器遍歷
		while(iterator.hasNext()){
			System.out.print(iterator.next()+"\t");
		}
		System.out.println();
		
		arraylist.trimToSize();										//將此 ArrayList 實例的容量調整為列表的當前大小
		
		ListIterator<Integer> 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<E> listIterator(int index){} //返回此列表中的元素的列表叠代器,從列表中指定位置開始 public Iterator<E> descendingIterator(){} //返回以逆向順序在此雙端隊列的元素上進行叠代的叠代器。

元素將按從最後一個到第一個的順序返回

(5)比如:

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

public class MyLinkedList {
	
	public static void main(String[] args) {
		LinkedList<Integer> linkedlist = new LinkedList<Integer>();//創建鏈接列表對象
		
		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 Set<E>extends Collection<E>{
	 Iterator<E> iterator();		//返回在此 set 中的元素上進行叠代的叠代器
	 int size();					//返回 set 中的元素數
}
8。HashSet類
(1)不包括反復元素、同意一個null、線程不同步
(2)此類由HashMap實例支持,不保證叠代順序恒久不變
(3)部分方法
public boolean add(E e){}			//假設此 set 中尚未包括指定元素,則加入指定元素
public Iterator<E> 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<Integer> hashset = new HashSet<Integer>();					//創建散列集合類對象
		
		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<? super E> comparator();			//返回對此set中的元素進行排序的比較器;假設此set使用其元素的自然順序,則返回null
E first();									//返回此 set 中當前第一個(最低)元素
E last();									//返回此 set 中當前最後一個(最高)元素
SortedSet<E> subSet(E from, E to);			//返回此 set 的部分視圖,其元素從 from(包含)到 to(不包含)
SortedSet<E> headSet(E toElement);			//返回此 set 的部分視圖,其元素嚴格小於 toElement
SortedSet<E> tailSet(E fromElement);		//返回此 set 的部分視圖,其元素大於等於 fromElement
10。TreeSet類
(1)不包括反復元素、不同意null、線程不同步
(2)使用元素的自然順序對元素進行排序,或者依據創建 set 時提供的 Comparator 進行排序,詳細取決於使用的構造方法,元素必須是可比較的
(3)此實現為基本操作(add、remove 和 contains)提供受保證的 log(n) 時間開銷
(4)部分方法
public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, Serializable{
	public TreeSet(){}									//構造一個新的空set,該set依據其元素的自然順序進行排序
	public TreeSet(Comparator<? super E> comparator){}	//構造一個新的空 TreeSet。它依據指定比較器進行排序
	public TreeSet(Collection<? extends E> c){}			//構造一個包括指定 collection 元素的新 TreeSet,它依照其元素的自然順序進行排序
	public TreeSet(SortedSet<E> 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中 <e 的最大元素。假設不存在這種元素。則返回 null
	
	Comparator<? super E> comparator(){}				//返回對此set中的元素進行排序的比較器。假設此set使用其元素的自然順序。則返回 null
	
	Iterator<E> iterator(){}							//返回在此 set 中的元素上按升序進行叠代的叠代器
	Iterator<E> 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<Integer> treeset = new TreeSet<Integer>();			//創建樹集合對象
		
		Random r = new Random();
		for(int i =0 ; i < 15 ; i++)								//加入元素
			treeset.add( r.nextInt(50) );
		
		Iterator<Integer> iterator = treeset.iterator();			//獲取叠代器。正向遍歷元素
		while(iterator.hasNext())
			System.out.print( iterator.next()+"\t" );
		System.out.println();
		
		Iterator<Integer> 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<Person>{
	
	public static void main(String[] args) {
		TreeSet<Person> treeset = new TreeSet<Person>(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<Person> 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<E> extends AbstractList<E> implements List<E>, 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<E> 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<Integer> vector = new Vector<Integer>();			//創建無參向量對象
		
		Random r = new Random();											//初始化向量對象
		for(int i = 0 ; i < 9 ; i++)
			vector.add( r.nextInt(30) );
		
		Iterator<Integer> iterator = vector.iterator();					//獲取叠代器,遍歷向量
		while(iterator.hasNext())
			System.out.print(iterator.next()+"\t");
		System.out.println();
		
		Enumeration<Integer> 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<E> extends Vector<E>{
	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<Integer> stack = new Stack<Integer>();				//創建棧
		
		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();
	}
}
 

java SE基礎(Collection接口概述)