java笔记--集合框架工具类Collections和Array

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

比较器：

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;
        }
    
}

CollectionsDemo:

public static void main(String[] args) {
        /*
        Collections:是集合框架的工具类。
        里面的方法都是静态的。
        */
        demo_1();
        demo_2();
        demo_3();
        demo_4();
    }

    private 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");//替换
        Collections.shuffle(list);//随机把元素安放在集合的位置上
//      Collections.fill(list, "cc");//全部替换成cc
        System.out.println(list);
        
    }

    private static void demo_3() {
        /*逆序
        TreeSet<String> ts=new TreeSet<String>(new Comparator<String>(){

            @Override
            public int compare(String o1, String o2) {
                
                int temp=o2.compareTo(o1);
                return temp;
            
            
        }
            
    });*/
        TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));//逆序比较器再调用
        ts.add("abc");
        ts.add("hahaha");
        ts.add("zzz");
        ts.add("aa");
        ts.add("cba");
        
        System.out.println(ts);
}

    private 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");
        System.out.println(list);
        
        int index=Collections.binarySearch(list, "cba");
        System.out.println("index="+index);
        
//      获取最大值
        String max=Collections.max(list,new ComparatorByLength());
        System.out.println("max="+max);
        
    }

    private 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);
//      mySort(list);
        mySort(list,new ComparatorByLength());
    }

    //Collections中sort方法的原理
    private static<T extends Comparable<? super T>> void mySort(List<T> list,Comparator<? super T> comp) {
        
        for(int i=0;i<list.size();i++){
            for(int j=i+1;j<list.size();j++){
                //if(list.get(i).compareTo(list.get(j))>0)
                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);
                }
            }
        }   
    }

运行：

如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。

如果数组中的元素是基本类型数值，那么将该数组作为集合中的元素进行存储。
ArrayDemo:

//数组转集合
    public static void main(String[] args) {
        
        /*
        Arrays:集合框架的工具类。
        里面的方法都是静态的。
        */
        int[] arr={3,1,5,6,3,6};
        System.out.println(Arrays.toString(arr));
        
        demo_2();
    }

    private static void demo_2() {
        /*
        如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
        
        如果数组中的元素是基本类型数值，那么将该数组作为集合中的元素进行存储。
        */
        int[] arr={31,11,51,61};
        
        List<int[]> list=Arrays.asList(arr);
        
        System.out.println(list.size());
    }

    private static void demo_1() {
        
        /*
        重点：List asList(数组)将数组转成集合。
        
        好处：其实可以使用集合的方法操作数组中的元素。
        注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的
        否则会发生UnsupportedOperationException
        */
        
        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 contain:"+b1);
//      list.add("hiahia");UnsupportedOperationException
        
        System.out.println(list);
    }

    private static boolean myContains(String[] arr, String key) {
        for(int i=0;i<arr.length;i++){
            if(arr[i].equals(key))
                return true;
        }
        return false;
    }
    //toString的经典实现，Api里的实现方法
    public static String myToString(int[] a){
        int iMax=a.length-1;
        if(iMax==-1)
            return "[]";
        
        StringBuilder b=new StringBuilder();
        b.append('[');
        for(int i=0;;i++){//中间省了条件判断，提高了效率
            b.append(a[i]);
        if(i==iMax)
                return b.append(']').toString();
        b.append(",");
        }
    }

运行：

集合转成数组：使用的是Collections接口中的toArray()

集合转成数组：可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
ToArray:

public static void main(String[] args) {
        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));
    }

运行：

1.5特性：

foreach语句：
格式：
for(类型 变量 ：Collection集合|数组){}

传统for和高级for的区别？
传统for可以完成对语句执行很多次，因为可以定义控制循环的变量和条件。

高级for是一种简化形式。它必须有被遍历的目标。该目标要么是数组，要么是Collection单列集合。

对数组的遍历如果仅仅是获取数组中的元素，可以使用高级for。如果要对数组的角标进行操作建议使用传统for。
Foreach：

public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        
        for(String s:list){//简化书写
            System.out.println(s);
        }
        
        int[] arr={3,1,5,7,4};
        
        for(int i:arr){
            System.out.println(i);
        }
//      可以使用高级for遍历map集合吗？不能直接用，但是可以将map转成单列的set，就可以用了
        Map<Integer,String> map=new HashMap<Integer,String>();
        
        map.put(3,"zhagsan");
        map.put(1,"wangyi");
        map.put(7,"wagnwu");
        map.put(4,"zhagsansan");
        
        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);
        }
    }

函数的可变参数。其实就是一个数组，但是接收的是数组的元素。自动将这些元素封装成数组。简化了调用者的书写。

注意：可变参数类型，必须定义在参数列表的结尾。

ParamterDemo:

public static void main(String[] args) {
        
        int sum=add(4,5);
        System.out.println("sum="+sum);
        int sum1=add(4,5,6);
        System.out.println("sum1="+sum1);

        int[] arr={5,1,4,7,3};
        int sum3=add(arr);
        System.out.println("sum3="+sum3);
        int[] arr1={5,9,1,4,7,3,9,8,7,6};
        int sum4=add(arr1);
        System.out.println("sum4="+sum4);
        
        int sum5=newAdd(5,1,4,7,3);
        System.out.println("sum5="+sum5);
        int sum6=newAdd(5,9,1,2,7,3,9,8,7,6);
        System.out.println("sum6="+sum6);
    }
    /*
    函数的可变参数。
    其实就是一个数组，但是接收的是数组的元素。
    自动将这些元素封装成数组。简化了调用者的书写。
    
    注意：可变参数类型，必须定义在参数列表的结尾。
    */
    private static int newAdd(int b,int... a) {
        int sum=0;
        for(int i=0;i<a.length;i++){
            sum+=a[i];
        }
        return sum;
    }

    private static int add(int[] arr) {
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum+=arr[i];
        }
        return sum;
    }

    private static int add(int i, int j, int k) {
        return i+j+k;
    }

    private static int add(int i, int j) {
        return i+j;
    }

运行：

java Api提供的静态方法可以用import导入

StaticImportDemo：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.*;//静态导入，其实到入的是类中的静态成员。
//import static java.util.Collections.max;//静态导入，其实到入的是类中的静态成员。

import static java.lang.System.*;

public class StaticImportDemo {

    public static void main(String[] args) {
    
        List<String> list = new ArrayList<String>();
        
        list.add("abc3");
        list.add("abc7");
        list.add("abc1");

        out.println(list);
        
        sort(list);
        
        System.out.println(list);
        
        String max=max(list);
        out.println(max);
    }
}

运行：

List list = new ArrayList();//非同步的。
list = MyCollections.synList(list);//返回一个同步的list.
给非同步的集合加锁的原理：

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

Collections中有提供给非同步的集合加锁的方法。