黑馬程序員_【總結】_集合框架知識梳理1

集合框架知識梳理1

---------- android培訓、java培訓、期待與您交流！ ----------

---------------------------------------------------------------------------------------------------------------------------------------------

Collection集合框架
-------------------------------------------
1、集合用於儲存對象、長度可變、可存儲各種類型對象
2、集合中存儲的都是對象的引用（地址）
--------------------------------------------
|--Collection 接口單列集合

|-- List

|-- ArrayList

|-- LindedList

|-- Vector

|-- Set

|-- HeshSet

|-- TreeSet

--------------------------------------------
【0】
List：可重複、有序。
Set: 不可重複、無序。
【1-1】
ArrayList
本質上，ArrayList是對象引用的一個可變長度數組。
底層：數據結構。查詢快，增刪慢，線程不同步
Arrays.asList() 能直接返回一個非八大基本狀態的數組。
【1-2】
LiknedList
底層：鏈表結果。增刪快，查詢慢。 Vector升級版
Vector：其特點就是枚舉迭代的前身。
跟迭代是極其的相似：

Vector<String> v = new Vector<String>();
v.add("java01");
v.add("java01");
v.add("java01");

Enumeration<String> en = v.elements();
while(en.hasMoreElements()){
	System.out.println(en.nextElement());
}

【1-3】
迭代器
Iterator

for(Iterator<T>it=al.iterator(); it.hasNext(); ){
	System.out.println(it.next());
}

【2-1】
HeshSet
底層：哈希值
通過 hashCode 方法保證唯一性，當哈希值地址相同時，
會調用equals 方法再次判斷
【2-2】
TreeSet
底層：二叉樹，
1、進行操作實現 Comparable 接口覆蓋 compareTo()方法，當主要條件相同時，
比較次要元素，保證運算唯一性的語語句是：compareTo()方法 return 0;
2、當元素不具備比較性或不是需要的比較時，定義一個類實現 Comparator接口
重寫 compare()方法。
TreeSet比較方式一

main方法：

	public static void main(String[] args) {
		// Comparable 內部排序【A】
		TreeSet  ts=new TreeSet();
		//Comparator 外部比較器 【B】
		//TreeSet  ts=new TreeSet(new Myc());
		ts.add(new Stu("lisi02",22));
		ts.add(new Stu("lisi007",20));
		ts.add(new Stu("lisi009",19));
		ts.add(new Stu("lisi06",19));
		ts.add(new Stu("lisi06",18));
		ts.add(new Stu("lisi03",18));
		Iterator it=ts.iterator();
		while(it.hasNext()){
			Stu s=(Stu)it.next();
			System.out.println(s);
		}
	}

Comparable 內部實現比較方法：

class Stu implements Comparable{
	String name;
	int age;
	Stu(String name,int age){
		this.name = name;
		this.age = age;
	}
    //覆蓋該方法
	public int compareTo(Object o) {
		//1、-1、分別代表 正序、倒序  
		//return -1;
		//也可以自定義--按照名字排序
		if(!(o instanceof Stu)){
			//如果不是該類型則拋出異常
			throw new RuntimeException("，，，");
		}
		Stu s = (Stu)o;
		//主條條件
		int num = this.name.compareTo(s.name);
		if(num==0){
			//基本數據類型不能 compareTo 進行比較
			num = new Integer(this.age).compareTo(new Integer(this.age));  
		}
		return num;
	}
	public String toString(){
		return name +"---"+age;
	}	
}

Comparator 外部自定義比較器：

class Myc implements Comparator{
	//覆蓋
	public int compare(Object o1, Object o2) {
		Stu s1 = (Stu) o1;
		Stu s2 = (Stu) o2;
		//主條件
		int num = s1.name.compareTo(s2.name);
		if(num==0){
			//次條件
			num = new Integer(s1.age).compareTo(new Integer(s2.age));
		}
		return num;
	}	
}//<span style="white-space:pre">		</span>int num = s1.name.compareTo(s2.name); 
//<span style="white-space:pre">		</span>return num==0?new Integer(s1.age).compareTo(new Integer(s2.age)):num;   寫法2

