/*
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);
}
}
