靜態匯入、可變引數、Collections集合工具類

阿新 • • 發佈：2020-07-17

靜態匯入

靜態匯入格式：

import static java.util.Map.Entry

import static XXX.YYY;   匯入後YYY可直接使用。

可變引數

格式：

修飾符 返回值型別 方法名(引數型別... 形參名){  }

修飾符 返回值型別 方法名(引數型別[] 形參名){  }

public class ParamDemo {
    public static void main(String[] args) {
        int[] arr = {21,89,32};
        int sum = add(arr);
        System.out.println(sum);
        sum = add(21,89,32);//可變引數呼叫形式
        System.out.println(sum);
        
    }

    //JDK1.5之後寫法
    public static int add(int...arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    //原始寫法
    /*
    public static int add(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
    */
}

注意：如果在方法書寫時，這個方法擁有多引數，引數中包含可變引數，可變引數一定要寫在引數列表的末尾位置。

public static int add(int...a)//形參中只能有一個可變參
public static int add(double b,int...a)//可以在前面插入引數

Collections集合工具類

Collections是集合工具類，用來對集合進行操作。

    public static <T> void sort(List<T> list) // 集合元素排序
//排序前元素list集合元素 [33,11,77,55]
Collections.sort( list );
//排序後元素list集合元素 [11,33,55,77]

    public static void shuffle(List<?> list) //  集合元素儲存位置打亂
//list集合元素 [11,33,55,77]
Collections.shuffle( list );
//使用shuffle方法後，集合中的元素為[77,33,11,55]，每次執行該方法，集合中儲存的元素位置都會隨機打亂

集合巢狀

l Map集合巢狀

HashMap<String, HashMap<String,String>>

HashMap<String, HashMap<Person,String>>

public class Demo03 {
public static void main(String[] args) {
    HashMap<String, HashMap<Person,String >> oracle=new HashMap<String, HashMap<Person,String >>();
    HashMap<Person, String> java0512=new HashMap<Person,String>();
    java0512.put(new Person("小紅",18), "優秀");
    java0512.put(new Person("小白",20), "不及格");
    HashMap<Person, String> java0715=new HashMap<Person,String>();
    java0715.put(new Person("小綠",25), "良好");
    java0715.put(new Person("小黑",23), "及格");
    oracle.put("java0512", java0512);
    oracle.put("java0715", java0715);
    //遍歷
    //1.keySet+增強for
    //獲取所有Key所在的set集合
    Set<String> bigKeys=oracle.keySet();
    //遍歷獲取每一個key
    for(String bigKey:bigKeys){
        String bkey=bigKey;//獲取大Map中的key值
        //獲取大Map中的Velue值
        HashMap<Person,String > bigValue=oracle.get(bkey);
        //遍歷小Map
        //獲取小key所在的set集合
        Set<Person> smallKeys=bigValue.keySet();
        //遍歷取到每一個key
        for(Person smallkey:smallKeys){
            Person skey=smallkey;//獲取小Map中獲取key值
            String sval=bigValue.get(skey);//獲取小map中的value值
            System.out.println(bkey+"..."+skey+"..."+sval);
        }
    }
    //2.keySet+Iterator迭代
    Set<String> b=oracle.keySet();//獲取所有Key所在的set集合
    Iterator<String> bb=b.iterator();//獲取迭代器物件
    while(bb.hasNext()){
        //遍歷大Map中的key值
        String bbb=bb.next();
        //遍歷大Map中的value值
        HashMap<Person,String > bv=oracle.get(bbb);
        //獲取所有key所在的set集合
        Set<Person> xx=bv.keySet();
        //獲取迭代器物件
        Iterator<Person> x1=xx.iterator();
        while(x1.hasNext()){
            Person i=x1.next();//小map的key值
            System.out.println(bbb+",,,"+i+",,,"+bv.get(i));//bv.get(i)小map的key值
        }
    }
    //3.entrySet+增強for
    Set<Map.Entry<String,HashMap<Person,String > >> arr=oracle.entrySet();//獲取Map中所有key和value的對應關係
    for(Map.Entry<String,HashMap<Person,String > > i:arr){//遍歷set集合
        String j=i.getKey();//獲取大Map的key值
        HashMap<Person,String > k=i.getValue();//獲取大Map的value值
        Set<Map.Entry<Person, String>> k1=k.entrySet();//獲取小Map中的所有key和value的對應關係（一對）
        for(Map.Entry<Person, String> aa:k1){//遍歷小map集合
            Person a1=aa.getKey();//獲取小map集合的key值
            String a2=aa.getValue();//獲取小map集合的value值
            System.out.println(j+"ooo"+a1+"ooo"+a2);
        }
    }
    //4.entrySet+Iterator迭代
    Set<Map.Entry<String,HashMap<Person,String >>> brr=oracle.entrySet();//獲取Map中所有key和value的對應關係（一對）
    Iterator<Map.Entry<String,HashMap<Person,String >>> die=brr.iterator();//獲取迭代器物件
    while(die.hasNext()){//遍歷大Map
        Map.Entry<String,HashMap<Person,String >> first=die.next();//大Map的一對值
        String i=first.getKey();//大Map的Key值
        HashMap<Person,String > i1=first.getValue();//大Map的Value值（小Map的一對值）
        Set<Map.Entry<Person,String>> i2=i1.entrySet();//獲取小Map中的所有key和value的對應關係（一對）
        Iterator<Map.Entry<Person,String>> i3=i2.iterator();//獲取迭代器物件
        while(i3.hasNext()){//遍歷小Map
            Map.Entry<Person,String> i4=i3.next();//小Map的一對值
            Person i5=i4.getKey();//小Map的Key值
            String i6=i4.getValue();//小Map的Value值
            System.out.println(i+"..."+i5+"..."+i6);
        }
        
    }
}
}