Collection集合

集合按照其存盤結構可以分為兩大類，分別是
單列集合 java.util.Collection
雙列集合 java.util.Map

Collection：單列集合類的根介面，用于存盤一系列符合某種規則的元素，它有兩個重要的子介面，分別是java.util.List 和 java.util.Set ，

List 的特點是元素有序、元素可重復
Set 的特點是元素無序，而且不可重復

List 介面的主要實作類有 java.util.ArrayList 和 java.util.LinkedList

Set 介面的主要實作類有 java.util.HashSet 和 java.util.TreeSet

Collection 常用功能

Collection是所有單列集合的父介面，因此在Collection中定義了單列集合(List和Set)通用的一些方法，這些方法可用于操作所有的單列集合，方法如下：

• public boolean add(E e) ： 把給定的物件添加到當前集合中 ，
• public void clear() :清空集合中所有的元素，
• public boolean remove(E e) : 把給定的物件在當前集合中洗掉，
• public boolean contains(E e) : 判斷當前集合中是否包含給定的物件，
• public boolean isEmpty() : 判斷當前集合是否為空，
• public int size() : 回傳集合中元素的個數，
• public Object[] toArray() : 把集合中的元素，存盤到陣列中，

import java.util.ArrayList;
import java.util.Collection;

public class Demo{
	public static void main(String[] args) {
		// 創建集合物件
		// 使用多型形式
		Collection<String> coll = new ArrayList<String>();
		// 使用方法
		// 添加功能 boolean add(String s)
		coll.add("張三");
		coll.add("李四");
		coll.add("王五");
		System.out.println(coll);//[張三, 李四, 王五]
		// boolean contains(E e) 判斷o是否在集合中存在
		System.out.println("判斷 張三 是否在集合中" + coll.contains("張三"));//判斷 張三 是否在集合中true
		// boolean remove(E e) 洗掉在集合中的o元素
		System.out.println("洗掉李四：" + coll.remove("李四"));//洗掉李四：true
		System.out.println("操作之后集合中元素:" + coll);//操作之后集合中元素:[張三, 王五]
		// size() 集合中有幾個元素
		System.out.println("集合中有" + coll.size() + "個元素");//集合中有2個元素
		// Object[] toArray()轉換成一個Object陣列
		Object[] objects = coll.toArray();
		// 遍歷陣列
		for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);//張三  王五
		}
		// void clear() 清空集合
		coll.clear();
		System.out.println("集合中內容為：" + coll);//集合中內容為：[]
		// boolean isEmpty() 判斷是否為空
		System.out.println(coll.isEmpty());//true
	}
}

Iterator迭代器

public Iterator iterator() : 獲取集合對應的迭代器，用來遍歷集合中的元素的，

迭代：即Collection集合元素的通用獲取方式，在取元素之前先要判斷集合中有沒有元素，如果有，就把這個元素取出來，繼續在判斷，如果還有就再取出出來，一直把集合中的所有元素全部取出，這種取出方式專業術語稱為迭代，

public class Demo2{
	public static void main(String[] args) {
		// 使用多型方式 創建物件
		Collection<String> coll = new ArrayList<String>();
		// 添加元素到集合
		coll.add("張三");
		coll.add("李四");
		coll.add("王五");
		// 遍歷
		// 使用迭代器 遍歷 每個集合物件都有自己的迭代器
		Iterator<String> it = coll.iterator();
		// 泛型指的是 迭代出 元素的資料型別
		while (it.hasNext()) { // 判斷是否有迭代元素
			String s = it.next();// 獲取迭代出的元素
			System.out.println(s);
		}
	}
}

在進行集合元素取出時，如果集合中已經沒有元素了，還繼續使用迭代器的next方法，將會發生java.util.NoSuchElementException沒有集合元素的錯誤，

for each回圈

JDK1.5以后出來的一個高級for回圈，專門用來遍歷陣列和集合的，它的內部原理其實是個Iterator迭代器，所以在遍歷的程序中，不能對集合中的元素進行增刪操作，

for(元素的資料型別 變數 : Collection集合or陣列){
	//寫操作代碼
}

public class Demo3{
	public static void main(String[] args) {
		int[] arr = {1,3,6,12};
		//使用增強for遍歷陣列
		for(int a : arr){//a代表陣列中的每個元素
		System.out.println(a);
		}
	}
}

