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();
}
}
