Collection
|--List:元素之间有序，且可以重复。
|--ArrayList: 使用数组存储的数据结构。增删慢，查询快。注意：此实现不是同步的
|--LinkedList: 使用链表存储的数据结构。增删快，查询慢。
|--Vector: 使用数组存储的数据结构。是同步到，访问速度较慢，被ArrayList所替代。
|--Set:元素之间无序，不可以重复。
### List集合提供的方法
增
add(index,element)//在指定位置插入指定元素
addAll(index,Collection)//指定位置插入集合
删
remove(int index)
移除列表中指定位置的元素（可选操作）。
改
set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。
查
iterator() 查找元素
listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
subList(int fromIndex, int toIndex)
返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
List集合特有的迭代器：ListIterator迭代器。
---listIterator是Iterator的子类接口。可以允许程序员按照任意方向遍历数据、修改数据、添加数据。
---Iterator迭代器只能够向下遍历数据，删除数据。如果要修改数据会出现ConcurrentModificationException异常
ListIterator提供的方法：
-->hasPrevious() 是否有前一个元素
-->previous()获取前一个元素
-->void remove()
从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。 -->void set(E e)
用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。 -->add()添加元素
~~~
import java.util.*;
public class ListDemo{
public static void main(String []args){
//List list = method_Add();
//method_it(list);
//sop(list);
method_ArrayList();
}
public static void method_ArrayList(){
ArrayList al = new ArrayList();
sop(al.size());
}
public static List method_Add(){
List list = new ArrayList();
list.add("java1--->name");
list.add("java2--->name");
list.add("java3--->name");
list.add(2,"java4--->name"); //在制定位置插入
return list;
}
public static void method_it(List list){
//通过iteraror遍历元素
ListIterator li = list.listIterator();
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("java3--->name"))
li.add("i love xy");
sop(obj);
}
while(li.hasPrevious()){
Object obj1 = li.previous();
sop("逆序--"+obj1);
}
/**此处会抛出ConcurrentModificationException异常
Iterator it = list.iterator();
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("java3--->name")){
list.add("i love xuYan");
}
sop(obj);
}**/
}
public static void sop(Object obj){
System.out.println(obj);
}
}
~~~
### ArrayList和Vector的异同：
1、相同点：两者都是使用数组存储的数据结构。
2、不同点：
2.1 ArrayList是1.1版本以后出现的，其执行效率高于Vector。
2.2 Vector是线程同步的，ArrayList是线程不同步的。
2.3 ArrayList和Vector默认初始容量是10，扩充容量时，ArrayList以50%扩充，而Vector以100%扩充。
2.4 Vector支持枚举类型。ArrayList不支持枚举。
枚举(Enumeration)其实和迭代器(Iterator)类似。
不过在1.1版本以后，Iterator中的方法名比较短，代替了枚举的方法。
~~~
import java.util.*;
public class VectorDemo{
public static void main(String args[]){
Vector v = new Vector();
v.add("hello");
v.add("world");
v.add("hi");
v.add("java");
Enumeration en = v.elements(); //获取枚举类型的数据
while(en.hasMoreElements()){
System.out.println("遍历枚举类型的数据："en.nextElement());
}
}
}
~~~
### LinkedList提供的方法：
JDK1.6以后提供的方法
增
offerFirst(E e)
在此列表的开头插入指定的元素。
offerLast(E e)
在此列表末尾插入指定的元素。
删
pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
pollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
改
set(int index, E element)
将此列表中指定位置的元素替换为指定的元素。
查
peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
peekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
~~~
import java.util.*;
public class LinkedListDemo{
public static void main(String args[]){
LinkedList ll = new LinkedList();
ll.offerFirst("java1");
ll.offerFirst("java2");
ll.offerFirst("java3");
ll.offerFirst("java4");
sop(ll);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
~~~
练习：在LinkedList的基础上封装一个自己使用的堆栈和队列的数据结构
堆栈特征--->先进后出
队列特征--->先进先出
~~~
import java.util.*;
class DuiLie{
LinkedList link;
public DuiLie(){
link = new LinkedList();
}
/*
添加队列中的数据。
*/
public void myAdd(Object obj){
link.offerFirst(obj);
}
/*
获取队列中的数据。以link链表中的最后一个数据取出
*/
public Object myGet(){
return link.pollLast();
}
public boolean isNull(){
return link.isEmpty();
}
}
class Zhan{
LinkedList link;
public Zhan(){
link = new LinkedList();
}
/*
添加队列中的数据。
*/
public void myAdd(Object obj){
link.offerFirst(obj);
}
/*
获取队列中的数据。以link链表中的最后一个数据取出
*/
public Object myGet(){
return link.pollFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}
public class LinkedListDemo{
public static void main(String args[]){
Zhan dl = new Zhan();
dl.myAdd("java1");
dl.myAdd("java2");
dl.myAdd("java3");
dl.myAdd("java4");
while(!dl.isNull()){
sop(dl.myGet());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
~~~
练习：去除ArrayList中的相同对象元素。即：姓名和年龄相同的步骤：
1、构造Person类，定义姓名、年龄两个属性，重写equals方法。
2、将Person对象存储到ArrayList集合中。
3、将对象一个个的取出。
4、定义一个新的集合，将就集合中的数据放入新集合，在此之前先判断新集合中是否存在该数据。
~~~
import java.util.*;
class Person{
private String name ;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public int getAge(){
return this.age;
}
public String getName(){
return this.name;
}
//因为要比较的是Person类中的name和age值，所以重写Object类的equals方法，
public boolean equals(Object obj){
//如果传入的对象不是Person类，直接返回false
if(!(obj instanceof Person))
return false;
//否则强转成Person类
Person p = (Person)obj;
//返回name和age的比较值。
return this.name.equals(p.getName()) && this.age == p.getAge();
}
}
public class ArrayListDemo{
public static void main(String args[]){
ArrayList al = new ArrayList();
//Person p = new Person();
al.add(new Person("lzl",18));
al.add(new Person("lzl1",18));
al.add(new Person("lzl2",18));
al.add(new Person("lzl3",18));
al.add(new Person("lzl",18));
al = sigleElements(al);
Iterator it = al.iterator();
while(it.hasNext()){
Person p = (Person)it.next();
sop(p.getName()+"---"+p.getAge());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
/*
去除相同的元素
*/
public static ArrayList sigleElements(ArrayList al){
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while((it.hasNext())){
Object obj = it.next();
//如果新链表中不存在P对象的元素，则添加。
if(!newAl.contains(obj)){
sop("---");
newAl.add(obj);
}
}
return newAl;
}
}
~~~