public class Demo4{
	public static void main(String[] args) {
		Collection<String> coll = new ArrayList<String>();
		coll.add("張三");
		coll.add("李四");
		coll.add("王五");
		//使用增強for遍歷
		for(String s :coll){//接收變數s代表 代表被遍歷到的集合元素
		System.out.println(s);
	}
}

Map集合

Map 中的集合，元素是成對存在的，每個元素由鍵與值兩部分組成，通過鍵可以找對所對應的值，常用的有HashMap集合、LinkedHashMap集合

HashMap<K,V>：存盤資料采用的哈希表結構，元素的存取順序不能保證一致，由于要保證鍵的唯一、不重復，需要重寫鍵的hashCode()方法、equals()方法，

LinkedHashMap<K,V>：存盤資料采用的哈希表結構+鏈表結構，通過鏈表結構可以保證元素的存取順序一致；通過哈希表結構可以保證的鍵的唯一、不重復，需要重寫鍵的hashCode()方法、equals()方法，

Map介面中的常用方法

• public V put(K key, V value) : 把指定的鍵與指定的值添加到Map集合中，
• public V remove(Object key) : 把指定的鍵 所對應的鍵值對元素 在Map集合中洗掉，回傳被洗掉元素的值，
• public V get(Object key) 根據指定的鍵，在Map集合中獲取對應的值，
• boolean containsKey(Object key) 判斷集合中是否包含指定的鍵，
• public Set keySet() : 獲取Map集合中所有的鍵，存盤到Set集合中，
• public Set<Map.Entry<K,V>> entrySet() : 獲取到Map集合中所有的鍵值對物件的集合(Set集合)，

public class Demo{
	public static void main(String[] args) {
		//創建 map物件
		HashMap<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("老三", "小三");
		map.put("老四", "小四");
		map.put("老五", "小五");
		System.out.println(map);
		//String remove(String key)
		System.out.println(map.remove("老三"));
		System.out.println(map);
		// 想要查看 老四的兒子 是誰
		System.out.println(map.get("老四"));
		System.out.println(map.get("老三"));
	}
}

Map集合遍歷

即通過元素中的鍵，獲取鍵所對應的值

public class Demo{
	public static void main(String[] args) {
		//創建 map物件
		HashMap<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("老三", "小三");
		map.put("老四", "小四");
		map.put("老五", "小五");
		//獲取所有的鍵 獲取鍵集
		Set<String> keys = map.keySet();
		// 遍歷鍵集 得到 每一個鍵
		for (String key : keys) {
		//key 就是鍵
		//獲取對應值
		String value = map.get(key);
		System.out.println(key+"的兒子是："+value);
		}
	}
}

Entry鍵值對物件
Entry 將鍵值對的對應關系封裝成了物件，即鍵值對物件，這樣我們在遍歷 Map 集合時，就可以從每一個鍵值對（ Entry ）物件中獲取對應的鍵與對應的值，
常用方法：
public K getKey() ：獲取Entry物件中的鍵，
public V getValue() ：獲取Entry物件中的值，

了獲取所有Entry物件的方法：
public Set<Map.Entry<K,V>> entrySet() : 獲取到Map集合中所有的鍵值對物件的集合(Set集合)，

public class Demo{
	public static void main(String[] args) {
		//創建 map物件
		HashMap<String, String> map = new HashMap<String, String>();
		//添加元素到集合
		map.put("老三", "小三");
		map.put("老四", "小四");
		map.put("老五", "小五");
		// 獲取 所有的 entry物件 entrySet
		Set<Entry<String,String>> entrySet = map.entrySet();
		// 遍歷得到每一個entry物件
		for (Entry<String, String> entry : entrySet) {
		// 決議
		String key = entry.getKey();
		String value = entry.getValue();
		System.out.println(key+"的兒子是:"+value);
		}

	}
}

LinkedHashMap

LinkedHashMap，它是鏈表和哈希表組合的一個資料存盤結構，保證成對元素唯一，且有順序

public class Demo{
	public static void main(String[] args) {
		LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
		map.put("老三", "小三");
		map.put("老四", "小四");
		map.put("老五", "小五");
		Set<Entry<String, String>> entrySet = map.entrySet();
		for (Entry<String, String> entry : entrySet) {
			System.out.println(entry.getKey() + " " + entry.getValue());
		}

	}
}

泛型

一般在創建物件時，將未知的型別確定具體的型別，當沒有指定泛型時，默認型別為Object型別，

泛型，用來靈活地將資料型別應用到不同的類、方法、介面當中，將資料型別作為引數進行傳遞，

格式：修飾符 class 類名<代表泛型的變數> { }

在創建物件的時候確定泛型,也可以是自定義的泛型類

例如：ArrayList<String> list = new ArrayList<String>();

含有泛型的方法

格式：修飾符 <代表泛型的變數> 回傳值型別 方法名(引數){ }

呼叫方法時，確定泛型的型別

含有泛型的介面

格式：修飾符 interface介面名<代表泛型的變數> { }

1、定義類時確定泛型的型別

public class MyImp1 implements MyGenericInterface<String> {
	//泛型E的值就是String型別，
	@Override
	public void add(String e) {
	// 省略...
	}
	@Override
	public String getE() {
	return null;
	}
}

2、始終不確定泛型的型別，直到創建物件時，確定泛型的型別

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
		// 省略...
	}
	@Override
	public E getE() {
		return null;
	}
}

確定泛型：

public class GenericInterface {
	public static void main(String[] args) {
		MyImp2<String> my = new MyImp2<String>();
		my.add("aa");
	}
}

泛型通配符

泛型的通配符:不知道使用什么型別來接收的時候,此時可以使用?,?表示未知通配符，
此時只能接受資料,不能往該集合中存盤資料，

public static void main(String[] args) {
	Collection<Intger> list1 = new ArrayList<Integer>();
	getElement(list1);
	Collection<String> list2 = new ArrayList<String>();
	getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意型別

受限泛型

泛型的上限：
格式： 型別名稱 <? extends 類 > 物件名稱
意義： 只能接收該型別及其子類

泛型的下限：
格式： 型別名稱 <? super 類 > 物件名稱
意義： 只能接收該型別及其父型別

public static void main(String[] args) {
	Collection<Integer> list1 = new ArrayList<Integer>();
	Collection<String> list2 = new ArrayList<String>();
	Collection<Number> list3 = new ArrayList<Number>();
	Collection<Object> list4 = new ArrayList<Object>();
	getElement1(list1);
	getElement1(list2);//報錯
	getElement1(list3);
	getElement1(list4);//報錯
	getElement2(list1);//報錯
	getElement2(list2);//報錯
	getElement2(list3);
	getElement2(list4);
}
// 泛型的上限：此時的泛型?，必須是Number型別或者Number型別的子類
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此時的泛型?，必須是Number型別或者Number型別的父類
public static void getElement2(Collection<? super Number> coll){}

標籤：Java

上一篇：Dart語言學習(十) Dart流程控制陳述句

下一篇：SpringBoot學習之整合Druid的簡單應用