java Collections集合工具类

/*
Collections是Collection的工具类。
工具类中其中两个比较常用的方法就是：
1，sort(list)  、  sort(list,自定义比较器)
2，max(list)   、  max(list,自定义比较器)
3，binarySearch(list,key) //利用折半查找的方法找到list中key元素的索引，存在则返回索引，不存在则返回-(插入点)-1

*/

import java.util.*;

class CollectionsDemo
{
	public static void main(String[] args)
	{
		sortDemo();
	}

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

		list.add("shdgjh");
		list.add("Alklkjjj");
		list.add("and");
		list.add("hello");
		list.add("World");
		list.add("Hello");
		list.add("hello");

		//sop("原始list:"+list);
		//排序：
		Collections.sort(list);//根据元素的自然顺序 对指定列表按升序进行排序。
		sop("按照自然顺序排序后的list:"+list);
		//Collections.sort(list,new MyComparator());// 根据指定比较器产生的顺序对指定列表进行排序。
		//sop("按照字符串长度排序后的list："+list);

		//获取最大值
		//String max=Collections.max(list);//根据元素的自然顺序，返回给定 collection 的最大元素。
		//sop("返回自然顺序最大的对象："+max);
		//String max1=Collections.max(list,new MyComparator());
		//sop("返回字符串长度最大的对象："+max1);

		int num=Collections.binarySearch(list,"and");//使用二分查找找到某一元素的索引值并返回
		sop("and的索引-调用binarySearch方法："+num);

		int y=halfSearch(list,"and");
		sop("and的索引-调用自定义的halfSearch方法："+y);

	}

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

	public static int halfSearch(List<String> list,String key)
	{
		int min=0,max=list.size()-1;
		while(min<=max)
		{
			int mid=(min+max)>>1;//左乘右除
			String str=list.get(mid);
			int x=str.compareTo(key);
			if(x>0)
				max=mid-1;
			else if(x<0)
				min=mid+1;
			else
				return mid;
		}
		return -min-1;
	}

}

class MyComparator 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);
	}
}

/*
Collection集合的工具类：
Collections中的常用方法（续）
1,	fill(list,"Hello");//用Hello来替换list中的所有对象。
2,	replaceAll(list,old,new);//用new对象替换list中所有的old对象。
3,	reverse(list);//list元素反转

*/

import java.util.*;
class CollectionsDemo1
{
	public static void main(String[] args)
	{
		fillDemo();
 	}

	public static void fillDemo()
	{
		List<String> list=new ArrayList<String>();
		list.add("Hello1");
		list.add("Hello2");
		list.add("Hello3");
		list.add("Hello4");
		list.add("Hello5");
		list.add("Hello6");
		list.add("Hello3");

		sop(list);

		Collections.shuffle(list);
		sop(list);

		Collections.swap(list,1,3);
		sop(list);
		//Collections.fill(list,"Hello World");//替换list中的全部对象
		//list=fillDemo_1(1,4,list,"me");//替换指定索引起始和终点位置的对象。
		Collections.replaceAll(list,"Hello3","me...");//替换list中所有的Hello3对象
		sop(list);

		Collections.reverse(list);//反转
		sop(list);
	}

	public static List<String> fillDemo_1(int first,int last,List<String> list,String key)
	{
		for(int i=first;i<last;i++)
		{
			list.set(i,key);
		}
		return list;
	}

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

/*
工具类Collections中有一个反转方法，返回的是一个比较器。
reverseOrder()  返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
在本例中，TreeSet集合会对元素进行自然顺序的排序，
如果在构造函数中调用工具类中的该方法，则会强行逆转自然顺序。

Collections.reverseOreder();//对自然顺序进行反转。
Collections.reverseOreder(new MyComparator());//对自定义的比较器比较后的顺序进行反转。
*/
import java.util.*;

//代码实现工具集的reverseOrder()反转方法的原理：实际开发中不用写这部分代码。因为已经封装好了
class StrComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		return s2.compareTo(s1);//自然顺序的逆序。
		//return s1.compareTo(s2);//自然顺序的正序。
		/*
		逆序解释：
		int num=s1.compareTo(s2);
		if(num>0)
			return -1;
		if(num<0)
			return 1;
		return num;
		*/
	}
}

class MyComparator 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);
	}
}

class CollectionsDemo2
{
	public static void main(String[] args)
	{

		//TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder());//使用工具类中的反转方法(自然顺序)
		//TreeSet<String> ts=new TreeSet<String>(new StrComparator());//自然顺序反转原理实现
		TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new MyComparator()));//对自定义的比较器比较后的顺序进行反转，这个真的好牛啊！
		ts.add("hello");
		ts.add("kl");
		ts.add("heyjk");
		ts.add("ash");
		ts.add("u");
		ts.add("bght");

		sop(ts);
		Iterator<String> it=ts.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}

	}

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

}