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

集合框架知識梳理3

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

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

-------------------------------------------------------
1、高級for循環： foreach 有一個侷限性必須有被遍歷的目標。

建議在遍歷數組的時候，還是希望使用傳統for 因爲傳統for可以定義角標。

2、可變參數在使用時注意：可變參數一定要定義在參數列表的最後面。
3、數組變集合 List<String> list = Arrays.asList(str);

使用集合的思想和方法來操作數組中的元素。

4、將數組變成集合，不可以使用集合的增刪方法。因爲數組的長度是固定的
5、集合變數組 String [] str = list.toArray(new String[list.size()]);

直接把集合的長度給出。

6、快速查看數組中元素，使用：Arrays.toString
7、Collection.reverseOrder() 反轉重點掌握

1、反轉比較器 Collections.reverseOrder(new StrLenCom()

2、默認反轉 Collections.reverseOrder()

8、二分法查找，又稱拆半查找BinarySearch

通常運用在：前提必須是有序列表，且變動不大經常查找的時候。

9、靜態導入 StaticImport

當類名重名時，需要指定具體的包命，

當方法重名時，需要指定具備所屬對象或者類。

import java.util.*;// 不加Static 導入的是類。

import static java.util.Arrays.*;// import 後面加static 導入的是【Arrays類中】所有靜態成員

import static java.lang.System.*;//導入的是【System類中】所有靜態成員

-------------------------------------------------------
【5】
數組變集合
Arrays : 用於操作數組的工具類。
裏面都是靜態。很多方法和Collections雷同。

重點：
asList : 將數組變成list集合。可以使用集合的思想和方法來操作數組中的元素。
注意：將數組變成集合，不可以使用集合的增刪方法。因爲數組的長度是固定的
可以用：contains、get、indexOf、subList
都可以用，就是不可以用增刪。
一旦使用增刪就會報UnsupportedoperationExcepton錯誤

class ArraysDemo6 {
	public static void main(String[] args) {
		int  [] ch = {2,3,5};
		System.out.println(Arrays.toString(ch));
		String [] str = {"fdsfs","fds","gr"};
		//爲什麼要這麼寫，有什麼好處，我們都知道數組是查看是否包含某一個元素
			//我們必須要遍歷數組，然後寫判斷，而這樣進行轉換後，
			//我們可以直接使用contains進行判斷。
			//可以使用集合的思想和方法來操作數組中的元素。
			//注意： 將數組變成集合，不可以使用集合的增刪方法。因爲數組的長度是固定的
		List<String> list = Arrays.asList(str);
		System.out.println(list);
		System.out.println("是否包含某一元素"+list.contains("gr"));
		//list.add("ss");//UnsupportedoperationExcepton  不支持的操作異常。爲什麼呢
		int  [] ints = {2,3,5};
		//如何加泛型。
		//List  li7 = Arrays.asList(ints);  //aa
		List <int []>li =Arrays.asList(ints);//bb
		//aa 和bb  的區別
		//如果數組中的元素都是對象，那麼變成集合時，數組中的元素就直接轉成集合中的元素
		//如果數組中的元素都是基本數據類型，那麼會將【該數組】作爲集合中的元素存在。
		System.out.println(li);
		//System.out.println(li7);
		Integer [] in = {2,3,5};
		//List  li2 = Arrays.asList(in);
		List<Integer>  li2 = Arrays.asList(in);
		//這個時候 數組就是對象，所以數組中的元素直接變成了集合中的元素。
		System.out.println(li2);
	}
}

【6】
集合變數組：
Collection 接口中的toArray方法。
2個方法：
toArray()
Arrays.toString()

class  CollectionToArray7{
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("dsa");
		list.add("ssa");
		list.add("dhffa");
		//如何快速查看數組中元素，Arrays.toString  派上用場了。
		String [] art = new String[3];
		list.toArray(art);
		System.out.println(Arrays.toString(art));
		//兩種方式是一樣的。
		//String [] str = list.toArray(new String [4]);//【a】
		//發現這個下標，給元素個數沒有關係。
		//1、指定類型的數組，到底要定義多長呢？
		//	1-1、當指定類型的數組長度小於了集合的size,該方法內部會創建一個新的數組，
		//		長度爲集合的size.  (所以寫4的時候，會多出一個null)	
		//    1-2、當指定類型的數組長度大於集合的size,就不會創建新的數組，而是使用傳遞進來的數組（追加在後面。）
		//	
		//	所以創建一個剛剛好的數組，最優。
		//	所以/【a】應該寫成：
		//2、爲什麼要把集合變數組？
		//	1、爲了限定對元素的操作。不需要增刪。
		String [] str = list.toArray(new String[list.size()]);//直接把集合的長度給出。
		System.out.println(Arrays.toString(str));
	}
}

