常用对象API（集和框架--工具类）

Collections-排序
对list集和进行指定顺序的排序

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
//通过字符串长度进行比较的比较器
class ComparatorByLength implements Comparator<String>{
    public int compare(String o1,String o2) {
        int temp = o1.length()-o2.length();
        return temp==0?o1.compareTo(o2):temp;
    }
}
public class CollectionsDemo {
    public static void main(String args[]) {
        demo_1();
    }
    public static void demo_1() {
        List<String> list = new ArrayList<String>();
        list.add("abcde");
        list.add("fddd");
        list.add("addd");
        list.add("hello");
        list.add("world");
        System.out.println(list);
        //对list集和进行指定顺序的排序
        // Collections.sort(list);
        //mySort(list);
        mySort_string(list,new ComparatorByLength());
        System.out.println(list);
    }
    public static <T extends Comparable<? super T>> void mySort(List<T> list) {
        for(int i=0;i<list.size()-1;i++){
            for(int j=i+1;j<list.size();j++){
                if((list.get(i).compareTo(list.get(j)))>0){
                    // T temp = list.get(i);
                    // list.set(i, list.get(j));
                    // list.set(j, temp);
                    Collections.swap(list, i, j);
                }
            }
        }
    }
    //通过自定义比较器按字符串长度排序
    public static <T> void mySort_string(List<T> list,Comparator<? super T> comp) {
        for(int i=0;i<list.size()-1;i++){
            for(int j=i+1;j<list.size();j++){
                //comp.compare(list.get(i), list.get(j));
                if(comp.compare(list.get(i),list.get(j))>0){
                    // T temp = list.get(i);
                    // list.set(i, list.get(j));
                    // list.set(j, temp);
                    Collections.swap(list, i, j);
                }
            }
        }
    }
}

二分查找（List）

int index = Collections.binarySearch(list, "hello");//[addd, fddd, abcde, hello, world]
System.out.println("index:"+index);//index:3

求集和最大值

System.out.println(Collections.max(list));//world

求集和最小值

System.out.println(Collections.min(list));//abcde

Collections.reverseOrder()

// TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());
//Collections.reverseOrder()可以将具备的自然排序的顺序进行逆转
//[pencil, hahh, book, bag, as]
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
//将已有比较器进行逆转 

Collections.replaceAll()

List<String> ts = new ArrayList<String>();
ts.add("hahh");
ts.add("boas");
ts.add("bag");
ts.add("pencil");
ts.add("as");
ts.add("z");
System.out.println(ts);//[hahh, boas, bag, pencil, as, z]
Collections.replaceAll(ts,"as","hello");
ts.set(0, "element");//[element, boas, bag, pencil, hello, z]
System.out.println(ts);//[hahh, boas, bag, pencil, hello, z]

Collections.fill()

Collections.fill(ts, "zz");//[zz, zz, zz, zz, zz, zz]

Collections.shuffle()

Collections.shuffle(ts);//[hahh, boas, bag, pencil, as, z]-->[z, boas, bag, hahh, as, pencil]

给非同步的集和加锁
原理

class MyCollections{
    public static List synList(List list) {
        return new MyList(list);
    }
    private class MyList implements 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

如何得到同步的集和

List<String> list = new ArrayList<>();
List<String> ts = Collections.synchronizedList(list);

Arrays 数组转集和

public static void demo_2() {
	/**
	 * Arrays集和框架的工具类。里面的方法都是静态的。
	 */
	//Arrays.toString()方法
	// int[] arr = {1,2,3,4,5};
	// System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5]
	//asList(数组)：方法将数组转成集和
	//好处：可以使用集和的方法操作数组的元素。
	//注意：数组的长度是固定的，所以对于集和的增删方法是不能使用的，
	//否则会发生异常：java.lang.UnsupportedOperationException
	String[] arr = {"haha","xixi","hehe"};
	List<String> list = Arrays.asList(arr);//数组转集和
	//list.add("heihei");//java.lang.UnsupportedOperationException
	System.out.println(list.contains("haha"));//true
}

public static void demo_3(){
	/**
	 * 如果数组中的元素是对象，转成集和时，直接将数组中的元素作为集和中的元素进行存储
	 * 如果数组中的元素是基本类型数值，那么会将该数组作为集和中的元素进行存储。
	 */
	int[] arr = {1,2,3,4};
	List list = Arrays.asList(arr);
	System.out.println(list);//[[I@279f2327]
}

toArray 集和转数组

//集和转数组
    //使用的是Collection接口中的toArray方法。
    //集和转数组可以对集和中的元素操作方法进行限定：不允许对其进行增删
    public static void demo_4(){
    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));
}

JDK1.5特性
foreach

public static void demo_5(){
       /**
        * foreach语句：
        * 格式：
        * for(类型 变量：collection集和|数组)
        * {
        * }
        */
       List<String> list = new ArrayList<String>();
       list.add("abc1");
       list.add("abc2");
       list.add("abc3");
       // Iterator<String> it = list.iterator();
       // while(it.hasNext()){
       //     System.out.println(it.next());
       // }
       for(String s:list){
           System.out.println(s);
       }
       int[] arr = {1,2,3,4};
       for(int i:arr){
           System.out.println(i);
       }
       /**
        * 传统for和高级for的区别：
        * 传统for可以控制循环的增量和条件；
        * 高级for是一种简化形式，必须有被遍历的目标，该目标要么是数组要么是collection单列集和。
        * 对于数组的遍历，如果仅仅是获取数组中的元素，使用高级for，如果要对数组角标进行操作，使用传统for。
        * 不能直接用高级for遍历map集和!将map集和转成单列的set就可以了
        */
       Map<Integer,String> map = new HashMap<>();
       map.put(1,"he");
       map.put(2,"hei");
       map.put(3,"hen");
       for(Integer key:map.keySet()){
           String value = map.get(key);
           System.out.println(key+"::"+value);
       }
       for(Map.Entry<Integer,String> me : map.entrySet()){
           Integer key = me.getKey();
           String value = me.getValue();
           System.out.println(key+"_"+value);
       }
    }

函数可变参数

System.out.println(new_add(1,2,3,4,5));//15
/**
     * 函数的可变参数。
     * 其实就是一个数组，但是接收的是数组的元素。
     * 自动将这些元素封装成数组，简化了调用者的书写。
     * 注意事项：可变参数类型必须定义在参数列表的结尾处。
     */
    public static int new_add(int... arr){
        int sum = 0;
        for(int i=0;i<arr.length;i++){
            sum = sum+arr[i];
        }
        return sum;
    }

静态导入

import java.util.Collections;
import java.util.ArrayList;
import java.util.List;
import static java.util.Collections.sort;//静态导入，其实导入的是类中的静态成员
public static void main(String args[]) {
        List<String> list = new ArrayList<String>();
        list.add("he");
        list.add("hah");
        list.add("heihei");
        sort(list);
    }