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;
}
}
~~~
