31-JDK5.0特性（foreach循环+函数的可变参数+静态导入）

一、foreach循环

1、foreach语句：增强型的for循环

2、foreach语句的格式：

      for(类型 变量名 : 单列集合或数组){ ... }

        /**
         * 遍历集合
         */
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");

        /**
         * 方法一：使用迭代器遍历取出
         * 迭代器本身是一个对象，可以在迭代的过程中对元素进行操作
         */
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        /**
         * 方法二：使用foreach循环取出，简化书写（高级for）
         * 将迭代动作简化成一个语句，其底层用的还是迭代
         * 通常只用于 遍历/迭代，将元素取出，不会在过程中对元素进行过多的操作
         */
        for (String s : list) {
            System.out.println(s);
        }

        /**
         * 遍历数组
         */
        int[] arr = {3, 7, 9, 5};
        for (int i : arr) {
            System.out.println(i);
        }

3、传统for和高级for的区别

（1）传统for：可以完成对语句执行很多次，因为可以定义控制循环的增量和条件（传统for中可以定义变量，可以确定其循环条件及循环次数）

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

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

即 

（1）如果仅仅为了取出，使用高级for遍历目标 -- 简化书写

（2）一旦有特定操作，要么用迭代器，要么用传统for循环

4、不可以直接使用高级for遍历双列集合Map。但可以将Map双列变单列（Set），再用迭代器或高级for遍历

注：高级for只能遍历单列集合（Collection）或数组

        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "zhangsan");
        map.put(2, "lisi");
        map.put(3, "wangwu");

        /**
         * 方法一：keySet()
         */
        for (Integer key : map.keySet()) {
            String value = map.get(key);
            System.out.println("key = " + key + ", value = " + value);
        }

        /**
         * 方法二：enterSet()
         */
        for (Map.Entry<Integer, String> me : map.entrySet()) {
            Integer key = me.getKey();
            String value = me.getValue();
            System.out.println("key = " + key + ", value = " + value);
        }

二、函数的可变参数

1、若想求多个整数的和，不能用重载，因为不确定有多少个数据。可以将参数定义成明确了类型的数组，但要在调用方法前，将数组建立好并传入

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

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

    /**
     * 函数的可变参数
     * ...代表省略，后面有很多。可以传入n多int类型的值，也可以不传（是简化型的数组，称为可变参数）
     * 将 创建数组、封装数组元素 等动作在内部完成了
     *
     * @param arr
     * @return
     */
    public static int newAdd(int... arr) {
        //验证，int... 其实就是数组
        System.out.println(arr);    //[I@50cbc42f

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

    public static void main(String[] args) {

        //直接将数组中的元素作为参数传入即可
        System.out.println(newAdd(1, 5, 6));
        System.out.println(newAdd(1, 5, 4, 7, 3));
        //可变参数，可以不传（此处相当于传入了一个空数组）
        System.out.println(newAdd());   //0

    }

3、可变参数类型必须定义在参数列表的结尾处，且只能有一个

三、静态导入

1、导入包的目的是为了简化书写。不导包也可以，用全类名

2、静态导入：import static java.xxx.类名.方法名;    或    import static java.xxx.类名.*;。使用时，省略“类名.” ，直接用方法名调用即可

        //一般写法
        import java.util.Collections;
        Collections.sort(list);
        
        //静态导入的写法
        import static java.util.Collections.*;  //简写时，可以使用Collections中的所有方法
        import static java.util.Collections.sort;   //简写时，只能使用Collections中的导入的sort()方法
        //使用静态导入后，Collections.sort(list); 可简写为
        sort(list);

3、静态导入，导入的是类中的静态成员（静态变量或静态方法）

//        System.out.println();
        //能省略System是因为out是静态的，不能省略out是因为println()方法是非静态的
        import static java.lang.System.out;
        out.println("xxx");

4、静态导入，如果类中的方法和其他类方法发生冲突时，类名不可以省略

eg：静态导入两个类，两个类中有相同名称的静态方法/静态变量，此时使用省略类名调用相同名称的静态方法/静态变量，会导致调用不确定，所以此种情况不能省略类名