黑马程序员-day17-集合框架中的工具类(Collections和Arrays)

------- android培训、 java培训、期待与您交流！ ----------

集合框架中的工具类
1.Collections：集合框架的工具类,里面定义的都是静态方法。
2.Arrays：用于操作数组的工具类。里面都是静态方法。

工具类-Collections
集合框架的工具类,里面定义的都是静态方法。

Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。它有两个常用的子接口:
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的,因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

Collections实例：

/*
Collections是集合框架中的一个工具类。该类中的方法都是静态的
		提供的方法中有可以对list集合进行排序，二分查找等方法。
		通常常用的集合都是线程不安全的。因为要提高效率。
		如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
*/
import java.util.*;
class  CollectionsDemo{
	public static void main(String[] args) {
		sortDemo();
	}

	public static void binarySearchDemo(){
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list,new StrLenComparator());

		sop(list);

		//int index = Collections.binarySearch(list,"aaaa");
		//int index = halfSearch(list,"cc");
		int index = halfSearch2(list,"aaaa",new StrLenComparator());
		sop("index="+index);
	}

	public static int halfSearch(List<String> list,String key){
		int max,min,mid;
		max = list.size()-1;
		min = 0;

		while(min<=max){
			mid = (max+min)>>1;//  /2;

			String str = list.get(mid);

			int num = str.compareTo(key);
			if(num>0)
				max = mid -1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}

	public static int halfSearch2(List<String> list,String key,Comparator<String> cmp){
		int max,min,mid;
		max = list.size()-1;
		min = 0;

		while(min<=max){
			mid = (max+min)>>1;//  /2;

			String str = list.get(mid);

			int num = cmp.compare(str,key);
			if(num>0)
				max = mid -1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}

	public static void maxDemo(){
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list/*,new StrLenComparator()*/);
		sop("max="+max);
	}

	public static void sortDemo(){
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		
		sop(list);

		//Collections.sort(list);
		Collections.sort(list,new StrLenComparator());
		//Collections.swap(list,1,2);
		sop(list);
	}

	public static void sop(Object obj){
		System.out.println(obj);
	}
}

//比较器
class StrLenComparator implements Comparator<String>{
	public int compare(String s1,String s2){
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

工具类-Arrays
特别方法：asList:将数组转成list集合

数组转成List集合实例：

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ArraysDemo {
	public static void main(String[] args) {
		//数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
		int arr1[] = {2,3,4};
		//返回指定数组内容的字符串表示形式。
		System.out.println("arr1:"+Arrays.toString(arr1));
		//将数组变成list集合
		List list1 = Arrays.asList(arr1);
		getMethod(list1);
		
		//数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
		Integer arr2[] = {2,3,4};
		System.out.println("arr2:"+Arrays.toString(arr2));
		List<Integer> list2 = Arrays.asList(arr2);
		getMethod(list2);
	}
	
	//遍历
	public static void getMethod(List list){
		Iterator it = list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}

思考：
把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
注意：
1.将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定。如果你增删。那么会发生UnsupportedOperationException异常。
2.如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
  如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

集合转成数组

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class CollectionToArray {
	public static void main(String[] args) {
		ArrayList<Object> al = new ArrayList<Object>();
		al.add("1");
		al.add("abc");
		al.add("123");
		
		String str[] = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(str));
	}
}

思考：
1.指定类型的数组到底要定义多长呢？
  (1)当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
  (2)当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。所以创建一个刚刚好的数组最优。
2.为什么要将集合变数组？
  为了限定对元素的操作,不需要进行增删。


高级for循环-1.5JDK的新特性
1.高级 for 循环(简化书写)格式：
for(数据类型 变量名 ： 被变量的集合（Collection）或者数组){
}
2.作用：对集合或者数组进行遍历，
3.好处和缺点：
  好处：简化书写
  缺点：
(1)遍历集合时只能获取集合元素，但是不能对集合进行操作。
(2)必须有便利的目标
4.高级for循环遍历和迭代器遍历的区别
  (1)高级for循环只能获取集合元素，但是不能对集合进行操作。
  (2)迭代器除了遍历，还可以进行remove集合中元素的动作。
     如果是用ListIterator，还可以在遍历过程中对集合进行增删改查动作。
5.传统for和高级for的区别
  高级for有一个局限性，必须有便利的目标。
  建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义脚标。

高级for循环实例：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class ForDemo {
	public static void main(String[] args) {
		//数组
		int arr[] = {1,2,3};
		
		for (int a:arr) {
			System.out.println(a);
		}
		
		//ArrayList
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc");
		al.add("efg");
		al.add("hij");
		
		for(String s: al){
			System.out.println(s);
		}
		
		//HashMap
		HashMap<String, Integer> hm = new HashMap<String, Integer>();
		hm.put("张三", 20);
		hm.put("李四", 20);
		hm.put("王五", 20);
		
		//通过键来获取值
		Set<String> keySet = hm.keySet();
		for(String s:keySet){
			System.out.println(s +","+ hm.get(s));
		}
		//通过映射关系来获取值和键
		Set<Map.Entry<String, Integer>> EntrySet = hm.entrySet();
		for(Map.Entry<String,Integer> s:EntrySet){
			System.out.println(s.getKey() +","+ s.getValue());
		}
	}
}

可变数组-JDK1.5版本出现的新特性
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象，只要将操作的元素作为参数传递即可，
隐式将这些参数封装成数组，可以传入空参数，0长度数组。
注意：可变参数一定要定义在参数列表最后面。

可变数组实例：

class  ParamMethodDemo{
	public static void main(String[] args) {
		//show(3,4);
		/*
		//虽然少定义了多个方法。
		但是每次都要定义一个数组。作为实际参数。

		int[] arr = {3,4};
		show(arr);

		int[] arr1 = {2,3,4,5};
		show(arr1);
		*/

		show("张三",1,2,3,4,5,6);

	}
	public static void show(String str,int... arr){
		System.out.println(arr.length);
	}
}

导入静态(ImportStatic)-JDK 1.5 版本出现的新特性
1.作用：导入这个类中所有的静态成员
2.好处：简化书写
3.思考：
  import 加static和不加static 有什么区别？
加static，导入的是这个类中所有的静态成员
不加static，导入的是这个包中所有的类
4.注意：
当类名重名时，需要指定具体的包名。
当方法重名时，需要指定具备所属的对象或者类。

导入静态实例：

import java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static  java.lang.System.*;//导入了System类中所有静态成员。

class StaticImport {
	public static void main(String[] args) {
		int[] arr = {1,5,3,4};

		sort(arr);
		int index = binarySearch(arr,1);
		out.println("Index="+index);
		out.println(Arrays.toString(arr));
	}
}