【3】對比 List 和 Set 集合。

class Person{
	String name;
	int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return name+">>"+age;
	}
}
public class CollectionTest{
	public static void main(String [] args){
		ArrayList<Person> al = new ArrayList<Person> ();
		al.add(new Person("li01",19));
		al.add(new Person("li01",19));
		al.add(new Person("li02",20));
		
		// 迭代器--方式一   不能add 、remove
		for(Iterator<Person> it = al.iterator(); it.hasNext() ; ){
			System.out.println(it.next());
		}
		System.out.println("---------------------");
		//ListIterator  迭代時，可以  併發交互了。
		for(ListIterator<Person>lit = al.listIterator(); lit.hasNext() ; ){
			Person obj = lit.next();
			if(obj.name.equals("li02")){
				lit.add(new Person("li03",18));
				lit.add(new Person("li03",32));
			}
			if(obj.name.equals("li01")){
				lit.remove();
			}
		}
		// 迭代器--方式二
		Iterator<Person> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next()+"...方式二");
		}
		System.out.println("---------------------");
		HashSet<String> hs = new HashSet<String>();
		hs.add("ya01");
		hs.add("ya01");
		hs.add("ya02");
		// 打印 HashSet  集合
		for(String has : hs){
			System.out.println(has+"...");
		}	
	}
}

結論：
1、集合就是一個可變長度的數組
2、List 是可重複的
3、Set 是不可重複的
4、取出方式有1、迭代Iterator ：for、while兩種方式。
2、高級for
5、ListIterator 可以在迭代時，進行併發交互

111：常見方法
1、新增：add() 2、清除： clear()3、是否包含：contains(Object o)5、是否爲空：isEmpty()
5：排序：toArray() 7、刪除：remove(Object o)
8、全部刪粗：removeAll(Collection<?> c) 9：長度、個數：size()

等，具體更詳細，要學會查看API

【4】
Generic
泛型的好處：
1、安全。
2、消除強制類型轉換
泛型就是指定一種類型。
其實泛型<>就是用來接收類型的。
當使用集合時，將集合中要存儲的數據類型作爲參數傳遞到<>中即可
1、
泛型機制
ArrayList<Person> al = new ArrayList<Person> ();
迭代器對應：
Iterator<Person> it = al.iterator()

泛型類
泛型類定義的泛型，在整個類中有效
如果被方法使用，那麼泛型的對象明確早操作的具體類型後
所有要操作的類型就已經固定了。

class Demo <T> {
	public void show(T t){
		System.out.println("show:"+t);
	}
	public void print(T t){
		System.out.println("print:"+t);
	}
}

泛型方法
爲了讓不同方法可以操作不同類型，而且類型還不確定
那麼可以將泛型定義在方法上。
public void show(T t){ //隨着泛型類的類型走
System.out.println("show:"+t);
}
//public <T> void print(T t){ 這裏的t上上面的一樣的嗎，不是。
public <Q> void print(Q q){ //爲了方便閱讀，還是寫成不一樣的。
System.out.println("print:"+q);
}
泛型接口
接口接收位置類型
方法也接收位置類型
主函數就可以傳遞任意類型的參數

interface Inter<T>{   //
	void show(T t);
}
class InterImpl<T> implements Inter<T>{
	public void show(T t){
		System.out.print(t);
	}
}
class InterDemo{
	public static void main(String[] args) {
		InterImpl<String> in = new InterImpl();
		InterImpl<Integer> in2 = new InterImpl();
		in.show("haha");
		in2.show(123);
	}
}

主函數就可以傳遞任意類型的參數

靜態泛型
特殊之處
靜態方法不可以訪問類上定義的泛型。
如果靜態方法操作的應用數據類型不確定，可以將泛型定義在方法上。

class Demo3<T> {
	
	//public static <T> void showS(T t){// 報錯，不能和非靜態類同類型
	//public <T> static  void showS(T t){//報錯，書寫格式錯誤
		
