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();            //返回迭代的下一个元素}

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();//以正向遍历列表时，如果列表迭代器有多个元素，则返回 trueboolean 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){}//返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1protected  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对象,默认容量为10for(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();//获取迭代器，遍历hashsetwhile(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();//获取迭代器，遍历hashsetwhile(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使用其元素的自然顺序,则返回nullE first();//返回此 set 中当前第一个(最低)元素E last();//返回此 set 中当前最后一个(最高)元素SortedSet<E> subSet(E from, E to);//返回此 set 的部分视图，其元素从 from(包括)到 to(不包括)SortedSet<E> headSet(E toElement);//返回此 set 的部分视图，其元素严格小于 toElementSortedSet<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 具有相同映射关系和相同排序的新 TreeSetE ceiling(E e){}//返回此set中 >=e 的最小元素；如果不存在这样的元素，则返回 nullE floor(E e){}//返回此set中 <=e 的最大元素；如果不存在这样的元素，则返回 nullE higher(E e){}//返回此set中 >e 的最小元素；如果不存在这样的元素，则返回 nullE lower(E e){}//返回此set中 <e 的最大元素；如果不存在这样的元素，则返回 nullComparator<? super E> comparator(){}//返回对此set中的元素进行排序的比较器；如果此set使用其元素的自然顺序，则返回 nullIterator<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;}@Overridepublic 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();}@Overridepublic int compare(Person arg0, Person arg1) {return arg0.getAge() - arg1.getAge();}/*@Overridepublic 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 popSystem.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();}}