Java集合框架（一）

·······················································································································
在C++里面有STL库用于对内存的预开辟，而在Java里面有集合复合框架而框架的设计目标是为了储存对象方便对多数对象的调用和操作。在Java的java.util包下。
集合框架是一个用了代表操作和的同一架构。所有的集合框架内容如下

• 接口 是集合的抽象数据类型。为了以不同的方式操作集合对象。
• 实现类 是对集合接口的具体实现，是可以实例化的对象。
• 算法 是实现类里面方法内部的优化计算，例如：排序，搜索等。

集合框架的容器分两类集合一种是集合（Collection），用于储存集合元素。另一种是图类型的（Map），储存键和映射值。

集合

Collection接口

Collection是基本集合的根接口，一个Collection代表一组Object，Java里面没有直接继承Collection的类只有继承与子接口的类。
Collection的方法如下：

• int size() //返回集合的当前元素个数
• boolean isEmpty() //判断集合是否为空
• boolean contains(Object o) //查找o是否在集合当中
• boolean containsAll(Collection<?> c) // 查询集合c中的所有元素是否在该集合
• Iterator iterator() //返回一个迭代器
• Object[] toArray() //将集合转化为数组包含该集合的所有元素
• T[] toArray(T[] a) //与上一个不同的是如果传入的数组长度小于集合的大小，就会创建一个新的数组拷贝数据并返回。如果数组大小大于等于集合的大小就直接将数据拷贝进去。
• boolean add(E e) //向集合中添加对象
• boolean addAll(Collection<? extends E> c)//将c集合中的所有元素添加到该集合
• boolean remove(Object o) //移除指定的对象
• boolean removeAll(Collection<?> c)//从该集合中移除c集合中有的元素
• boolean retainAll(Collection<?> c) //从该集合中删除c集合不包含的元素
• void clear()//移除所有元素
• boolean equals(Object o)// 用于判断o类型和内部数据是否与该集合相同
• int hashCode() //返回该集合的哈希值，主要作用是为了配合基于散列的集合一起正常运行

List接口

List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。
List 接口存储一组不唯一，有序（插入顺序）的对象。他有父类的方法也有自己定义的其他方法

• E get(int index) //返回List指定位置的元素
• boolean addAll(int index,Collection c)//将集合c的元素添加到指定的位置
• int indexOf(Object o)//返回第一个出现元素o的位置.
• Object set(int index,Object element)//用元素element取代位置index上的元素,返回被取代的元素
• void sort(Comparator<? super E> c) //容器的排序函数，需要的排序方法进行重载

ArrayList

ArrayList类似于动态数组，该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
用例：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<Integer> lis=new ArrayList<Integer>();
		lis.add(1);//添加元素
		lis.add(3);
		lis.add(100);
		lis.add(8);
		System.out.println("lis集合的长度："+lis.size());
		System.out.println("lis元素：");
		for(int i:lis) {//循环打印
			System.out.print(i+" ");
		}
		lis.sort(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o1<o2?1:-1;
			}
		});
		System.out.println("排序后：");
		for(int i:lis) {//循环打印
			System.out.print(i+" ");
		}
		System.out.println("lis 0 位置的元素"+lis.get(0));
		lis.clear();
	}

LinkedList

是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。他也实现了List，Deque，Cloneable，Serializable等接口允许有null（空）元素，可以克隆。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。LinkedList 查找效率低。
增加的方法：

• boolean add(E o)/offer(E o) //在链表尾部添加元素(add与offer的区别在于当超出界限的时候add()回报异常，offer()方法只返回false。)

• boolean addFirst(E o)/offerFirst(E e)//在链表头部添加元素

• boolean addLast(E e)/offerLast(E e)//在链表尾部添加元素

• E peek()//查询最后一个元素

• E peekFirst()//查询头部元素

• E peekLast()//查询尾部部元素

• E element()//查询头部元素（与peek()的区别在于当队列为空的时候element会抛出异常，peek返回null）

• E poll()//删除头部元素并返回对应的值（不抛出异常）

• E pollFirst()//删除头部元素并返回对应的值

• E pollLast()//删除尾部元素并返回对应的值

• E pop()//删除头部元素并返回对应的值

• E remove()//删除头部元素并返回对应的值（抛出异常）

• E removeFirst()//删除头部元素并返回对应的值

