静态导入，，，可变参数，，， Collections集合工具类

 静态导入

静态导入格式：

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