Collection接口相关集成关系如下图
1。关于可迭代接口(Iterable)
可迭代接口仅包含一个方法,返回一个在一组T类型元素上进行迭代的迭代器：
public abstract Iterator<T> iterator();迭代器Iterator接口的方法声明如下：
public interface Iterator<E>{
public abstract boolean hasNext(); //如果仍有元素可以迭代，则返回 true
public abstract E next(); //返回迭代的下一个元素
}所有通用的 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（不包括）之间的部分视图。
}
(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 返回的最后一个元素
}
(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 实例的存储量
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();
}
}
(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(){} //返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。元素将按从最后一个到第一个的顺序返回
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();
}
}
(1)不包含重复元素、最多包含一个null
(2)接口声明(部分)：
public interface Set<E>extends Collection<E>{
Iterator<E> iterator(); //返回在此 set 中的元素上进行迭代的迭代器
int size(); //返回 set 中的元素数
}
(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() );
}
}
(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
(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 元素上按降序进行迭代的迭代器
}
/*例一*/
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();
}*/
}
(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(不包括)之间的所有元素
}
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());
}
}
(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(){} //测试堆栈是否为空
}
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();
}
}
3609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
