集合框架（List容器）

>两大主流：collection、map（接口）

底层实现为数组和链表；

RationalRose工具：接口与典型实现类；

List :数据是有序的（时间上有序，存放时间顺序存放），可以存放重复元素；

Set：数据是无序的，不可以存放重复元素；

>ArrayList/Vector/LInkedList（区别是Vector是线程安全的，其他功能相同，都实现了相同的规范List）

注意：

即使在线程不安全的情况下，也不推荐使用Vector类（已经过时），而是使用Collections工具类将ArrayList转换成线程安全的类；

ArrayList与LinkedList的区别：ArrayList底层是使用数组存储的；LinkedList底层使用链表存储的；

链表：修改比较快，查找比较慢；

数组：查找比较快，修改比较慢；

 

ArrayList常用方法：

add();//添加一个元素；

addAll();//将一个容器中全部元素加入到当前list后面；

get();//得到指定位位置上的元素（不真正取出元素）；

remove();//拿出指定位置上的元素（取出元素）；

size();//返回长度；

ArrayList 中的ensureCapacity（int minCapticy）方法：

ensureCapacity(int minCapacity)           如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。

              

>自己实现一个简单的ArrayList

package com.ls.list;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList implements List {
	private int size = 10;
	private int current = 0;
	Object[] obj = new Object[size];

	/**
	 * 用来确定容量是否到达极限 这里涉及问题，如何扩充数组？ 新建一个更大的（比如两倍，将原来的数组中的拷贝过来）
	 * 
	 * @param minCapacity
	 */
	private void ensureCapcity(int minCapacity) {
		if (minCapacity > size) {
			// 数组放不下，需要扩充数组
			/**
			 * 新建一个长度为当前数组两倍的数组 
			 * 将原来数组中的内容拷贝到新的数组当中 
			 * 将全局变量的数组的引用指向新定义的数组,更新size
			 */
			// 下面注释的这种方式性能不行
			// Object[] newobj=new Object[size*2];
			// for (int i = 0; i < obj.length; i++) {
			// newobj[i]=obj[i];
			// }
			// obj=newobj;
			// size=size*2;
			/**
			 * System类的一个底层语言的native方法(不好用)
			 * Arrays类的方法；
			 */
			//System.arraycopy(src, srcPos, dest, destPos, length);
			obj= Arrays.copyOf(obj, size*2);
			size=size*2;
		} else {

		}

	}

	@Override
	public boolean add(Object e) {
		// 判段是否到达极限
		ensureCapcity(current + 1);
		// 添加一个数据；
		obj[current++] = e;
		return false;
	}

	@Override
	public void add(int index, Object element) {
		// TODO Auto-generated method stub

	}

	@Override
	public boolean addAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean addAll(int index, Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub

	}

	@Override
	public boolean contains(Object o) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean containsAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Object get(int index) {
		return obj[index];
	}

	@Override
	public int indexOf(Object o) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Iterator iterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int lastIndexOf(Object o) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public ListIterator listIterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public ListIterator listIterator(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean remove(Object o) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Object remove(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public boolean removeAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public boolean retainAll(Collection c) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public Object set(int index, Object element) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int size() {
		// 集合大小
		return current;
	}

	@Override
	public List subList(int fromIndex, int toIndex) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Object[] toArray() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Object[] toArray(Object[] a) {
		// TODO Auto-generated method stub
		return null;
	}

}

package com.ls.list;

import java.util.List;
//测试类
public class TestMyArray {
	
public static void showList(List list){
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
} 
	
public static void main(String[] args) {
	MyArrayList list=new MyArrayList();
	list.add("a");
	list.add("b");
	list.add("c");
	list.add("d");
	list.add("e");
	list.add("f");
	list.add("g");
	list.add("h");
	
	
	list.add("a");
	list.add("b");
	list.add("c");
	list.add("d");
	list.add("e");
	list.add("f");
	list.add("g");
	list.add("h");
	showList(list);
}
}

>自己实现一个简单的LinkedList

//LinkedList原码，内部类模拟一个节点：

>Queue接口（队列）

方法摘要
boolean	add(E e)           将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
E	element()           获取，但是不移除此队列的头。
boolean	offer(E e)           将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
E	peek()           获取但不移除此队列的头；如果此队列为空，则返回 null。
E	poll()           获取并移除此队列的头，如果此队列为空，则返回 null。
E	remove()           获取并移除此队列的头。

>Deque接口(双端队列)

方法摘要
boolean	add(E e)           将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
void	addFirst(E e)           将指定元素插入此双端队列的开头（如果可以直接这样做而不违反容量限制）。
void	addLast(E e)           将指定元素插入此双端队列的末尾（如果可以直接这样做而不违反容量限制）。
boolean	contains(Object o)           如果此双端队列包含指定元素，则返回 true。
Iterator	descendingIterator()           返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E	element()           获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
E	getFirst()           获取，但不移除此双端队列的第一个元素。
E	getLast()           获取，但不移除此双端队列的最后一个元素。
Iterator	iterator()           返回以恰当顺序在此双端队列的元素上进行迭代的迭代器。
boolean	offer(E e)           将指定元素插入此双端队列所表示的队列（换句话说，此双端队列的尾部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用的空间，则返回 false。
boolean	offerFirst(E e)           在不违反容量限制的情况下，将指定的元素插入此双端队列的开头。
boolean	offerLast(E e)           在不违反容量限制的情况下，将指定的元素插入此双端队列的末尾。
E	peek()           获取，但不移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
E	peekFirst()           获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
E	peekLast()           获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
E	poll()           获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。
E	pollFirst()           获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。
E	pollLast()           获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。
E	pop()           从此双端队列所表示的堆栈中弹出一个元素。
void	push(E e)           将一个元素推入此双端队列所表示的堆栈（换句话说，此双端队列的头部），如果可以直接这样做而不违反容量限制的话；如果成功，则返回 true，如果当前没有可用空间，则抛出 IllegalStateException。
E	remove()           获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）。
boolean	remove(Object o)           从此双端队列中移除第一次出现的指定元素。
E	removeFirst()           获取并移除此双端队列第一个元素。
boolean	removeFirstOccurrence(Object o)           从此双端队列移除第一次出现的指定元素。
E	removeLast()           获取并移除此双端队列的最后一个元素。
boolean	removeLastOccurrence(Object o)           从此双端队列移除最后一次出现的指定元素。
int	size()           返回此双端队列的元素数。

 

>LinkedList

LinkedList list=new LinkedList();

>List特征

list.add();

list.get();

>queue特征：进行插入操作的端称为队尾，进行删除操作的端称为队头。

list.add();

list.poll();//获取头，并移除；

list.peek();//获取头，不移除

>stack特征：仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。

list.add();

list.push();//压栈；

list.peek();//出栈；

>Deque特征：队头和队尾都可以进行插入，删除操作。

list.add();

list.addFirst();

list.addLast();

list.removeLast();

list.removefirst();

>LinkedList API文档

方法摘要
boolean	add(E e)           将指定元素添加到此列表的结尾。
void	add(int index, E element)           在此列表中指定的位置插入指定的元素。
boolean	addAll(Collection c)           添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
boolean	addAll(int index, Collection c)           将指定 collection 中的所有元素从指定位置开始插入此列表。
void	addFirst(E e)           将指定元素插入此列表的开头。
void	addLast(E e)           将指定元素添加到此列表的结尾。
void	clear()           从此列表中移除所有元素。
Object	clone()           返回此 LinkedList 的浅表副本。
boolean	contains(Object o)           如果此列表包含指定元素，则返回 true。
Iterator	descendingIterator()           返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E	element()           获取但不移除此列表的头（第一个元素）。
E	get(int index)           返回此列表中指定位置处的元素。
E	getFirst()           返回此列表的第一个元素。
E	getLast()           返回此列表的最后一个元素。
int	indexOf(Object o)           返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int	lastIndexOf(Object o)           返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
ListIterator	listIterator(int index)           返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
boolean	offer(E e)           将指定元素添加到此列表的末尾（最后一个元素）。
boolean	offerFirst(E e)           在此列表的开头插入指定的元素。
boolean	offerLast(E e)           在此列表末尾插入指定的元素。
E	peek()           获取但不移除此列表的头（第一个元素）。
E	peekFirst()           获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E	peekLast()           获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	poll()           获取并移除此列表的头（第一个元素）
E	pollFirst()           获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E	pollLast()           获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E	pop()           从此列表所表示的堆栈处弹出一个元素。
void	push(E e)           将元素推入此列表所表示的堆栈。
E	remove()           获取并移除此列表的头（第一个元素）。
E	remove(int index)           移除此列表中指定位置处的元素。
boolean	remove(Object o)           从此列表中移除首次出现的指定元素（如果存在）。
E	removeFirst()           移除并返回此列表的第一个元素。
boolean	removeFirstOccurrence(Object o)           从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
E	removeLast()           移除并返回此列表的最后一个元素。
boolean	removeLastOccurrence(Object o)           从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
E	set(int index, E element)           将此列表中指定位置的元素替换为指定的元素。
int	size()           返回此列表的元素数。
Object[]	toArray()           返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。
T[]	toArray(T[] a)           返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。