【7】
BinarySearch 原理。
二分法查找，又稱拆半查找
通常運用在：前提必須是有序列表，且變動不大經常查找的時候。
通過把有序列表一分爲二，使用有序列表的kay 進行中間值的比較，
來進行左右某一邊進行查找，速度很快，不宜增刪。

class BinarySearchTest2 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("bb");
		list.add("hhhhh");
		list.add("a");
		list.add("fffs");
		list.add("mm");
		list.add("zzzzz");
		//Collections.sort(list);
		System.out.println(list);
		//int num = balfSearch(list,"aaa");
		Collections.sort(list,new MyCom());
		System.out.println(list);
		int num = balfSearchII(list,"aaa",new MyCom());
		System.out.println(num);
	}
	public static int balfSearch(List<String> list, String key){
		int max,min,mid;
		max=list.size()-1;//最大值爲長度-1
		min=0;
		while(min<=max){  //循環條件
			mid=(max+min)>>1;  //   同 /2   中間值 爲最大最小值和除以2.  
			String str=list.get(mid);// 獲取中間值
			int num = key.compareTo(str);//用key和中間值進行比較。  具備性，默認比較方法。
			if(num<0){
				max=mid-1;//  key沒有中間值大，就在左邊查詢，所以最大值就是中間值-1
			}
			else if(num>0){
				min=mid+1;//  key比中間值大，在右邊查詢，所以最小值爲中間值+1
			}else{
				return mid;//相等就是中間值。
			}		
		}
		return -min-1;// 沒有就是負數，專業寫法，負的插入點-1.
	}
	//【當元素不具備比較性時，該如何處理:】
	//	在參數中加上 Comparator比較器，在比較時調用compare方法，如果需要新的比較方式，
	//	實現Comparator接口並覆蓋compare方法即可
	public static int balfSearchII(List<String> list, String key,Comparator<String> com){
		int max,min,mid;
		max=list.size()-1;
		min=0;
		while(min<=max){  
			mid=(max+min)>>1;  
			String str=list.get(mid);
			//int num = key.compareTo(str);//用key和中間值進行比較。  具備性，默認比較方法。
			int num =com.compare(key,str);//【在此處調用compare方法進行2個參數的傳遞即可】
			if(num<0){
				max=mid-1;
			}
			else if(num>0){
				min=mid+1;
			}else{
				return mid;
			}		
		}
		return -min-1;
	}
}
//自定義比較器。 按照長度排序
class MyCom implements Comparator<String>{	
	public int compare(String s1,String s2){		
		if(s1.length()>s2.length()){
			return 1;
		}else if(s1.length()==s2.length()){
			return s1.compareTo(s2);
		}
		return -1;
	}
}

【8】
collections 工具類
常見方法：
sort(List<T> list) :排序
max(Collection<? extends T> coll) ：最大值
fill(List<? super T> list, T obj) ：用指定元素替換掉列表中的所有元素
binarySearch(List<? extends Comparable<? super T>> list, T key) :但凡使用該方法，必須是有序集合(list) 返回負數，表示不存在。
replaceAll(List<T> list, T oldVal, T newVal) :使用一個新值替換掉一箇舊的值
reverse(List<?> list) ：反轉集合
reverseOrder() ：強行逆轉比較器順序
Collections 中重點方法：
1、Collection.reverseOrder() 反轉

通常默認排序，需要反轉的時候，需要編寫一個比較器來完成。

而Collection.reverseOrder() 能強行進行反轉，並能對比較器強行反轉

