JDK1.5新特性

一、静态导入

静态导入：jdk1.5新特性

格式：

import static 包名.类名.静态成员;

作用范围：一个类的所有静态成员

未使用静态导入：需要重复书写多个Collections

import java.util.ArrayList;
import java.util.Collections;

public class Demo8 {
    
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(5);
        list.add(4);
        list.add(2);
        list.add(1);
        
        //排序
        Collections.sort(list);
        System.out.println("集合的元素是："+list);//集合的元素是：[1, 2, 3, 4, 5]
        
        //索引值
        int binarySearch = Collections.binarySearch(list, 4);
        System.out.println("索引值："+binarySearch);//索引值：3
    }

}

使用静态导入：

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.*;
public class Demo8 {
    
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(5);
        list.add(4);
        list.add(2);
        list.add(1);
        
        //排序
        sort(list);
        System.out.println("集合的元素是："+list);//集合的元素是：[1, 2, 3, 4, 5]
        
        //索引值
        int binarySearch = binarySearch(list, 4);
        System.out.println("索引值："+binarySearch);//索引值：3
    }

}

当本类和静态导入的方法名相同时，使用的是本类的方法。
只要静态导入的成员和本类的成员有同名的情况，都是使用本类的成员。

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.*;
import static java.lang.System.out;
public class Demo8 {
    
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(5);
        list.add(4);
        list.add(2);
        list.add(1);
        
        //作用在方法上
        //排序 
        //指定调用静态导入的成员：相当于静态导入不起作用了
        Collections.sort(list);//本类的sort方法
        out.println("集合的元素是："+list);//集合的元素是：[1, 2, 3, 4, 5]
        
        //索引值
        int binarySearch = binarySearch(list, 4);
        out.println("索引值："+binarySearch);//索引值：3
        
        //作用在属性上
        out.println("xxx");
    }
    
    public static void sort(ArrayList<Integer> list) {
        System.out.println("本类的sort方法");
    }

}

注意：如果静态导入的成员与本类的成员存在同名的情况下，那么默认使用本类的静态成员，如果需要指定使用静态导入的成员，那么需要在静态成员前面加上类名。

二、增强for循环

作用：简化迭代器的书写格式

适用范围： 实现了Iterable接口的对象或者是数组对象

格式:

for(变量类型 变量名：遍历的目标){

}

demo：

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

public class Demo9 {
    
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        //添加元素
        set.add("1");
        set.add("2");
        set.add("3");
        
        //使用迭代器遍历
        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);
            //报错：java.util.ConcurrentModificationException
            //在使用迭代器遍历的过程中不准使用集合修改元素的个数
            //set.remove("3");
        }
        
        int[] arr = {1,2,3,4,5};
        //普通for循环遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println("元素："+arr[i]);
        }
        
        //使用增强for循环实现
        for (int i : arr) {
            System.out.println("元素："+i);
        }
        
        //遍历map
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("1", "张三");
        map.put("2", "李四");
        map.put("3", "王五");
        map.put("4", "赵六");
        map.put("5", "陈七");
        Set<Entry<String,String>> entrys = map.entrySet();
        for (Entry<String, String> entry : entrys) {
            System.out.println("键："+entry.getKey()+"值："+entry.getValue());
        }
    }

}

注意：增强for循环的底层还是使用了迭代器遍历。

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

注意：Map集合没有实现Iterable接口，所以map集合不能直接使用增强for循环；需要使用增强for循环需要借助Collection。

自定义类使用增强for循环

import java.util.Iterator;

class MyList implements Iterable<String>{
    
    Object[] arr = new Object[10];
    
    int index = 0;//当前指针
    
    public void add(Object o) {
        arr[index++] = 0;
    }

    public int size() {
        return index;
    }
    
    @Override
    public Iterator<String> iterator() {
        
        return new Iterator<String>() {
            
            int cursor = 0;

            @Override
            public boolean hasNext() {
                return cursor<index;
            }

            @Override
            public String next() {
                return (String) arr[cursor++];
            }
            
        };
    }
    
}

public class Demo10{
    public static void main(String[] args) {
        MyList list = new MyList();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        
        for (String item : list) {
            System.out.println(item);
        }
    }
}

三、可变参数

格式：

数据类型... 变量名

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

public class Demo11 {
    
    public static void main(String[] args) {
        add();
        add(1);
        add(1,2);
    }
    
    public static void add(int... arr) {
        System.out.println("参数是："+arr);//[I@15db9742
        int result = 0;
        for (int i : arr) {
            result += i;
        }
        System.out.println("和是："+result);
    }

}

四、自动装箱和自动拆箱

Java是面向对象的语言，任何事物都可以使用类来描述，sun使用一些类描述Java中八种数据类型

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

自动装箱： 自动把java的基本数据类型数据转换成对象类型数据。
自动拆箱： 把引用类型的数据转换成基本类型的数据

import java.util.ArrayList;

public class Demo12 {
    
    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的二进制："+ Integer.toBinaryString(10));
        System.out.println("10的十六进制："+ Integer.toHexString(10));
        
        
        //可以把字符串当成对应的进行数据帮你转换
        String data = "10";
        int a = Integer.parseInt(data, 2);
        System.out.println("a="+a);
        
        
        //集合： 集合是可以存储任意对象类型数据的容器。
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        
        //自动装箱： 自动把java的基本数据类型数据转换成对象类型数据。
        int temp = 10;  //基本数据类型
        Integer b =temp; //把a存储的值赋予给b变量。
        
        
        //自动拆箱： 把引用类型的数据转换成基本类型的数据
        Integer c = new Integer(13);
        int d = c; //
        System.out.println(d);
        
        //引用的数据类型
        Integer e = 128;
        Integer f = 128; 
        // Integer类内部维护 了缓冲数组，该缓冲数组存储的-128~127 这些数据在一个数组中。
        //如果你获取的数据是落入到这个范围之内的，那么就直接从该缓冲区中获取对应的数据。
        System.out.println("同一个对象吗？"+(e==f)); //false
        
        
    }
    
}