java SE基礎(Collection接口概述)
Collection接口相關集成關系例如以下圖
1。
關於可叠代接口(Iterable)
可叠代接口僅包括一個方法,返回一個在一組T類型元素上進行叠代的叠代器:
public abstract Iterator<T> iterator();
叠代器Iterator接口的方法聲明例如以下:
public interface Iterator<E>{ public abstract boolean hasNext(); //假設仍有元素能夠叠代,則返回 true public abstract E next(); //返回叠代的下一個元素 }
關於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(); //返回此列表元素的列表叠代器(按適當順序)。4。關於ListIterator<E>接口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(不包含)之間的部分視圖。
}
(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 實例的容量調整為列表的當前大小。(5)比如:此操作用來最小化 ArrayList 實例的存儲量
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){} //將指定元素插入此列表的開頭。(5)比如: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(){} //返回以逆向順序在此雙端隊列的元素上進行叠代的叠代器。
元素將按從最後一個到第一個的順序返回
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 的部分視圖,其元素大於等於 fromElement10。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接口概述)