1. 程式人生 > >JAVA常用集合框架用法詳解基礎篇一之Colletion介面

JAVA常用集合框架用法詳解基礎篇一之Colletion介面

首先,在學習集合之前我們能夠使用的可以儲存多個元素的容器就是陣列。

下面舉幾個例子主要是引出集合類的:

1、8,4,5,6,7,55,7,8  像這樣的型別相同的可以使用陣列來儲存,本例可以用int[] arr來儲存。

2、”zhnagsan”,true,68 像這樣的可以使用StringBuilder或者StringBuffer來儲存,但最終需要使用.toString()的方法轉換成字串才可以使用。即 變為:”zhnagsantrue68”。

3、”李四”,25  像這樣的可以使用物件來儲存,如: new Person(“李四”,25);


一、為什麼要使用集合呢,那什麼時候需要使用集合類呢??????

1.集合類的由來:

物件用來封裝特有的資料,物件多了需要儲存,或者物件的個數不確定,就使用集合容器進行儲存。原來集合是用來儲存個數不確定的物件的。這一點是陣列做不到的。

2.集合的特點:

--是用於儲存物件的容器;

--集合的長度是可變的;

--集合中不可以儲存基本的資料型別(如:int、 char、 boolean之類的),一般我們可以將基本資料型別進行裝箱處理,然後在儲存在集合中。

 

接下來用一幅圖表示集合的整體框架:


3、集合容器因內部的資料結構不同,有多種具體容器。不斷向上抽取,就形成了集合框架。

我們先詳細的說說框架的頂層Collection介面:

Collection的常見方法:

---新增。

boolean add(Object obj); //新增一個物件

boolean addAll(Collection  coll);//新增一個集合


</pre><pre name="code" class="html">程式碼如下:
package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testAdd {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定義List物件
		List<String> list=new ArrayList<String>();//定義另一個List物件	
		allList.add("hello");//使用從Collection介面中繼承的方法
		allList.add(0, "world");//此方法為List自己擴充套件的方法
		System.out.println(allList);
		list.add("LL");
		list.add("www.ll.com");
		allList.addAll(list);//增加一組物件,此方法是從父類繼承的
		System.out.println(allList);
		allList.addAll(1, list);//在指定的位置上,進行增加一組物件。此方法是List介面自己擴充套件的方法
		System.out.println(allList);
	}

}

---刪除

boolean remove(Object  obj);
boolean removeAll(Collection coll);
void  clear();//將集合中的元素清空
程式碼如下:
package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testRemove {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//例項化一個List物件
		allList.add("kello");
		allList.add("joke");
		allList.add("www.ll.com");
		allList.add("world");
		System.out.println(allList);//輸出List物件中的元素
		allList.remove(0);//刪除指定位置的內容
		System.out.println(allList);
		allList.remove("joke");//刪除指定的內容
		System.out.println(allList);
	}

}

---判斷

boolean contains(Object obj);//是否包含
boolean  containsAll(Collection coll);
boolean  isEmpty();//判斷集合中是否含有元素
程式碼如下:
package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testSizeAndGet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定義並例項化List物件
		allList.add("world");
		allList.add("world");
		allList.add("kkorld");
		allList.add("pprld");
		allList.add("lllrld");
		allList.add("wqwld");
		System.out.println("從前向後輸出:");
		for(int i=0;i<allList.size();i++){
			System.out.println(allList.get(i)+"..");
		}
		
		System.out.println("從後向前輸出:");
		for(int i=allList.size()-1;i>=0;i--){
			System.out.println(allList.get(i)+"..");
		}
	}

}

---獲取

int size();//獲取集合中元素的個數
Iterator iterator();//取出元素的方式,使用的是迭代器
Object get(int i);

程式碼如下:

package com.ll.list;

import java.util.ArrayList;
import java.util.List;

public class testSizeAndGet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定義並例項化List物件
		allList.add("world");
		allList.add("world");
		allList.add("kkorld");
		allList.add("pprld");
		allList.add("lllrld");
		allList.add("wqwld");
		System.out.println("從前向後輸出:");
		for(int i=0;i<allList.size();i++){
			System.out.println(allList.get(i)+"..");
		}
		
		System.out.println("從後向前輸出:");
		for(int i=allList.size()-1;i>=0;i--){
			System.out.println(allList.get(i)+"..");
		}
	}

}

我們再來測試一下迭代器Iterator的用法。

程式碼如下:

package com.ll.list;

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

/*
 * 迭代輸出:Iterator
 * 是最常用的的集合輸出操作
 * 但是隻能進行單向的從前向後輸出
 */
