day17集合框架的工具类Collections。二分法查找原理 。操作数组的工具类Arrays，集合变数组。高级for循环。可变参数

/*
集合框架的工具类Collections。二分法查找原理 。操作数组的工具类Arrays，集合变数组。高级for循环。可变参数
*/
import java.util.*;
/*
Collections,集合框架的工具类。对集合进行操作的类。方法都是静态的。

sort(List),对List集合进行排序。
binarySearch(),二分法查找
fill(List<? super T> list, T obj) 
          使用指定元素替换指定列表中的所有元素。

reverse(List<?> list) 
          反转指定列表中元素的顺序。

replaceAll(List<T> list, T oldVal, T newVal) 
          使用另一个值替换列表中出现的所有某一指定值。

reverseOrder() 
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

reverseOrder(Comparator<T> cmp) 
          返回一个比较器，它强行逆转指定比较器的顺序。

 synchronizedList(List<T> list) 
          返回指定列表支持的同步（线程安全的）列表。

swap(List<?> list, int i, int j) 
          在指定列表的指定位置处交换元素。

shuffle(List<?> list) 
          使用默认随机源对指定列表进行置换。
		  把集合中的元素重新随机进行置换。

			Collections.shuffle(list);		  
		  */
class  CollectionsDemo
{
	public static void main(String[] args) 
	{
		//sortDemo();
		maxDemo();
	}
	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");
		sop(list);
		//Collections.sort(list);//按元素的自然排序。
		Collections.sort(list,new StrLenCompare());//按比较器方式排序
		String max = Collections.max(list);
		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 StrLenCompare());//按比较器方式排序
		String max = Collections.max(list/*,new StrLenCompare()*/);
		Collections.fill(list,"pp");//将集合中的元素全部替换成pp
		sop(list);
		sop("max::"+max);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