	public static <M> void showS(M m){// 靜態泛型方法不可爲非靜態泛型類相同類型，原理很簡單，靜態先加載，
		System.out.println("print:"+m);
	}
}

【4-1】
泛型的高級引用
<?> 通配符，也可以理解爲佔位符。
泛型的限定：
<? enteds E> E 可以接收 E類型或者E的子類型。上限。
<? super E> E 可以接收 E類型或者E的父類型。下限。

public class test2 
	{
		public static void main(String[] args) 
		{
			ArrayList<Personp> alp= new ArrayList<Personp> ();
			alp.add(new Personp("wocao01"));
			alp.add(new Personp("wocao02"));
			
			ArrayList<Student> als= new ArrayList<Student> ();
			als.add(new Student("002s"));
			als.add(new Student("003s"));
			
			ArrayList<Pupil> alx= new ArrayList<Pupil> ();
			alx.add(new Pupil("xxx11"));
			alx.add(new Pupil("dd333"));
			
			show(als);
			show(alp);
			show(alx);
			showX(als);
			showX(alp);
			//showX(alx);  //【P】
		}
		public static void show(ArrayList<? extends Personp> al){
			for(Iterator<? extends Personp> it=al.iterator();it.hasNext(); ){
				System.out.println(it.next().getName());
			}
		}
		public static void showX(ArrayList<? super Student> al){
			for(Iterator<? super Student> it=al.iterator();it.hasNext(); ){
				//System.out.println(it.next().getName());//編譯不通過
				System.out.println(it.next());
			}
		}
	}
	class Personp{
		private String name;
		Personp(String name){
			this.name=name;
		}
		public String getName(){
			return name;
		}
		public String toString(){
			return name+"";
		}
	}
	class Student extends Personp{
		Student(String name){
			super(name);
		}
	}
	class Pupil extends Student{
		Pupil(String name){
			super(name);
		}
	}

這個時候【p】處就出現了錯誤。
因爲
<? extends Personp> 是指 Personp 和Personp的子類 Student、Pupil 都是人的子類
<? super Student> 是指Student 和Student 的父類 Pupil是 Student 的子類，所以報錯。
再看下面的代碼：繼承關係依然用上面的代碼。
充分的利用了泛型的限定， TreeSet進行了排序，並簡潔了很多代碼。

public class test2 {
	public static void main(String[] args) {
		TreeSet<Personp> tp = new TreeSet<Personp>(new Comp());
		tp.add(new Per("fds08"));
		tp.add(new Per("asd07"));
		tp.add(new Per("asd01"));
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Stu("fds----08"));
		ts.add(new Stu("asd---07"));
		ts.add(new Stu("asd---01"));
		TreeSet<Pupil> tx = new TreeSet<Pupil>(new Comp());
		tx.add(new Pul("fds>>>08"));
		tx.add(new Pul("asd>>>07"));
		tx.add(new Pul("asd>>>01"));
		show(tx);
		show(ts);
		show(tp);
	}
	//通過泛型向下限定， 指定了類型的範圍。
	public static void show(TreeSet<? extends Personp> ts){
		for(Iterator<? extends Personp> it = ts.iterator(); it.hasNext(); ){
			System.out.println(it.next().getName());
		}
	}
}
//不用在依次設定比較器，泛型設定爲父類， 讓比較器通用了。
class Comp implements Comparator<Personp>{
	public int compare(Personp p1,Personp p2){
		return p1.getName().compareTo(p2.getName());
	}
}

通過對比較器的泛型限定，父類，使其具備了通用性，但是侷限於父類以及父類子類。

---------------------------------------------------------------------------------------------------------------------------------------------

---------- android培訓、 java培訓、期待與您交流！----------

黑馬官網

黑馬程序員_【總結】_集合框架知識梳理1

Python 潮流週刊#52：Python 處理 Excel 的資源

黑馬程序員_Java基礎[29]_線程間通訊、解決問題、lock

黑馬程序員_Java基礎[23]_練習題

黑馬程序員_Java基礎[27]_靜態同步函數

黑馬程序員_Java基礎[22]_異常總結

黑馬程序員_Java基礎[24]_package、import

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結