一、Collections

Collections中的方法都是静态的

1 void sort(List<? extends Comparable<? super T>> list);//list集合元素必须具备比较性
2 void sort(List<T>,Comparator<? super T> c);//指定比较器,list集合元素可以不具备比较性

1 void swap(List<T>,int i,int j);//位置替换,相当于以下代码
2 //T temp = list.get(i);
3 //list.set(i,list.get(j));
4 //list.set(j,temp)

1 //二分查找（折半查找），List必须先排序再使用binarySearch
2 int binarySearch(List<? extends Comparable<? super T>> list,T key);
3 int binarySearch(List<? extends T> list,T key,Comparator<? super T> c);

1 //求最值
2 max(Collection<? extends T> coll);
3 max(Collection<? extends T> coll,Comparator<? super T> comp);
4 
5 min(Collection<? extends T> coll);
6 min(Collection<? extends T> coll,Comparator<? super T> comp);

 1 //逆转
 2 void reverse(List<?> list);
 3 Comparator<T> reverseOrder();//返回一个比较器，强行逆转实现了Comparable接口的对象collection的自然顺序
 4 Comparator<T> reverseOrder(Comparator<T> cmp);
 5 /*
 6 用法：
 7 1、TreeSet ts=new TreeSet(reverseOrder());
 8 
 9 2、sort(list,reverseOrder());
10 */

1 //替换
2 boolean replaceAll(List<T> list,T oldVal,T newVal);//替换指定值
3 //实现原理：
4 list.set(list.indexOf(oldVal,newVal));

1 //指定元素替换指定列表中所有元素
2 void fill(List<? super T> list , T obj);
3 
4 //随机对指定列表进行置换
5 void shuffle(List<?> list);

 1 //非同步的集合加锁
 2 List<T> synchronizedList(List<T> list);//返回同步List集合
 3 //原理：
 4 class MyCollections{
 5     public static List synchronizedList(List list){
 6         retutn new MyList(list)
 7     }
 8     private class MyList implements List{
 9         private List list;
10         private static final Object lock=new Object();
11         MyList(List list){
12             this.list=list;
13         }
14         
15         public boolean add(Object obj){
16             synchronized(lock){
17                 return list.add(obj);
18             }
19         }
20         public boolean remove(Object obj){
21             synchronized(lock){
22                 return list.remove(obj);
23             }
24         }
25     }
26 }

二、Arrays

 1 //二分查找
 2 binarySearch
 3 copyOf
 4 copyOfRange
 5 equals
 6 fill
 7 sort
 8 deepEquals(Object[] o1,Object[] o2);//深度比较，比较元素对象中的属性
 9 
10 List asList(数组);//将数组转成集合。
11 /*
12 好处：其实可以使用集合的方法操作数组。
13 注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的，否则会发生UnsupportedOperationException
14 
15 如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素
16 String arr={"ab","abc","abd","abe"};
17 List list = Arrays.asList(arr);
18 list元素("ab","abc","abd","abe")
19 如果数组中的元素时基本类型数值，那么将数组作为集合中的元素
20 int[] arr = {1,2,3,4};
21 List list = Arrays.asList(arr);
22 list元素(int[]数组对象)
23 */