class  CollectionsDemo5{
	public static void main(String[] args) {
		orderDemo();
		System.out.println("-------------------------------");
		frequecyDemo();
		System.out.println("-------------------------------");
		copyDemo();
		System.out.println("-------------------------------");
		addAllDemo();
		System.out.println("-------------------------------");
		List list=new ArrayList();
		synchronizedListDemo(list);
		System.out.println("-------------------------------");
		shuffleDemo();
	}
	//隨機排序    //撲克牌，骰子。
	public static void shuffleDemo(){
		System.out.println("隨機排序");
		List<String> list = new ArrayList<String>(); 
		list.add("a");
		list.add("ag");
		list.add("dfd");
		list.add("ggggs");
		list.add("a");
		list.add("dd");
		System.out.println(list);
		Collections.shuffle(list);
		System.out.println(list);
	}
	//只需要傳入一個集合工具類，或者直接對比較器進行強轉即可。
	public static void orderDemo(){
		System.out.println("新值替換舊值，反轉");
		TreeSet<String> list = new TreeSet<String>();  //默認排序		
		//TreeSet<String> list = new TreeSet<String>(Collections.reverseOrder());//對默認排序反轉
		//TreeSet<String> list = new TreeSet<String>(new StrLenCom());  //傳入比較器 長度排序
		TreeSet<String> list = new TreeSet<String>(Collections.reverseOrder(new StrLenCom()));  //對 長度排序進行反轉
		//新增元素。
		list.add("a");
		list.add("ag");
		list.add("dfd");
		list.add("ggggs");
		list.add("z");
		list.add("dd");
		for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){
			System.out.println(it.next());
		}
	}
	//返回一個安全（同步）的list集合
	public static List synchronizedListDemo(List list){
		list = Collections.synchronizedList(new ArrayList());
		Collections.addAll(list,"dd","a","ccc","mmmm");
		synchronized(list) {
			Iterator i = list.iterator(); // Must be in synchronized block
			while (i.hasNext())
				System.out.println(i.next());
		return list;
  }

		//來進行安全轉換
		//System.out.println(list);
	}
	//查找只等值的個數
	public static void frequecyDemo(){
		System.out.println("查找只等值的個數");
		List<String> list = new ArrayList<String>(); 
		list.add("a");
		list.add("ag");
		list.add("dfd");
		list.add("ggggs");
		list.add("a");
		list.add("dd");
		System.out.println(list);
		int num=Collections.frequency(list,"a");
		System.out.println(num);
	}
	//全部加入
	public static void addAllDemo(){
		List<String> list = new ArrayList<String>(); 
		Collections.addAll(list,"dddd","mm");
		System.out.println(list);
	}
	public static void copyDemo(){
		System.out.println("查找只等值的個數");
		List<String> list = new ArrayList<String>(); 
		list.add("a");
		list.add("ag");
		list.add("dfd");
		list.add("ggggs");
		list.add("a");
		list.add("dd");
		System.out.println(list);
		//List<String> clist = new ArrayList<String>(); 
		//想要進行copy 必須要加入一個相同長度。
		//Collections.addAll(clist,  new  String[list.size()]);
		//Collections.copy(clist,list);
		List<String> clist=list;//這種方式和copy  有何區別？
		System.out.println(clist);
		System.out.println(list);
	}
}
//1
class StrLenCom implements Comparator<String>{
	public int compare(String s1,String s2){
		//return s2.compareTo(s1);
		
		if(s1.length()>s2.length()){
			return 1;
		}
		if(s1.length()==s2.length()){
			return s1.compareTo(s2); 
		}
		return -1;
	}
}
//2
class MyCom implements Comparator<String>{
	public int compare(String s1,String s2){
		return s2.compareTo(s1);
	}
}

【9】
高級for循環： foreach

格式：
【 for(數據類型變量名 : 被遍歷的集合(Collection)或者數組)】

1/集合只能是Collection集合。

2/這個數據類型是集合或者數組中元素的類型。

（如果不確定元素類型，就寫Object, 1.5 後出了泛型，一般都帶泛型）

for
只能對元素進行取出，而不能做修改動作：
對集合進行遍歷，只能獲取集合元素，但是不能對集合進行操作。

迭代器除了遍歷，還可以進行remove 集合中的元素。
如果使用listIterator 還可以在遍歷過程中對集合進行增刪改查的動作

底層原理還是迭代器，升級後優化簡寫了。

傳統for循環和高級for 有什麼區別呢。

1、高級for 有一個侷限性。必須有被遍歷的目標。

建議：在遍歷數組的時候，還是希望使用傳統for 因爲傳統for可以定義角標。

