Java中的集合嵌套

Collections集合工具类：

shuffle()    随机置换打乱（只能传list)

sort()    集合元素升序排列

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class Demo05 {

    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        System.out.println(list);
        //打乱集合元素顺序
        Collections.shuffle(list);
        System.out.println(list);
        //排序(按内容排序)
        Collections.sort(list);
        System.out.println(list);
    }

}

集合嵌套：

集合嵌套，仅仅是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo06 {

    public static void main(String[] args) {
        //大 Map
        HashMap<String, HashMap<Person,String>> oracle=new HashMap<String, HashMap<Person,String>>();
        //小Map
        HashMap<Person,String> java1018= new HashMap<Person,String>();
        HashMap<Person,String> java1227= new HashMap<Person,String>();
        //封装小的
        java1018.put(new Person("吉吉国王",18), "山东淄博");
        java1018.put(new Person("熊大",18), "山东济南");
        java1227.put(new Person("熊二",28), "山东济南");
        java1227.put(new Person("光头强",20), "山东淄博");
        //封装大的
        oracle.put("java1018", java1018);
        oracle.put("java1227", java1227);
        //entrySet+Iterator
        //先获取大Map的结婚证对象Set集合
        Set<Map.Entry<String, HashMap<Person,String>>> bigentrys=oracle.entrySet();
        //2.遍历结婚证集合到每一个结婚证对象
        //获取迭代器对象
        Iterator<Map.Entry<String, HashMap<Person,String>>> it=bigentrys.iterator();
        while(it.hasNext()){
            //获取每一个大结婚证对象
            Map.Entry<String, HashMap<Person,String>> bigentry=it.next();
            //获取大结婚证对象的key
            String bigkey=bigentry.getKey();
            //获取大结婚证对象的value
            HashMap<Person,String> smallMap=bigentry.getValue(); 
            
            //3.获取小Map的结婚证对象Set集合
            Set<Map.Entry<Person,String>> smallentrys=smallMap.entrySet();
            //4.遍历小结婚证对象取到每一个小结婚证对象
            //获取迭代器对象
            Iterator<Map.Entry<Person,String>> it2=smallentrys.iterator();
            while(it2.hasNext()){
                //获取每一个小结婚证对象
                Map.Entry<Person,String> smallentry=it2.next();
                //获取小结婚证对象的key
                Person smallKey=smallentry.getKey();
                //获取小结婚证对象的value
                String smallValue=smallentry.getValue();
                System.out.println(bigkey+"..."+smallKey+"..."+smallValue);
            }
        }
//keySet+增强for
        Set<String> set1=oracle.keySet();
        for(String s:set1){
            //小map value
            HashMap<Person, String> map = oracle.get(s);
            Set<Person> s1=map.keySet();
            for(Person s2:s1){
                System.out.println(s+"..."+s2+"..."+map.get(s2));
            }
        }
        
        System.out.println("---------keySet+iteracor");
        Set<String> set2=oracle.keySet();
        Iterator<String> it=set2.iterator();
        while(it.hasNext()){
            String p=it.next();
            HashMap<Person, String> map = oracle.get(p);
            Set<Person> s3=map.keySet();
            Iterator<Person> it2=s3.iterator();
            while(it2.hasNext()){
                Person p1=it2.next();
                System.out.println(p+"..."+p1+"..."+map.get(p1));
            }
        }
        
        System.out.println("---------entrySet+增强for");
        Set<Map.Entry<String, HashMap<Person,String>>> bigentrys=oracle.entrySet();
        for(Map.Entry<String, HashMap<Person,String>> s4:bigentrys){
            String s5 = s4.getKey();
            HashMap<Person,String> map2=s4.getValue();
            Set<Map.Entry<Person,String>> s6=map2.entrySet();
            for(Map.Entry<Person,String> s7:s6){
                
                System.out.println(s5+"..."+s7.getKey()+"..."+s7.getValue());
            }
            
        }

            
    }

}

静态导入：

　　在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。

静态导入格式：

import static XXX.YYY;   导入后YYY可直接使用。

可变参数：

　　在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。