java SE基础(Collection接口概述)

关于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（不包含）之间的部分视图。

}

                            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 返回的最后一个元素
}

                在加入大量元素前。应用程序能够使用 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();
	}
}

                这些操作同意将链接列表用作堆栈、队列或双端队列
            (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();
	}
}				

public interface Set<E>extends Collection<E>{
	 Iterator<E> iterator();		//返回在此 set 中的元素上进行迭代的迭代器
	 int size();					//返回 set 中的元素数
}

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

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

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

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(不包含)之间的全部元素
}

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

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