class foreachDemo8 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("dsa");
		list.add("ssa");
		list.add("dhffa");
		//【增強型 For 循環】
		for(String s : list){
			System.out.println(s);
		}
		//迭代器取出
		//for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){			
		//	System.out.println(it.next());
		//}
		//數組：
		String [] ss=new String[100];
		int [] arr  = {2,23,58,26,17}; 
		for(int i : arr){
			System.out.println(i);
		}
		//  哈哈，  高級for 打印100次
		for(String s : new String[10]){
			s="hello word";
			System.out.println(s);
		}
		int m = 1;
		for(int in : new int[10]){
			in=m++;
			System.out.println(in);
		}
		HashMap<Integer,String> hm= new HashMap<Integer,String>();
		hm.put(123,"tt");
		hm.put(3,"tt");
		hm.put(1,"tt");
		hm.put(353,"pp");
		//1、for裏面只能是Collection,所以mapd 類型需要轉變
		//	所以Set  來裝該集合的key值
		//	通過遍歷獲取key的時候，來獲取value值。
		Set<Integer> keyset = hm.keySet();
		//1、
		for(Integer i : keyset ){
			String s =hm.get(i);
			System.out.println(i+".."+s);
		}
		System.out.println("...................");
		//2、
		//Set<Map.Entry<Integer,String>> entryset = hm.entrySet();
		//for(Map.Entry<Integer,String> me: entryset){ 
			//【簡寫爲：
		for(Map.Entry<Integer,String> me: hm.entrySet()){
			Integer key = me.getKey();
			String value = me.getValue();
			System.out.println(key+".."+value);
		}
	}
}

【10】
JDK 1.5 版本出現的新特性。
可變參數
在使用時注意：可變參數一定要定義在參數列表的最後面。

class  ParamMethodDemo9{
	public static void main(String[] args) {
		show(2,3);
		//2 可是當我們需要4，5，6個的時候，那豈不是要重載很多個方法？
		//3-2  發現比1 重載方式好，但是每一次使用都要先創建數組，麻煩
		int [] arr = {2,3,4,};
		show1(arr);
		int [] arr1 = {2,3,4,4,5,6,7,8};
		show1(arr1);
		//4-2  發現用【...】代表可變參數跟3比，相當於替換了[]號，其實就是2的簡寫。 
		show2(2,3);
		show2(2,3,4);
		show2(2,3,4,4,5,6,7,8);
		show3("hh",2,3);//編譯通過
		//show4(2,3,"aaa");//編譯失敗
	}
	//1-1 當我們做2個數運算時候 ，定義一個接收2個參數方法即可
	public static void show(int a ,int b){
		sop(a+b);
	}
	//1-2當我們做3個數運算時候 ，重載1方法即可。
	public static void show(int a ,int b,int c){
		sop(a+b+c);
	}
	//3-1 這個時候我們想到了定義參數爲數組，
	public static void show1(int [] arr){
		//用循環來計算
		int num=0;
		for(int i =0;i<arr.length;i++){
			num+=arr[i];
		}
		sop(num);
	}
	//4-1
	public static void show2(int ... arr){
		//用高級for來計算
		int num = 0;
		for(int i : arr){
			num+=i;
		}
		sop(num);
	}
	//4-2  【注意事項  可變參數一定放最後】
	public static void show3(String str,int ... arr){}//編譯通過
	//4-3
	//public static void show4(int ... arr,String str){}//編譯錯誤
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

【11】
JDK 1.5 版本出現的新特性。

StaticImport : 靜態導入。

當類名重名時，需要指定具體的包命，
當方法重名時，需要指定具備所屬對象或者類。

import java.util.*;// 不加Static 導入的是類。
import static ava.util.Arrays.*;//  import 後面加static 導入的是【Arrays類中】所有靜態成員
import static java.lang.System.*;//導入的是【System類中】所有靜態成員
class StaticImport91 {
	public static void main(String[] args) {
		//Static System  靜態導入後 ：
		out.println("!!!靜態導入後的輸出語句");
		int [] arr = {2,3,1};
		//Arrays.sort(arr);//排序
		sort(arr);
		//int index = Arrays.binarySearch(arr,2);//使用二分法查找。查找前必須排序
		int index = binarySearch(arr,2);//使用二分法查找。查找前必須排序
		out.println(Arrays.toString(arr));//轉成集合【AAA】
		//System.out.println(Arrays.toString(arr));//轉成集合【AAA】
		System.out.println("Index:"+index);//
		//1、發現每次都要寫Arrays 或者Collections 等非常麻煩。
		//	 所以我們可以導入包，來簡寫。靜態包的導入
		// 2、靜態導入Arrays  後發現，可以直接調用方法了。簡單了很多
		//  3、爲什麼【AAA】不簡寫 因爲類都是Object 中有toString，而Object是所有類的超類。
		//	 如果這時候去掉Arrays  指定不明確，編譯失敗。
		//	 3-1、當類名重名時，需要指定具體的包命，
		//	 3-2、當方法重名時，需要指定具備所屬對象或者類。
		//  4、靜態導入System後，可以去掉System了。
		
	}
}

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

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

黑馬官網

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

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

Mac下配置sublime實現LaTeX

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

linux以太網驅動總結