java 静态导入、可变参数、集合嵌套

一 静态导入

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

在源码中经常会出现静态导入。

静态导入格式：

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

Map.Entry的访问，简化后为Entry

import static java.util.Map.Entry;
public class HashMapTest {
    public static void main(String[] args) {
        //1,创建hashmap集合对象。
        Map<Student,String> map = new HashMap<Student,String>();

        //取出元素。键值对方式
        //Set<Map.Entry<Student, String>> entrySet = map.entrySet();
        Set<Entry<Student, String>> entrySet = map.entrySet();

        //for (Map.Entry<Student, String> entry : entrySet) {
        for (Entry<Student, String> entry : entrySet) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key.toString()+"....."+value);
        }
    }
}

二 可变参数

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

简化成如下格式：

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

其实这个书写完全等价与

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

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

　　jdk1.5以后。出现了简化操作... 用在参数上，称之为可变参数。

　　同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将

数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进

行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：  

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

　　上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性

　　注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定

要写在参数列表的末尾位置。

三  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]，每次执行该方法，集合中存储的元素位置都会随机打乱

四 集合嵌套

　　集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如Collection集合嵌套、Collection

集合与Map集合相互嵌套、Map集合嵌套。

ArrayList嵌套 ArrayList

　　ArrayList< ArrayList<String> >

　　Collection< ArrayList<Integer> >

Map嵌套 ArrayList

　　HashMap<String, ArrayList<Person>>

　　ArrayList< HashMap<String, String>>

Map集合嵌套

　　HashMap<String, HashMap<String,String>>

　　HashMap<String, HashMap<Person,String>>

map 集合嵌套的遍历

package com.oracle.demo02;

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

import com.oracle.demo01.Person;

public class Demo04 {
    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);
        //keyset 增强for
        /*Set<String> bigkeyset = oracle.keySet();
        for (String bigkey : bigkeyset) {
            HashMap<Person,String> smallhm = oracle.get(bigkey);
            Set<Person> smallkeyset = smallhm.keySet();
            for (Person smallkey : smallkeyset) {
                String smallvalue = smallhm.get(smallkey);
                System.out.println(bigkey+"..."+smallkey+"..."+smallvalue);
            }
        }*/
        //Iteratro
        /*Set<String> bigkeyset = oracle.keySet();
        Iterator<String> bigit = bigkeyset.iterator();
        while(bigit.hasNext()){
             String bigkey = bigit.next();
             HashMap<Person,String> smallhm = oracle.get(bigkey);
             Set<Person> smallkeyset = smallhm.keySet();
             Iterator<Person> smallit =  smallkeyset.iterator();
            while (smallit.hasNext()) {
                Person smallkey = smallit.next();
                System.out.println(bigkey+"..."+smallkey+"..."+smallhm.get(smallkey));
            }
        }*/
        //entry+增强for
    /*    Set<Map.Entry<String, HashMap<Person,String>>> bighmset = oracle.entrySet();
        for (Entry<String, HashMap<Person, String>> bighm : bighmset) {
            String bigkey = bighm.getKey();
            HashMap<Person,String> smallhm = bighm.getValue();
            Set<Map.Entry<Person,String>> smallhmset = smallhm.entrySet();
            for (Entry<Person, String> smallhmen : smallhmset) {
                Person smallkey = smallhmen.getKey();
                String smallvalue = smallhmen.getValue();
                System.out.println(bigkey+"..."+smallkey+"..."+smallvalue);
            }
        }*/
        //iterator
    /*    Set<Map.Entry<String, HashMap<Person,String>>> bighmset = oracle.entrySet();
        Iterator<Entry<String, HashMap<Person,String>>> bigit = bighmset.iterator();
        while (bigit.hasNext()) {
            Entry<String, HashMap<Person,String>> bighmen = bigit.next();
            String bigkey = bighmen.getKey();
            HashMap<Person,String> smallhm = bighmen.getValue();
            Set<Map.Entry<Person,String>> smallset = smallhm.entrySet();
            Iterator<Entry<Person,String>> smallit = smallset.iterator();
            while (smallit.hasNext()) {
                Entry<Person, String> smallen = smallit.next();
                Person smallkey = smallen.getKey();
                String smallvaule = smallen.getValue();
                System.out.println(bigkey+"..."+smallkey+"..."+smallvaule);
            }
        }*/
        //keyset
        /*Set<String> bigset = oracle.keySet();
        for (String bigkey : bigset) {
            HashMap<Person,String> smallhm = oracle.get(bigkey);
            Set<Person> smallset = smallhm.keySet();
            for (Person smallkey : smallset) {
                String smallvaule = smallhm.get(smallkey);
                System.out.println(bigkey+" "+smallkey+" "+smallvaule);
            }
        }*/
    /*    Set<String> bigset = oracle.keySet();
        Iterator<String> bigit = bigset.iterator();
        while (bigit.hasNext()) {
            String bigkey = bigit.next();
            HashMap<Person,String> smallhm = oracle.get(bigkey);
            Set<Person> smallset = smallhm.keySet();
            Iterator<Person> smallit = smallset.iterator();
            while (smallit.hasNext()) {
                Person smallkey = smallit.next();
                String smallvaule = smallhm.get(smallkey);
                System.out.println(bigkey+" "+smallkey+" "+smallvaule);
            }
        }*/
        //entry
        /*Set<Entry<String, HashMap<Person,String>>> bigset = oracle.entrySet();
        for (Entry<String, HashMap<Person, String>> bigen : bigset) {
            String bigkey =  bigen.getKey();
            HashMap<Person, String> smallhm = bigen.getValue();
            Set<Entry<Person, String>> smallset = smallhm.entrySet();
            for (Entry<Person, String> smallen : smallset) {
                Person smallkey = smallen.getKey();
                String smallvaule = smallen.getValue();
                System.out.println(bigkey+" "+smallkey+" "+smallvaule);
            }
        }*/
        Set<Entry<String, HashMap<Person,String>>> bigset = oracle.entrySet();
        Iterator<Entry<String, HashMap<Person,String>>> bigit = bigset.iterator();
        while (bigit.hasNext()) {
            Entry<String, HashMap<Person,String>> bigen = bigit.next();
            String bigkey = bigen.getKey();
            HashMap<Person,String> smallhm = bigen.getValue();
            Set<Entry<Person,String>> smallset = smallhm.entrySet();
            Iterator<Entry<Person,String>> smallit = smallset.iterator();
            while (smallit.hasNext()) {
                Entry<Person,String> smallen = smallit.next();
                Person smallkey = smallen.getKey();
                String smallvaule = smallen.getValue();
                System.out.println(bigkey+" "+smallkey+" "+smallvaule);
            }
        }
    }
}

五 集合继承体系的面向对象思想

接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；

抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；

具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自

身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。