Day 11：静态导入、增强for循环、可变参数的自动装箱与拆箱

jdk1.5新特性-------静态导入

静态导入的作用： 简化书写。 
静态导入可以作用一个类的所有静态成员。
 
静态导入的格式：
import static 包名.类名.静态的成员；
 
静态导入要注意的事项：
 　　如果静态导入的成员与本类的成员存在同名的情况下，那么默认使用本类的静态成员，如果需要指定使用静态导入的成员，那么需要在静态成员前面加上类名

import java.util.ArrayList;
import java.util.Collections;
import static java.util.Collections.sort;
import static java.util.Collections.binarySearch;
import static java.util.Collections.max;
import static java.lang.System.out;

public class Demo1 {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(13);
        list.add(9);
        list.add(10);
        list.add(19);
        
        //排序
        Collections.sort(list);
        out.println("集合的元素："+ list);
        out.println("索引值："+ binarySearch(list,13));
        out.println("最大值："+ max(list));
    }
    
    public static void sort(ArrayList<Integer> list){
        System.out.println("本类 的sort方法.....");
    }    
}

jdk1.5出现的新特性----增强for循环

增强for循环的作用： 简化迭代器的书写格式。(注意：增强for循环的底层还是使用了迭代器遍历。)

增强for循环的适用范围： 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。

增强for循环的格式：
 　　 for(数据类型  变量名  :遍历的目标){
  
 　　 }

增强for循环要注意的事项：
　　 1. 增强for循环底层也是使用了迭代器获取的，只不过获取迭代器由jvm完成，不需要我们获取迭代器而已，所以在使用增强for循环变量元素的过程中不准使用集合
　　     对象对集合的元素个数进行修改。
 　　2. 迭代器遍历元素与增强for循环变量元素的区别：使用迭代器遍历集合的元素时可以删除集合的元素，而增强for循环变量集合的元素时，不能调用迭代器的remove方法删除元素。
 　　3. 普通for循环与增强for循环的区别：普通for循环可以没有变量的目标，而增强for循环一定要有变量的目标。

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

public class Demo1 {
    
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        //添加元素
        set.add("李杰");
        set.add("李英");
        set.add("李汉三");
        
        /*
        //使用迭代器遍历Set的集合.
        Iterator<String> it  = set.iterator();
        while(it.hasNext()){
            String temp = it.next();
            System.out.println("元素："+ temp);
            it.remove();
        }
        
        //使用增强for循环解决
        for(String item : set){
            System.out.println("元素："+ item);    
        }
        
        int[] arr = {12,5,6,1};
         普通for循环的遍历方式
         for(int i =  0 ; i<arr.length ; i++){
            System.out.println("元素："+ arr[i]);
        }
        
        //使用增强for循环实现
        for(int item :arr){
            System.out.println("元素："+ item);
        }
        */
        //注意： Map集合没有实现Iterable接口，所以map集合不能直接使用增强for循环，如果需要使用增强for循环需要借助于Collection的集合。
        HashMap<String,String> map = new HashMap<String,String>();
        map.put("001","张三");
        map.put("002","李四");
        map.put("003","王五");
        map.put("004","赵六");
        Set<Map.Entry<String, String>> ent = map.entrySet();
        for(Map.Entry<String, String> entry  :ent){
            System.out.println("键："+ entry.getKey()+" 值："+ entry.getValue());
        }            
    }
}

jdk1.5新特性之-------可变参数

需求： 定义一个函数做加法功能（函数做几个数据 的加法功能是不确定）。

可变参数的格式：

　　数据类型... 变量名

可变参数要 注意的细节：
 1. 如果一个函数 的形参使用上了可变参数之后，那么调用该方法的时候可以传递参数也可以不传递参数。
 2. 可变参数实际上是一个数组对象。
 3. 可变参数必须位于形参中的最后一个参数。
 4. 一个函数最多只能有一个可变参数，因为可变参数要位于形参中最后一个位置上。
 

public class Demo2 {

    public static void main(String[] args) {
        add(1,2,3);
    }
    
    public static void add(int... arr){ 
        int result = 0;
        for(int item : arr){
            result+=item;
        }
        System.out.println("总和："+ result);
    }    
}

 jdk1.5新特性之-----自动装箱与自动拆箱。
 
 java是面向对象 的语言，任何事物都可以使用类进行描述，sun就使用了
 一些类描述java中八种基本数据类型数据
 
  基本数据类型            包装类型
 byte           Byte
 short         Short
 int             Integer
 long          Long
 
 float          Float
 double      Double
 
 boolean     Boolean
 
 char          Character

基本数据类型数据有了对应的包装类型的好处：如下

import java.util.ArrayList;

public class Demo3 {
    
    public static void main(String[] args) {
        /*String str = "12";
        
        //字符串转换成int类型数据。 可以把字符串转换成对应的数字
        int i = Integer.parseInt(str);
        System.out.println(i+1);
        
        //把数字转换成字符串
        System.out.println("把整数转换成对应 的字符串："+Integer.toString(i));
        
        //把整数转换成对应的进制形式
        System.out.println("10的2进制："+ Integer.toBinaryString(10));
        System.out.println("10的8进制："+ Integer.toOctalString(10));
        System.out.println("10的16进制："+ Integer.toHexString(10));
        
        //可以把字符串当成对应的进行数据帮你转换
        String data = "10";
        int a = Integer.parseInt(data, 2);//把data当成2进制数据，转换成十进制数据，进制最大为36
        System.out.println("a="+a);
    
        //集合： 集合是可以存储任意   对象类型    数据的容器。
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        
        //自动装箱： 自动把java的基本数据类型数据转换成对象类型数据。
        int a = 10;  //基本数据类型
        Integer b =a; //把a存储的值赋予给b变量。
        System.out.println(b);
        
        //自动拆箱： 把引用类型的数据转换成基本类型的数据
        int d = new Integer(13); 
        System.out.println(d);
        */
        //引用的数据类型
        Integer e = 128;
        Integer f = 128;
        System.out.println("同一个对象吗？"+(e==f)); 
        // Integer类内部维护 了缓冲数组，该缓冲数组存储的-128~127 这些数据在一个数组中。
        //如果你获取的数据是落入到这个范围之内的，那么就直接从该缓冲区中获取对应的数据。
        
    }
}