public class testIterator {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();
		allList.add("hello");
		allList.add("world");
		allList.add("__ll__");
		//直接例項化一個Iterator介面
		System.out.println("刪除前的集合"+allList.toString());
		Iterator<String> it=allList.iterator();
		while(it.hasNext()){//判斷是否還有元素
			String str=it.next();
			if("__ll__".equals(str)){
				it.remove();//使用remove方法刪除指定的元素
			}
			else{
				System.out.print(str+"、");//next()方法用來取出當前元素
			}
		}
		System.out.println("\n刪除後的集合"+allList.toString());
	}

}

----其他

boolean retainAll(Collection coll);//取與coll集合的交集
Object[]  toArray();將集合轉成物件陣列<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>

4、Collection是介面,所以只能通過子類來例項化。如:Collection coll=new ArrayList();

注意:這裡會稍微提一下之前的迭代輸出的程式碼。迭代輸出有兩種寫法,如下:

法一:

       Iterator it=coll.iterator();

       while(it.hasnext){

       system.out.println(it.next());

       }

法二:

       for(Iterator it=coll.iterator;it.hasnext();){

       system.out.println(it.next());

       }

比較兩種方法,我們會注意到while()迴圈結束後,it會一直佔著記憶體不放,而for迴圈不會出現這種情況。

5、迭代器的原理

迭代器,取出元素的物件,該物件必須依賴具體的容器。因為每一個容器的資料結構是不同的。所以該迭代器是在容器中進行內部的實現。對於使用容器而言,具體的實現不重要,只要通過容器獲取到該實現的迭代器的物件即可。也就是iterator方法。Iterator介面就是對所有Collection容器進行元素取出的公共介面。

補充:接下來補充一個Collection.Sort()方法的例項:可以看看程式碼

//collection.sort()方法的測試類,這個類還需要Students類和一個自定義比較器//Studentscomparator類

package com.wq.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

import javax.swing.text.html.ListView;

/**
 * 將要完成
 * 1.通過Collections.sort(),對Integer泛型的List集合進行排序
 * @author LULEI
 *
 */

public class CollectionsTest {
	
	/**
	 * 通過Collections.sort(),對Integer泛型的List集合進行排序
	 * 使用Random類來生成不相等的隨機數10個
	 */
	public void testListSort1(){
	List<Integer> integer=new ArrayList<Integer>();
		Random random=new Random();  //產生一個隨機種子物件
		int k=0;
		//生成10個隨機數
		for(int i=0;i<10;i++){
			do{
				k=random.nextInt(100);//生成100以內的一個隨機數
			}while(integer.contains(k));//判斷隨機數是否重複,如果不重複就跳出while迴圈
			integer.add(k);		//向list集合中新增元素
			System.out.println(k+"已經成功新增");
		}
		System.out.println("-----排序前------");
		for(Integer it:integer){
			System.out.println("元素:"+it);
		}
		
		//呼叫sort()方法來進行排序
		Collections.sort(integer);	//直接呼叫父方法的sort()進行排序
		System.out.println("--------排序後--------");
		for(Integer it:integer){
			System.out.println("元素:"+it);
		}
	}
	/**
	 * 通過Collections.sort(),對String泛型的List集合進行排序
	 * 向List集合中新增3個字串
	 */
	public void testListSort2()
	{
		List<String> str=new ArrayList<String>();
		str.add("microsoft");
		str.add("baidu");
		str.add("google");
		System.out.println("----排序前----");
		for(String ss:str){
			System.out.println(ss);
		}
		Collections.sort(str);
		System.out.println("----排序後----");
		for(String ss:str){
			System.out.println(ss);
		}
	}
	
