java5新特性简单介绍

新特性介绍

java5是2004年9月份发布的，主要特性有泛型，枚举，可变参数，注解等。

泛型

先看一下泛型的简单使用

public class Client {
  public static void main(String[] args) {
    List<String> names = new ArrayList<String>();
    names.add("lisi");
    String name = names.get(0);
    System.out.println(name);
  }
}

在java5之前的使用形式为

public class Client {
  public static void main(String[] args) {
    List names = new ArrayList();
    names.add("lisi");
    String name = (String) names.get(0);
    System.out.println(name);
  }
}

我们不能确定List集合中可以放什么类型的元素，在类型转换时就可能出错。
我们看一下java5版本例子反编译的结果

public class Client {
    public static void main(String[] args) {
        List names = new ArrayList();
        names.add("lisi");
        String name = (String)names.get(0);
        System.out.println(name);
    }
}

可以看到反编译之后就没有泛型了，这个就是类型擦除，泛型信息只会在编译期存在，编译后的字节码中不会保存。

枚举

public enum UserGenderEnum {
  MALE("0", "男"),
  FEMALE("1", "女"),
  NOT_KNOWN("2", "未知");

  private final String code;
  private final String info;

  UserGenderEnum(String code, String info) {
    this.code = code;
    this.info = info;
  }

  public String getCode() {
    return code;
  }

  public String getInfo() {
    return info;
  }
}

public class Client {
  public static void main(String[] args) {
    EnumMap<UserGenderEnum, String> enumMap = new EnumMap<>(UserGenderEnum.class);
    enumMap.put(UserGenderEnum.MALE, "male");
    System.out.println(enumMap.get(UserGenderEnum.MALE));
    UserGenderEnum male = UserGenderEnum.MALE;
    switch (male) {
      case MALE:
        System.out.println("male");
        break;
      case FEMALE:
        System.out.println("female");
        break;
      case NOT_KNOWN:
        System.out.println("not_known");
        break;
    }
  }
}

枚举的使用还是很简单的，Enum是所有枚举都会继承的抽象类，EnumMap,EnumSet是java提供的工具类，java也提供了对枚举的switch的支持，关于枚举的更多原理，请看枚举这篇博客。

自动装箱和拆箱

装箱就是primitive类型转成对应的wrapper类型，拆箱就是反过来，Boolean,Byte,Character,Integer,Short,Long,Double,Float
下面以int和Integer来演示

public class Client {
  public static void main(String[] args) {
    Integer score = 98;//自动装箱
    System.out.println(score);
    int newScore = score + 2;//自动拆箱
    System.out.println(newScore);
  }
}

看一下反编译结果

public class Client {
    public static void main(String[] args) {
        Integer score = Integer.valueOf((int)98);
        System.out.println((Object)score);
        int newScore = score.intValue() + 2;
        System.out.println((int)newScore);
    }
}

可以看到自动装箱就是编译器帮我们调用了valueOf方法，拆箱就是调用了intValue方法。

可变参数

public class Client {
  public static void main(String[] args) {
    System.out.println(sum(1, 2, 3));
  }

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

}

反编译结果

public class Client{

    public Client(){
    }

    public static void main(String args[]){
        System.out.println(sum(new int[] {
            1, 2, 3
        }));
    }

    private static transient int sum(int nums[]){
        int sum = 0;
        for(int i = 0; i < nums.length; i++)
            sum += nums[i];

        return sum;
    }
}

可以看到可变参数的本质就是数组。

增强for循环

public class Client {
  public static void main(String[] args) {
    int[] nums = {1, 2, 3, 4};
    for (int num : nums) {
      System.out.println(num);
    }
    List<String> nameList = new ArrayList<>();
    nameList.add("lisi");
    nameList.add("zhangsan");
    nameList.add("wangwu");
    for (String name : nameList) {
      System.out.println(name);
    }
  }
}

反编译结果为

public class Client{

    public Client(){
    }

    public static void main(String args[]){
        int nums[] = {
            1, 2, 3, 4
        };
        int ai[] = nums;
        int i = ai.length;
        for(int j = 0; j < i; j++){
            int num = ai[j];
            System.out.println(num);
        }

        List nameList = new ArrayList();
        nameList.add("lisi");
        nameList.add("zhangsan");
        nameList.add("wangwu");
        String name;
        for(Iterator iterator = nameList.iterator(); iterator.hasNext(); System.out.println(name))
            name = (String)iterator.next();

    }
}

可以看到增强for循环也是语法糖。

注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
  String value();
}

@Log("hello")
public class User {
}

public class Client {
  public static void main(String[] args) {
    Log log = User.class.getAnnotation(Log.class);
    System.out.println(log.value());
  }
}

结果为

hello

静态导入

import static java.lang.Math.PI;
import static java.lang.Math.max;

public class Client {
  public static void main(String[] args) {

    System.out.println(max(2, 5));
    System.out.println(PI);
  }
}

反编译结果为

public class Client{

    public Client(){
    }

    public static void main(String args[]){
        System.out.println(Math.max(2, 5));
        System.out.println(3.1415926535897931D);
    }
}

还是语法糖。

并发支持（JUC类库）

提供了一些原子类如AtomicInteger，线程池工具Executors，线程安全的容器ConcurrentHashMap等。

java.lang.instrument类库

具体可以看这篇这篇

StringBuilder

非线程安全的字符串连接工具