天天看點
傳回

黑馬程式員：Java基礎——List集合的分支1.Vector中的枚舉2.LinkedList 3.ArrayList

------- Java EE教育訓練、 java教育訓練、期待與您交流！ ----------

1.Vector中的枚舉

枚舉就是Vector特有的取出方式。

發現枚舉和疊代器很像。其實枚舉和疊代是一樣的。

因為枚舉的名稱以及方法的名稱都過長，是以被疊代器取代了，枚舉郁郁而終了。

Vector中的方法與List集合中的方法大都相似，而Enumeration枚舉是Vector的特有方法。以下是Vector周遊的代碼示例：

public class VectorDemo {
    public static void sop(Object obj){
    	System.out.println(obj);
    }
	
	public static void main(String[] args) {
		Vector vec = new Vector();
		vec.add("Java01");
		vec.add("Java02");
		vec.add("Java03");
		vec.add("Java04");
		
		
		for(Enumeration enu = vec.elements();enu.hasMoreElements();){
			sop(enu.nextElement());
		}
	}
}

運作結果可想而知：

Java01

Java02

Java03

Java04

然而Vector現在已經被ArrayList所替代，是以通常我們不使用Vector集合。

2.LinkedList

LinkedList的特有方法：

addFirst();

addLast();

getFirst();

getLast();

擷取元素，但不删除元素，如果集合中沒有元素，會出現NoSuchElementException

removeFirst();

removeLast();

擷取元素，會删除元素，如果集合沒有元素，會出現NoSuchElementException

在JDK1.6出現了替代方法：

offerFirst();

offerLast();

peekFirst();

peekLast();

擷取元素，但不删除元素，如果集合中沒有元素，傳回Null。

pollFirst();

pollLast();

擷取元素，元素會被删除，如果集合沒有元素，傳回Null。

以下是示例代碼，注意，NoSuchELementException我用try,catch方法抓掉了：

import java.util.LinkedList;
import java.util.NoSuchElementException;

public class LinkedListDemo {

	public static void sop(Object obj) {
		System.out.println(obj);
	}

	public static void main(String[] args) {
		for(int i=0;i<2;i++){
			if(i==0){
				method_6();		
			}else{
				method();
			}
		}
	}

	public static void method() {
		LinkedList lList = new LinkedList();

		lList.add("Java");
		lList.addFirst("Java01");
		lList.addLast("Java02");

		sop("--原有方法--");
		sop("添加後lList集合裡有："+lList);

		for(int i=0;i<2;i++){
			if(i==0){
				sop("擷取(get)第一個元素："+lList.getFirst());
				sop("擷取(get)最後一個元素："+lList.getLast());
				sop("最後剩下："+lList);
				sop("");
			}else{
				sop("擷取并移除(remove)第一個元素："+lList.removeFirst());
				sop("擷取并移除(remove)最後一個元素："+lList.removeLast());
				sop("最後剩下："+lList);
				
				sop("最後這麼搞：");
				sop("連續兩次擷取并移除(remove)第一個元素："+lList.removeFirst());
				try{
				    sop(lList.removeFirst());
				}catch(NoSuchElementException e){
					sop("這裡NoSuchElementException異常抛出，我用try,catch抓了。");
				}
			}
		}
	}
	
	public static void method_6(){
		LinkedList lList = new LinkedList();
		int iNum = 100;
		sop("--1.6新方法--");
		lList.add(iNum);
		sop("offerFirst也可以這麼玩："+lList.offerFirst("Java01"));
		lList.offerLast("Java02");
		sop("添加後lList集合裡有："+lList);
		
		for(int i=0;i<2;i++){
			if(i==0){
				sop("擷取(peek)第一個元素："+lList.peekFirst());
				sop("擷取(peek)最後一個元素："+lList.peekLast());
				sop("最後剩下："+lList);
				sop("");
			}else{
				sop("擷取并移除(poll)第一個元素："+lList.pollFirst());
				sop("擷取并移除(poll)最後一個元素："+lList.pollLast());
				sop("最後剩下："+lList);
				
				sop("最後這麼搞：");
				sop("連續兩次擷取并移除(poll)第一個元素："+lList.pollFirst());
				sop("輸出："+lList.pollFirst());
				sop("========================================");
			}
		}
	}
}

