黑马程序员_【总结】_集合框架知识梳理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培训、期待与您交流！----------

黑马官网