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

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

阿新 • • 發佈：2018-10-31

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

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

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的子類。微笑

相關推薦

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

首先，在學習集合之前我們能夠使用的可以儲存多個元素的容器就是陣列。 下面舉幾個例子主要是引出集合類的： 1、8,4,5,6,7,55,7,8  像這樣的型別相同的可以使用陣列來儲存，本例可以用int[] arr來儲存。 2、”zhnagsan”,true,68 像這樣的可以使

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

這一篇我們來介紹Collection介面的另一個子介面，Set介面。Set是個介面，元素不可以重複，是無序的。Set介面中的方法和Collection的一致。 A、Set的子類： 1、HashSet：此類實現的Set介面，由雜湊表(實際上是一個HashMap)例項支援，它不保證Set的迭代順

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

接著上一篇，接著講講集合的知識。上一篇講了Collection介面。它可以說是集合的祖先了，我們這一篇就說說它的子孫們。 一、Collection的子介面 List:有序（存入和取出的順序一致），元素都有索引（即角標），元素可以重複。 Set:元素不能重複，無序的。 首先講講L

JAVA常用集合框架用法詳解——提高篇

   這篇文章是我對集合框架的昇華總結。文章中沒有提到各個集合子類的最基本的操作和方法。想要知道這部分的內容，可以檢視我的一篇基礎知識的部落格--Java集合框架總結基礎篇http://blog.csdn.net/lulei1217/article/details/4516

【Redis詳解基礎篇一】

前言 由於專案的原因所以需要深入Redis學習，所以我會不定期的更新~ 什麼是Redis 他是開源的BCD協議，使用C編寫的，他是把資料儲存在記憶體中的，使用的是no only sql 資料庫，是鍵值對的方式 Redis的資料型別 redis支援非常多的資料

Java之集合框架總結詳解

Java 集合框架主要包括兩種型別的容器，一種是集合（Collection），儲存一個元素集合，另一種是圖（Map），儲存鍵/值對對映。Collection 介面又有 3 種子型別，List、Set 和 Queue，再下面是一些抽象類，最後是具體實現類，常用的有 ArrayList、LinkedLi

java中的instanceof用法詳解

定義 xtend print 繼承 interface 參數 保留 如果 ack 　　instanceof是Java的一個二元操作符（運算符）,也是Java的保留關鍵字。它的作用是判斷其左邊對象是否為其右邊類的實例，返回的是boolean類型的數據。用它來判斷某個對象是否是

Java 常用IO流操作詳解

字符集 -s fileinput 顯式 print OS 數值 重寫 目錄 1.基本概念 IO：Java對數據的操作是通過流的方式，IO流用來處理設備之間的數據傳輸，上傳文件和下載文件，Java用於操作流的對象都在IO包中。 2.IO流的分類 圖示：（主要IO流）

Java二進位制中0用法詳解

題目內容： 計算機內部用二進位制來表達所有的值。一個十進位制的數字，比如18，在一個32位的計算機內部被表達為00000000000000000000000000011000。可以看到，從左邊數過來，在第一個1之前，有27個0。我們把這些0稱作前導的零。 現在，你的任務是寫一個程式，輸入一

Java內部類作用用法詳解

Java中，可以將一個類定義在另一個類裡面或者一個方法裡面，這樣的類稱為內部類。 內部類包括四種：成員內部類、區域性內部類、匿名內部類和靜態內部類。 內部類的作用： 1.Java只支援單重繼承，想擴充套件功能，去實現介面吧。很快Java的設計者就發現了他們犯了矯枉過正的

JAVA常用集合框架原始碼解析（基於1.8）開題篇

倪升武的部落格中有一個小專題，讀完之後，發現博主的分析基本是基於JAVA1.7的，這裡我基於JAVA1.8給出一些新的解讀。但是對於JAVA1.8新增的一些新特性可能不太會作過多的分析（畢竟本人目前水平有限，且本部落格的寫作初衷也是以基礎學習為主），在徹底淺讀完

iOS 集合NSSet 用法詳解

集合NSSet //NSSet中不能存在重複的物件 NSMutableSet *set1 = [[NSMutableSet alloc] initWithObjects:@"1",@"2",@"3", nil]; NSMutableSet *

java中random的用法詳解

   java中存在兩個隨機函式，它們分別來自java.long.Math.random()和    java.util.Random();其中前者的適用範圍比較小，完全可以被後者取代。一、java.lang.Math.random()方法的用法     ①、方法型別：pub

Java中instanceof運算子用法詳解

一、 instanceof運算子可以確定物件是否屬於一個特定的類。 該運算子是二目運算子，左邊的操作元是一個物件，右邊是一個類，當左邊的物件是右邊的類或子類建立的物件時，該運算子運算的結果是true,否則是false。 例： class instanceOf

Java中Class.forName()用法詳解

Class.forName()主要功能 Class.forName(xxx.xx.xx)返回的是一個類， Class.forName(xxx.xx.xx)的作用是要求JVM查詢並載入指定的類，也就是說JVM會執行該類的靜態程式碼段。 下面，通過解答以下三個問題的來詳細講解下

Android Collections集合框架使用詳解

Collection在Android中的用法最近在做Android專案的時候，遇到了一些集合排序的問題，之前也使用過Collections的一些方法，例如Collections.sort(),Collections.swap()...，於是就統一整理了一下Collection

Java中JNI的使用詳解第二篇:JNIEnv型別和jobject型別的解釋

上一篇說的是一個簡單的應用，說明JNI是怎麼工作的，這一篇主要來說一下，那個本地方法sayHello的引數的說明，以及其中方法的使用 首先來看一下C++中的sayHello方法的實現:  對於這個方法引數中的JNIEnv* env引數的解釋: JNIEnv型別實際上代表了Java

Java中JNI的使用詳解第一篇:HelloWorld

今天開始研究JNI技術，首先還是老套路，輸出一個HelloWorld:具體流程如下:在Java中定義一個方法，在C++中實現這個方法，在方法內部輸出“Hello World"，然後再回到Java中進行呼叫。分為以下步驟: 第一步:在Eclipse中建立一個類:JNIDemo  

Java中JNI的使用詳解第一篇 HelloWorld

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Elasticsearch檢索分類深入詳解—基礎篇

題記 Elasticsearch中當我們設定Mapping（分詞器、欄位型別）完畢後，就可以按照設定的方式匯入資料。 有了資料後，我們就需要對資料進行檢索操作。根據實際開發需要，往往我們需要支援包含但不限於以下型別的檢索： 1）精確匹配，類似mysql中的 “=”操作；