集合框架的list一脉

*collection是所有集合的父类接口，具有增{add(),addAll(),}，删{remove
(),removeAll(),clear()},查{contains(),containsAll(),isEmpty(),size()},取交集
retainAll(),遍历iterator(),哈希码hasCode(),比较equals(),
*collection
|-List:元素是有序的，可以重复的。因为该集合体系有索引。
|-ArrayList：底层是数组结构。java1.2版本，线程不同步。查
找很快，增删稍慢慢
|-LinkedList：底层是链式数据结构。查找很慢，增删很快
|-Vector：底层同ArrayList，java1.0版本，线程是同步的。被
ArrayList替代了。增删改查都很慢。
|-Set：元素是无序的，不可以重复的。
*List:
特有的方法。凡是可以操作角标的方法都是该体系特有的方法。
增add(index,element);addAll(index,Collection)
删remove(index)
改set(index,element)
查get(index),subList(from,to),listIterator()
*在迭代过程中不能使用除迭代器中的方法以外的方法对集合中的元素进行操作。因
为迭代之后容器中的元素有两个用户，集合类和迭代器共同持有这些元素的资源。
如果这是在迭代器中进行集合的增删改查会引起并发异常。
*List集合特有的迭代器ListIterator是Iterator的子接口，在迭代时不可以通过集合
对象的方法操作集合中的元素会发生ConcrrentModificationException异常。所以
，在迭代器时只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能进行
判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子
接口，ListIterator。该接口只能通过List集合的listIterator方法获取
*枚举就是Vector特有的取出方式。其实枚举和迭代是一样的。枚举的名称和方法的
名称都过长了所以被迭代器取代了。
*Vector：特有方法：只要是带有element的都是
增：addElement(E)，copy到指定数组：copyInto(Object[])，
insertElementAt(obj,index)
删：removeElementAt(index),移除全部removeAllElements()
查：elements，firstElement(),capacity(),elementAt(index)

import java.util.Enumeration;
import java.util.Vector;

public class VectorTest {

public static void main(String[] args) {

Vector<String> v=new Vector<String>();

v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");

Enumeration<String> en=v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
}

}
*ArrayList：特有的方法
1.构造器 ArrayList() 构造一个初始容量为 10 的空列表。
2.返回ArrayList实例的浅表副本：clone()
3.增：增加容量：ensureCapacity(minCapacity)，
4.删：removeRange(from,to)
5.改：trimToSize()将此ArrayList实例的容量调整为列表当前大小。
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest {
/*
* 去除ArrayList集合中的重复元素
*/
public static void main(String[] args) {
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java01");
al.add("java02");
al.add("java03");

System.out.println(al);
al=singleElement(al);
System.out.println(al);
}
public static ArrayList singleElement(ArrayList al){
//定义一个临时容器
ArrayList newAl=new ArrayList();
Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if(!newAl.contains(obj)){
newAl.add(obj);
}
}
return newAl;
}
}

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest2 {

/*
* 将自定义对象作为元素存储到ArrayList集合当中，并去除重复元素
* 比如：存人对象，同姓名同年龄，视为同一个人，为重复元素
*
* 思路：
* 1.对人描述，将数据封装进人对象。
* 2.定义容器，将人存入。
* 3.取出。
*
* List集合判断元素是否相同，依据的是元素的equals方法
*/
public static void main(String[] args) {
ArrayList al=new ArrayList();
al.add(new Person("zhangsan01",30));
al.add(new Person("zhangsan02",31));
al.add(new Person("zhangsan02",31));
al.add(new Person("zhangsan03",32));
al.add(new Person("zhangsan04",33));
al.add(new Person("zhangsan04",33));

al=singleElement(al);

Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
Person person=(Person)obj;
System.out.println(person.getName
()+"::"+person.getAge());
}
}
public static ArrayList singleElement(ArrayList al){
//定义一个临时容器
ArrayList newAl=new ArrayList();
Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if(!newAl.contains(obj)){
newAl.add(obj);
}
}
return newAl;
}

}
class Person{
private String name;
private int age;
Person(String name,int age){
this.name=name;
this.age=age;
}
public boolean equals(Object obj){
if(!(obj instanceof Person))
return false;
Person p=(Person)obj;
return this.name.equals(p.name) && this.age==p.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

LinkedList:特有方法
1.addFirst();addLast();
2.getFirst();getLast();//获取元素，但不删除元素。如果集合中没有元素
，会出现NoSuchElementException.
3.removeFirst;removeLast();//获取元素，并删除元素。如果集合中没有
元素，会出现NoSuchElementException.
*在JDK1.6中出现了替代方法
1.offer(E)添加到末尾，offerFirst(E),offerLast(E)
2.peek()头,peekFirst();peekLast();获取元素，但不删除元素。如果集合
中没有元素会返回null。
3.poll()头,pollFirst(),pollLast()；获取元素，但不删除元素。如果集合中
没有元素会返回null
import java.util.LinkedList;

/*
*
* 使用LinkedList模拟一个堆栈或者队列数据结构
* 堆栈：先进后出。如同一个装糖的瓶子
* 队列：先进先出。First in First out FIFO。如同水管
*
*/
class Queue{
private LinkedList link;
Queue(){
link=new LinkedList();
}
public void myAdd(Object obj){
link.addFirst(obj);
}
public Object myGet(){
return link.removeLast();
}
public boolean isNull(){
return link.isEmpty();
}
}
public class LinkedListTest {

public static void main(String[] args) {
Queue q1=new Queue();
q1.myAdd("java01");
q1.myAdd("java02");
q1.myAdd("java03");
q1.myAdd("java04");
while(!q1.isNull()){
System.out.println(q1.myGet());
}
}
}