輸出結果如下：

黑馬程式員：Java基礎——List集合的分支1.Vector中的枚舉2.LinkedList 3.ArrayList

我們針對LinkedList做個練習，要求如下：

使用LinkedList模拟一個堆棧或者隊列資料結構。

堆棧：先進後出 如同一個杯子

隊列：先進先出 FIFO(First in First out)如同一個水管

這裡是源代碼，需要注意的是，有些方法被分裝：

public class LinkedListTest {
	public static void main(String[] args) {
		Method med = new Method();		
		Scanner scan = new Scanner(System.in);
		
		Method.sop("請輸入要輸入的字元串長度：");
		int iFor = scan.nextInt();
		Method.sop("請輸入字元串：");
		for(int i=0;i<iFor;i++){
			med.add(scan.next());
		}
		Method.sop("請輸入正反向(正向敲1，反向敲2)：");
		int iFlag = scan.nextInt();
		
		Method.sop("結果為：");
		med.result(iFlag);
	}
}

class Method{
	private LinkedList list;
	Method(){
		list=new LinkedList();
	}
	
	public void add(Object obj){
		list.addFirst(obj);
	}
	
	public Object getQueue(){
		return list.removeFirst();
	}
	
	public Object getStack(){
		return list.removeLast();
	}
	
	public Boolean isNull(){
		return list.isEmpty();
	}
	
	public void result(int iFlag){
    		while(!isNull()){
			if(iFlag==1){
				sop(getStack());
			}else{
				sop(getQueue());
			}
    		}
 	}
	
	public static void sop(Object obj){
    		System.out.println(obj);
   	}
}

以下是運作結果：

黑馬程式員：Java基礎——List集合的分支1.Vector中的枚舉2.LinkedList 3.ArrayList

3.ArrayList

關于ArrayList呢，我們前面已經見過了，這裡就直接做練習：

