JDK5特性学习

1. 自动拆装箱：基本类型与包装类型自动转换。
   源码：

    @Test
	public void auto() {
	    //Integer---int
	    Integer integer = 10;
	    int i = integer;
	    //Byte---byte
	    Byte B = 10;
	    byte b = B;
	    //Short---short
	    Short S = 10;
	    short s = S;
        //Long---long
        Long L = 10L;
        long l = L;
        //Character---char
        Character C = 'a';
        char c = C;
	    //Double---double
        Double D = 5d;
        double d = D;
        //Float---float
        Float F = 5f;
        float f = F;
        //Boolean---boolean
        Boolean Bl = true;
        boolean bl = Bl;
        System.out.println("自动拆装箱");
	}

编译：

  @Test
  public void auto()
  {
    Integer integer = Integer.valueOf(10);
    int i = integer.intValue();

    Byte B = Byte.valueOf(10);
    byte b = B.byteValue();

    Short S = Short.valueOf(10);
    short s = S.shortValue();

    Long L = Long.valueOf(10L);
    long l = L.longValue();

    Character C = Character.valueOf('a');
    char c = C.charValue();

    Double D = Double.valueOf(5.0D);
    double d = D.doubleValue();

    Float F = Float.valueOf(5.0F);
    float f = F.floatValue();

    Boolean Bl = Boolean.valueOf(true);
    boolean bl = Bl.booleanValue();
    System.out.println("自动拆装箱");
  }

2. 增强for循环。

    @Test
    public void forEach() {
        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");
        list.add("333");
        for (String str : list){
            System.out.println("str:" + str);
        }
        int[] ints = new int[]{1, 2, 3, 4, 5};
        for(int i : ints){
            System.out.println("i: " + i);
        }
        System.out.println("增强for循环");
    }

3. 静态导入：可以将静态方法和静态变量通过 import static 和导包一样的方式直接导入，使用的时候无需使用类名即可直接访问。

import static java.lang.Math.*;
@SpringBootTest
public class JDK5Test {
    @Test
    public void importStatic() {
        System.out.println(max(3, 6));
        System.out.println("静态导入");
    }
}

4. 可变参数：当传入到方法的参数不固定时，可以使用可变参数。格式：数据类型… 参数名。可变参数实际为数据。
   源码：

    @Test
    public void args() {
        varArgs(1);
        varArgs(2,3);
        System.out.println("可变参数");
    }
    
    public void varArgs(int... ints) {
        System.out.println(ints instanceof int[]);
        for (int i : ints){
            System.out.println(i);
        }
    }

编译：

  @Test
  public void args()
  {
    varArgs(new int[] { 1 });
    varArgs(new int[] { 2, 3 });
    System.out.println("可变参数");
  }

  public void varArgs(int[] ints) {
    System.out.println(ints instanceof int[]);
    for (int i : ints)
      System.out.println(i);
  }

结合泛型使用：
源码：

    @Test
    public void args() {
        varArgs("av");
        varArgs(2,3);
        System.out.println("可变参数");
    }
    
    public <T> void varArgs(T... ints) {
        System.out.println(ints instanceof Integer[]);
        for (T i : ints){
            System.out.println(i);
        }
    }

编译：

  @Test
  public void args()
  {
    varArgs(new String[] { "av" });
    varArgs(new Integer[] { Integer.valueOf(2), Integer.valueOf(3) });
    System.out.println("可变参数");
  }

  public <T> void varArgs(T[] ints) {
    System.out.println(ints instanceof Integer[]);
    for (Object i : ints)
      System.out.println(i);
  }

5. 枚举。
   源码：

    //枚举类型
    public enum SexEnum {
        MAN,WOMAN;
    }
    
//    @Ignore 
    @Test
    public void enumTest() {
        System.out.println(SexEnum.valueOf("MAN"));
        System.out.println(SexEnum.valueOf("WOMAN"));
        for (SexEnum sex : SexEnum.values()) {
            System.out.println(sex);
        }
        System.out.println("枚举");
    }

6. 格式化输出。

/**
     * 格式化输出
     */
//    @Ignore 
    @Test
    public void formatTest() {
        //创建对象时指定将结果输出到控制台
        Formatter formatter = new Formatter(System.out);
        formatter.format("x = %d , y = %s\n", 1, "test");
        formatter.close();
        System.out.println("格式化输出");
    }

7. 泛型。泛型格式：<>。
   通配符问号(?)表示任意类型.如"List<?>"表示可以存放任意对象类型的List，和List一样。
   通配符可以连接限制符：extends 和 super。上边界List<? extends Parent> 申明的List只能存放Parent及其子类，而下边界 List<? super Child> 申明的List只能存放Child及其父类。

    /**
     * 泛型
     */
//    @Ignore 
    @Test
    public void generics() {
        List<?> allList = new ArrayList<>();
        List<? extends Date> extendsList = new ArrayList<>();
        List<? super Date> superList = new ArrayList<>();
        getE("泛型");
        System.out.println("泛型");
    }
    
    public <E> E getE(E e) {
        return e;
    }

9. ProcessBuilder。