• E removeLast()删除尾部部元素并返回对应的值

• boolean removeFirstOccurrence(Object o)//方法删除指定元素第一次出现在该列表中(遍历从头部到尾部列表时)。如果列表中不包含该元素，它是不变的。

• boolean removeLastOccurrence(Object o)方法删除指定元素最后一次出现在该列表中(遍历从头部到尾部列表时)。如果列表中不包含该元素，它是不变的。

• Object clone()//拷贝

• Iterator descendingIterator()//方法返回一个迭代器在此双端队列以逆向顺序的元素

• E get(int location)//获取指定位置的元素

• E getFirst()//获取头部与元素

• E getLast()//获取尾部元素

• int indexOf(Object object)//方法被用于搜索给定参数的第一次出现位置

• int lastIndexOf(Object object)//方法被用于搜索给定参数的最后一次出现位置

• ListIterator listIterator(int location)//方法返回一个列表迭代器在此列表中的元素(按适当顺序)，从列表中的指定位置。

用例：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		LinkedList<Integer> lis=new LinkedList<Integer>();
		lis.offer(1);//添加元素
		lis.add(3);
		lis.add(100);
		lis.offerFirst(8);
		lis.offerLast(2);
		System.out.println("lis集合的长度："+lis.size());
		System.out.println("lis元素：");
		for(int i:lis) {//循环打印
			System.out.print(i+" ");
		}
		Iterator<Integer> x = lis.listIterator(0);
		System.out.println("lis元素->迭代打印：");
		 while (x.hasNext()) {
	         System.out.print(x.next()+" ");
	      }

		//lis.peek();
		System.out.println("\n获取1位置的元素"+lis.indexOf(1));
		System.out.println("\n获取头元素"+lis.pop());
		lis.clear();
	}

Vector

Vector类实现了一个动态数组。实现了list接口的部分方法和ArrayList和相似，但是两者是不同的。如果事先不知道数组的大小，或者只需要一个可以在程序的生命周期内改变大小的数据，那么Vector是非常合适的。
构造函数

构造函数	方法
Vector()	此构造函数创建一个默认向量，其初始大小为10。
Vector(int size)	此构造函数接受等于所需大小的参数，并创建一个初始容量由size指定的向量。
Vector(int size, int incr)	此构造函数创建一个向量，初始容量由size指定，增量由incr指定。 增量指定每次向量调整向量时要分配的元素数。
Vector(Collection c)	此构造函数创建一个包含集合c的元素的向量。

增加的方法：

• void addElement(Object obj) //将指定的对象添加到末尾，并使其大小加一
• int capacity() //返回当前容量
• void copyInto(Object[] anArray) //将向量中的元素复制到指定数组中
• Object elementAt(int index) //返回指定的元素
• void insertElementAt(Object obj, int index) //在指定位置中插入元素
• void removeAllElements() //移除所有元素并将大小设置为0
• boolean removeElement(Object obj) //移除第一个小于等于obj的元素
• protected void removeRange(int fromIndex, int toIndex) //删除索引介于fromIndex(包含)到toIndex(不包含)之间的所有元素。
• void setSize(int newSize) //设置向量大小
• List subList(int fromIndex, int toIndex)//返回在fromIndex(包含)和toIndex(不包含)之间的元素并转化到List当中去。
• String toString()//将向量的元素用字符串表示
• void trimToSize() //将此向量的容量调整为向量的当前大小。
• Enumeration elements()//返回向量的枚举

Stack

Stack是继承于Vector的实体类Stack是栈，它的特性是：先进后出
Stack除了从Vector继承的方法还有其他自定义的方法：

• boolean empty()//检测堆栈是否为空为空就返回true否则为false
• Object peek()//返回栈顶元素，但不会将其删除
• Object pop()//返回位于堆栈顶部的元素，在这个过程中去除它
• Object push(Object element)//元素入栈
• int search(Object element)//搜索元素，如果存在则返回偏移量，否则返回1。

 public static void main(String[] args){
        Stack<Integer> ts=new Stack<Integer>();
		ts.push(1);//添加元素
		ts.push(2);
		ts.push(16);
		System.out.println("查找16的位置:    "+ts.search(1));
		while(!ts.empty())
		{

			System.out.println(ts.pop());
		}

    }