Java的集合框架——工具类（Collections，Arrays）

Collections

是集合框架的工具类，里面的方法都是静态的。

此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

排序

Collections.sort
默认的情况：

public static void demo_1(){
		
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");
		System.out.println(list);
		
		
		//对list集合进行指定顺序的排序。
		
		Collections.sort(list);
		//对字符串类型来说，是通过自带的比较器进行比较的，也就是按字母顺序
		System.out.println(list);

自定义比较器：
现在自定义一个比较器，实现按照字符串的长度来排序：

import java.util.Comparator;

public class ComparatorByLength implements Comparator<String> {

	@Override
	public int compare(String o1, String o2) {

		int temp = o1.length() - o2.length();
		
		return temp==0?o1.compareTo(o2): temp;
	}

}

接下来向sort方法中传入这个自定义的比较器：

Collections.sort(list,new ComparatorByLength());

运行结果：

成功实现了按照字符串的长度来排序。

折半

必须要保证元素有序的前提下才能使用折半查找。
Collections.binarySearch

	public static void demo_2(){
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");
		Collections.sort(list);
		System.out.println(list);
		
		int index = Collections.binarySearch(list, "aaa");		
		System.out.println("index="+index);

以上的例子是查找元素不存在的情况。返回负号就表示没有查到，此时的index为插入点-1（-1是为了保证插入点为0的情况仍为负数）。本例中即为-1-1=-2。
此时将“aaa”添加到集合中再次运行：

同样，也可以给Collections.binarySearch指定比较器。

最值

不要求有序。

	public static void demo_2(){
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("aaa");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");

		System.out.println(list);
		
		//获取最大值。
		String max = Collections.max(list);
		System.out.println("max="+max);

同样也可以传入比较器：

String max = Collections.max(list,new ComparatorByLength());

最小值将max改为min即可。

逆序

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

public static void demo_3() {
		
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());	
		
		ts.add("abc");
		ts.add("hahaha");
		ts.add("zzz");
		ts.add("aa");
		ts.add("cba");
		
		System.out.println(ts);
		
	}

这个逆序实现的原理如下：

TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){

			@Override
			public int compare(String o1, String o2) {
				
				int temp = o2.compareTo(o1); //將o1与o2的位置替换就实现了逆序
				return temp;
			}
			
		});

对已经有的比较器进行逆转：
Collections.reverseOrder(比较器)
将上面的例子改动一下：

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));	

就实现了基于长度的逆序排列。

替换

Collections.replaceAll(）

	public static void demo_4() {
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("zhangsan");
		list.add("zhaoliu");
		list.add("xiaoqiang");
		
		System.out.println(list);
		Collections.replaceAll(list, "cba", "nba");// 原理：set(indexOf("cba"),"nba");

		System.out.println(list);
	}

其他方法

Collections.fill()

能将集合中的所有元素初始化一次。

	public static void demo_4() {
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("zhangsan");
		list.add("zhaoliu");
		list.add("xiaoqiang");
		
		System.out.println(list);
		Collections.fill(list, "cc");
		System.out.println(list);
	}

Collections.shuffle()

对集合中的元素乱序排列。
还是用上面的例子：

Collections.shuffle(list);

每次运行结果都是不同的，这体现了随机的特点。

将非同步集合转成同步集合的方法

若想要自己实现，可以这么写：

//给非同步的集合加锁。

class MyCollections{

	public static  List synList(List list){
		
		return new MyList(list); 
	}

	private class MyList implements List{ //内部类，用来返回一个同步的list
		private List list;
		
		private static final Object lock = new Object();//创建一个锁对象
		
		MyList(List list){	//构造函数
			this.list = list;	
		}
		
		public boolean add(Object obj){
			synchronized(lock)
			{
				return list.add(obj);//方法还是用原来的，只不过加上了同步
			}
		}
		
		public boolean remove(Object obj){
			synchronized(lock)
			{
				return list.remove(obj);
			}
		}
	}
}

List list = new ArrayList();//非同步的。

list = MyCollections.synList(list);//返回一个同步的list.

如果觉得自己实现比较麻烦，那么恭喜你， Collections这个工具类中已经提供了现成的方法：

那就是synchronizedXXX()。

Arrays

集合框架的工具类。里面的方法都是静态的。

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

常用的方法直接查询API即可：
binarySearch
copyOf
copyOfRange
deepEquals(Object[] a1, Object[] a2)
如果两个指定数组彼此是深层相等 的，则返回 true。
equals
fill
hashCode
sort（升序）
toString

数组->集合 ：Arrays.asList( )

重点：List **asList(数组)**将数组转成集合。
好处：其实可以使用集合的方法操作数组中的元素。

	public static void demo_1() {
		
		String[] arr = {"abc","haha","xixi"};
		
		boolean b = myContains(arr, "xixi"); //数组的方法
		System.out.println("contains:"+b);
		
		List<String> list = Arrays.asList(arr);
		boolean b1 = list.contains("xixi");//集合的方法
		System.out.println("list contaisn:="+b1);

	}

注意：
（1）数组的长度是固定的，所以对于集合的增删方法是不可以使用的
否则会发生UnsupportedOperationException。

list.add("hiahia");//UnsupportedOperationException

（2）

• 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
• 如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。（此时集合中只有一个数组对象）

	public static void demo_2() {
		
		
		int[] arr = {31,11,51,61};
		
		List<int[]> list = Arrays.asList(arr);
		
		System.out.println(list);
	}

集合->数组 ：XXX.toArray( )

集合转成数组 使用的就是Collection接口中的toArray方法。
可以对集合中的元素操作的方法进行限定。不允许对其进行增删。

List<String> list = new ArrayList<String>();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		
		
		/*
		 * toArray方法需要传入一个指定类型的数组。
		 * 长度该如何定义呢？
		 * 如果长度小于集合的size，那么该方法会创建一个同类型并和集合相同size的数组。
		 * 如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认为null。
		 * 
		 * 所以建议，最后长度就指定为，集合的size。
		 */
		String[] arr = list.toArray(new String[list.size()]);
		
		System.out.println(Arrays.toString(arr));