class StrLenCompare implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		int num = s1.length() - s2.length();
		if(num == 0)
		{
			return s1.compareTo(s2);
		}
		return num;
	}
}


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class BinarySearchDemo {

	/**二分法查找原理 
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		searchDemo();
	}
	
	public static void searchDemo()
	{
		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 StrLenCompare());//按比较器方式排序
		sop(list);
		//int index = Collections.binarySearch(list, "aaaa",new StrLenCompare());
		int index = binaryDemo(list, "aaaa");//二分法查找必须要是排序后的集合
		System.out.println("index="+index);
	
	}
	
	public static int binaryDemo(List<String> list,String key)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min<=max)
		{
			mid =(max+min)/2;
			String s = list.get(mid);
			int num = s.compareTo(key);
			if(num>0)
			{
				max = mid-1;
			}
			else if(num<0)
			{
				min = mid+1;
			}else
				return mid;
		}
		return -min-1;
	}
	public static int binaryDemo2(List<String> list,String key,Comparator<String> cmp)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min<=max)
		{
			mid =(max+min)/2;
			String s = list.get(mid);
			//int num = s.compareTo(key);
			int num = cmp.compare(s, key);//自定义比较器
			if(num>0)
			{
				max = mid-1;
			}
			else if(num<0)
			{
				min = mid+1;
			}else
				return mid;
		}
		return -min-1;
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

class StrLenCompare implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		int num = s1.length() - s2.length();
		if(num == 0)
		{
			return s1.compareTo(s2);
		}
		return num;
	}
}



import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
//练习，
public class FillDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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.fill(list, "ppp");//替换集合全部元素
		fillTest(list,1,4,"kk");//替换部分集合，自定义的方法
			//Collections.replaceAll(list, "kk", "afa");//把指定值替换成new值
			//Collections.reverse(list);反转集合。
		sop(list);
	}
	public static void fillTest(List<String> list,int start,int end,String str)
	{
		Collections.fill(list.subList(start,end),str);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

}
/*
reverseOrder() 
          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
reverseOrder(Comparator<T> cmp) 
          返回一个比较器，它强行逆转指定比较器的顺序。

 synchronizedList(List<T> list) 
          返回指定列表支持的同步（线程安全的）列表。
*/


/*
Arrays:用于操作数组的工具类
里面都是静态方法
asList():将数组变list集合
*/
import java.util.*;
class  ArraysDemo
{
	public static void main(String args[])
	{
		String arr[] = {"mm","hh","hhg","hhj","jj"};

		System.out.println(Arrays.toString(arr));//StringBuffer

		//把数组变成List集合有什么好处？
		/*
		可以使用集合的思想和方法来操作数组中的元素。
		注意：将数组变成集合，可以查询，但是不能增删！！！
		因为数组的长度是固定的。
		可以contains,get,indexOf(),subList()。不能add
		*/
		List<String> list = Arrays.asList(arr);//把数组变成集合
		System.out.println("list"+list);

		boolean b = list.contains("jj");
		System.out.println(b);

		int[] nums = {2,4,5};
		Arrays.asList(nums);

		List li = Arrays.asList(nums);
		//List <int[]>list = Arrays.asList(nums);加泛型
		/*
		如果数组中的元素都是对象(引用)，那么变成集合时，数组中的元素
		就直接转成集合中的元素。

		如果数组中的元素都是基本数据类型，那么就将该数组
		作为集合中的元素存在。

		int[] nums = {2,4,5};可以用Integer[] nums
		*/
		System.out.println(list);
	}
}

/*
集合变数组
Collection接口中的toArray方法
*/
import java.util.*;

class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc02");
		al.add("abc03");
		/*
		1指定类型的数组到底要定义多长呢？
		当指定类型的数组长度小于集合的size,那么方法内部
		会创建一个新的数组，长度为集合的size.

		当指定类型的数组长度大于了集合的size,
		就不会新创建数组，而是使用传递进来的数组。
		所以创建一个刚刚好的数组最优。 al.toArray(new String[al.size()]);

		2为什么要将集合变数组？
		为了限定对元素的操作。
		返回一个集合给对方 ，对方可以操作，比如增删。
		那我返回一个数组，对方不能增删了。
		*/
		String[] arr = al.toArray(new String[al.size()]);

		System.out.println(Arrays.toString(arr));
	}
}
/*
高级for循环
格式：
for(数据类型 变量名：被遍历的集合（Collection）或者数组){}
对集合进行遍历，只能获取，但是不能对集合进行过多的操作

迭代器除了遍历，还可以进行remove操作集合中的元素的动作。
如果使用ListIterator,还可以在遍历过程中
进行增删改查的动作。

传统for和高级for有什么区别？
高级for有一个局限性，必须有被遍历的目标。
想对hello world打印一百次。高级就不推荐。

建议在遍历数组时，还是希望使用传统for,因为传统for可以定义角标
*/
import java.util.*;
class  ForEach
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc02");
		al.add("abc03");

		for (String str :al)//上面必须加泛型，这里才能用String
		{
			str ="kk";//改变str的指向，al里面的没变。
			//只能遍历，不能修改。
			System.out.println(str);
		}
	}
}

/*
	使用高级for遍历Map集合。
	for(Map.Entry<String,String> me:hm.entrySet())
	{
		System.out.println(me.getKey()+"---"+me.getValue());
	}
	for(String s:hm.keySet())
	{
		System.out.println(s+"::"+hm.get(s));
	}

*/

/*
JDK1.5版本出现的新特性

可变参数就是上一种数组参数的简写形式
不用每一次都手动建立数组对象
只要将要操作的元素作为参数传递
隐式将这些参数封闭成了数组。

方法的可变参数
在方法中，是以数组的形式操作可变参数的。
在使用时，注意：可变参数一定要定义在参数列表的最后面。
不能放前面或者中间。
(String str,int... arr);这是可以的。
(int... arr,String str)这是不可以的。
--------------------------------------

StaticImport 静态导入

格式：import static java.util.Arrays.*;
导入的是Arrays这个类中的所有静态成员
Object 中也有toString();
System.out.println(Arrays.toString(arr));

当类名重名时，需要指定具体的包名。
当方法重名时，指定具体所属的对象或类。

import static java.lang.System.*;
导入了System类中所有的静态成员
out.println();

导入static时,导入的是某个类中的静态成员
没有static,导入类，导入的是类。
*/

import java.util.*;
class  ParamMethodDemo
{
	public static void main(String[] args) 
	{
		show(2,3);
	}
	//1.5以后
	public static void show(int... arr)//可变参数
	{
		System.out.println(arr.length);
	}
}