	/**
	 *  通過Collections.sort(),對String泛型的List集合進行排序
	 *  向List裡新增十條隨機字串
	 *  字串的長度要不大於10
	 *  每個字串的每個字元都是隨機生成的,但可以重複
	 *  每個字串是不可以重複的
	 * @param args
	 */
	public void testListOfString(){
		List<String> newStr=new ArrayList<String>();//用於儲存字串的
		Random randomLength=new Random();//隨機生成字串的長度
		
		//所有字元查詢表
		String table="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
		
		//生成10個字串
		for(int i=0;i<10;i++){
			StringBuilder sb=new StringBuilder();//用來儲存隨機產生的字串
			do{
				//確定當前字串的長度
				
				int length=randomLength.nextInt(11);//注意每個字串不能大於10個字元
				
				while(length==0){//避免length的值為0,否則這樣就會產生空字串
					length=randomLength.nextInt(11);
				}
				
				for(int m=0;m<length;m++){
					int pos=randomLength.nextInt(table.length());//獲取字元查詢表中任意一個隨機的位置
					sb.append(table.charAt(pos));//將該位置上的字元新增到sb中
				}
			}while(newStr.contains(sb.toString()));//判斷是否有重複的字串,如果集合中不含有該字串則退出while迴圈
			newStr.add(sb.toString());//使用toString方法轉化為String型別
		}
		
		System.out.println("====排序前=====");
		for(String stBd:newStr){
			System.out.println(stBd);
		}
		//呼叫sort()方法進行排序
		Collections.sort(newStr);
		
		System.out.println("====排序後=====");
		for(String stBd2:newStr){
			System.out.println(stBd2);
		}
		Collections.sort(newStr);
	}
	/**
	 * 如何給Students型別的List集合元素進行排序
	 * 直接使用Collections.sort()方法是不行的,必須先讓Students類繼承comparable介面
	 * 並且覆寫comparable介面的compareTo()方法。然後確定新的比較規則:此處我們設定如下
	 * this.id.compareTo(o.id);通過比較id號的字元大小順序來進行排序
	 * @param args
	 */
	public void testStudentsList(){
		List<Students> liStu=new ArrayList<Students>();//例項化一個集合,用來儲存Students物件
		Random random=new Random();//生成隨機種子用於隨機生成幾個不相等的id號
		//新增3個Students的物件
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "tim"));
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "jack"));
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "lucy"));
		liStu.add(new Students(Integer.toString(100000), "lily"));
		/*
		 * 直接使用Collections.sort()方法是不行的,必須先讓Students類繼承comparable介面
		 * 並且覆寫comparable介面的compareTo()方法。然後確定新的比較規則:此處我們設定如下
		 * this.id.compareTo(o.id);通過比較id號的字元大小順序來進行排序
		 */
		System.out.println("=====排序前====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
		Collections.sort(liStu);
		
		System.out.println("=====排序後====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
		
		/**
		 * 接下來是用comparator介面來確定新的臨時比較規則:使用姓名來排序
		 * 過程如下:1、定義一個StudentComparator類,然後
		 * 讓這個類繼承comparator介面,然後覆寫該介面的compare()方法
		 * 2、然後呼叫Collections.sort()方法來進行排序
		 */
		Collections.sort(liStu,new StudentsComparator());
		System.out.println("-------按照名字進行排序---------");
		System.out.println("=====排序後====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
	}
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CollectionsTest ct=new CollectionsTest();
		//排序Integer型別的List
		ct.testListSort1();
		//排序String型別的List
	//	ct.testListSort2();
		//排序隨機生成的String型別的List
		ct.testListOfString();
		//排序Students類
		ct.testStudentsList();
	}

}

//Students類
package com.wq.list;

import java.util.HashSet;
import java.util.Set;
/**
 * 學生類
 * @author LULEI
 *
 */
public class Students implements Comparable<Students>{
	private String name;
	private String id;
	public Set<Courses> courses;//用於後面新增課程
	
	public Students(String id,String name){
		this.setId(id);
		this.setName(name);
		//Set是一個介面,不能直接例項化,通過HashSet()對courses進行例項化
		this.courses=new HashSet<Courses>();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof Students))
			return false;
		Students other = (Students) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public int compareTo(Students o) {
		// TODO Auto-generated method stub
		//將比較規則設定為id號
		return this.id.compareTo(o.id);
	}
	
}

//StudentsComparator類
package com.wq.list;

import java.util.Comparator;

public class StudentsComparator implements Comparator<Students> {

	@Override
	public int compare(Students o1, Students o2) {
		// TODO Auto-generated method stub
		//將規則改成比較名字
		return o1.getName().compareTo(o2.getName());
	}

}
執行結果如下:
57已經成功新增
22已經成功新增
65已經成功新增
52已經成功新增
27已經成功新增
90已經成功新增
38已經成功新增
77已經成功新增
47已經成功新增
21已經成功新增
-----排序前------
元素:57
元素:22
元素:65
元素:52
元素:27
元素:90
元素:38
元素:77
元素:47
元素:21
--------排序後--------
元素:21
元素:22
元素:27
元素:38
元素:47
元素:52
元素:57
元素:65
元素:77
元素:90
====排序前=====
Zj
gkjvUfLB
WgPiL3VX
Xj2DtAtL9
kyrkT9ILYa
G
s0FfBD
bZR
eDA
pVihS
====排序後=====
G
WgPiL3VX
Xj2DtAtL9
Zj
bZR
eDA
gkjvUfLB
kyrkT9ILYa
pVihS
s0FfBD
=====排序前====
319.tim
606.jack
464.lucy
100000.lily
=====排序後====
100000.lily
319.tim
464.lucy
606.jack
-------按照名字進行排序---------
=====排序後====
606.jack
100000.lily
464.lucy
319.tim

這一篇先寫到這,下一篇我將說說Collection的子類。微笑