練習1：去除ArrayList集合中的重複元素

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ArrayListTest {

	public static void main(String[] args) {
		ArrayList aList = new ArrayList();
		aList.add("Java01");
		aList.add("Java02");
		aList.add("Java03");
		aList.add("Java01");
		aList.add("Java02");
		aList.add("Java01");
		
		sop(aList);
		aList = simpleElement(aList);
		sop(aList);
	}
	
	public static ArrayList simpleElement(ArrayList al){
		ArrayList newAl = new ArrayList();//new一個新的數組
		//進行周遊判斷，并寫入新的數組
		for(Iterator it = al.iterator();it.hasNext();){
			Object object = it.next();
			if(!newAl.contains(object)){
				newAl.add(object);
			}
		}
		return newAl;  //傳回到主函數
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

運作結果為：

[Java01, Java02, Java03, Java01, Java02, Java01]

[Java01,Java02,Java03]

練習2：将自定義對象作為元素存到ArrayList集合中，并去除重複元素。

例如：存人對象，同姓名同年齡視為同一人，為重複元素

思路：

 1.對人描述，将資料封裝進對象

 2.定義容器，将人存入

 3.取出。

依照思路一步一步來，我們得到以下代碼：

public class ArrayListPersonTest{
    public static void main(String[] args) {
    	
    	ArrayList aList = new ArrayList();
		
		
		aList.add(new Person("ZhangSan",17));
		aList.add(new Person("LiSi",21));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("ZhangSan",17));
		
		aList = simpleElement(aList);
		
		for(Iterator it = aList.iterator();it.hasNext();){
			Person p = (Person)it.next();   //it.next()是Object類，需要進行強轉
			sop("姓名："+p.getsName()+"，年齡："+p.getiAge());  //調用get方法來擷取包裝内容
		}
	}
    
    public static void sop(Object obj){
    	System.out.println(obj);
    }
    
    public static ArrayList simpleElement(ArrayList aList){
    	//建立一個緩存數組來進行比較
    	ArrayList temp = new ArrayList();
    	
    	for(Iterator it = aList.iterator();it.hasNext();){
    		Object obj = it.next();
    		//判斷緩存數組裡面是否已經包含obj所含内容
    		if(!temp.contains(obj)){
    			temp.add(obj);
    		}
    	}
    	return temp;
    }
}

class Person{
	private String sName;
	private int iAge;
	
	Person(){}
	Person(String sName,int iAge){
		this.sName=sName;
		this.iAge=iAge;
	}
		
	public String getsName() {
		return sName;
	}
	public void setsName(String sName) {
		this.sName = sName;
	}
	public int getiAge() {
		return iAge;
	}
	public void setiAge(int iAge) {
		this.iAge = iAge;
	}
}

通過運作我們發現結果令人出乎意料——相同的項目并沒有被删除，也就是說我們的去除重複是失敗的。

這時，我們需要重寫equals方法

以下是重寫後的全部代碼：

public class ArrayListPersonTest{
    public static void main(String[] args) {
    	
    	ArrayList aList = new ArrayList();
		
		
		aList.add(new Person("ZhangSan",17));
		aList.add(new Person("LiSi",21));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("Wangwu",22));
		aList.add(new Person("ZhangSan",17));
		
		aList = simpleElement(aList);
		
		for(Iterator it = aList.iterator();it.hasNext();){
			Person p = (Person)it.next();   //it.next()是Object類，需要進行強轉
			sop("姓名："+p.getsName()+"，年齡："+p.getiAge());  //調用get方法來擷取包裝内容
		}
	}
    
    public static void sop(Object obj){
    	System.out.println(obj);
    }
    
    public static ArrayList simpleElement(ArrayList aList){
    	//建立一個緩存數組來進行比較
    	ArrayList temp = new ArrayList();
    	
    	for(Iterator it = aList.iterator();it.hasNext();){
    		Object obj = it.next();
    		//判斷緩存數組裡面是否已經包含obj所含内容
    		if(!temp.contains(obj)){
    			temp.add(obj);
    		}
    	}
    	return temp;
    }
}

class Person{
	private String sName;
	private int iAge;
	
	Person(){}
	Person(String sName,int iAge){
		this.sName=sName;
		this.iAge=iAge;
	}
	
	//這裡需要重寫Object類中的equals方法
	public boolean equals(Object obj){
//java中的instanceof運算符是用來在運作時指出對象是否是特定類的一個執行個體。
//instanceof通過傳回一個布爾值來指出，這個對象是否是這個特定類或者是它的子類的一個執行個體。
		if(!(obj instanceof Person)){   
			return false;
		}
		Person p = (Person)obj;
		//System.out.println(this.sName+"...."+p.sName);
		//調用String的equals對比
		return this.sName.equals(p.sName) && this.iAge==p.iAge;
	}
	
	public String getsName() {
		return sName;
	}
	public void setsName(String sName) {
		this.sName = sName;
	}
	public int getiAge() {
		return iAge;
	}
	public void setiAge(int iAge) {
		this.iAge = iAge;
	}
}

通過運作，我們發現重複的去掉了，這是為什麼呢？

因為List集合判斷元素是否相同（無論是contains還是remove），依據是元素的equals方法。而在我們重寫之前，equals比的是Person的位址，因為Person是一個Object，每一個Person的位址都是new過的，位址值是不可能相同的。我們重寫的目的就是要調用String的equals來比較其值是否相同。

我們把

System.out.println(this.sName+"...."+p.sName);

的注釋取消掉。

結果為下圖：

黑馬程式員：Java基礎——List集合的分支1.Vector中的枚舉2.LinkedList 3.ArrayList

可以發現，值與值在挨個比較，直到找到相同的為止。



黑馬入學Blog List集合 黑馬程式員 linkedlist arraylist vector
上一篇: 黑馬程式員_集合架構_4
下一篇: 黑馬程式員_集合架構（一）

繼續閱讀