Java7 部分新特性备忘录

1、Catching Multiple Exception Types and Rethrowing Exceptions with Improved Type Checking

①：Handling More Than One Type of Exception

old：

catch (IOException ex) {     logger.log(ex);     throw ex;catch (SQLException ex) {     logger.log(ex);     throw ex;}

new：

catch (IOException|SQLException ex) {    logger.log(ex);    throw ex;}

②：Rethrowing Exceptions with More Inclusive Type Checking

old：

  static class FirstException extends Exception { }  static class SecondException extends Exception { }  public void rethrowException(String exceptionName) throws Exception {    try {      if (exceptionName.equals("First")) {        throw new FirstException();      } else {        throw new SecondException();      }    } catch (Exception e) {      throw e;    }  }

new：

  public void rethrowException(String exceptionName)  throws FirstException, SecondException {    try {      // ...    }    catch (Exception e) {      throw e;    }  }

2、Type Inference for Generic Instance Creation

Consider the following variable declaration:

Map<String, List<String>> myMap = new HashMap<String, List<String>>();

In Java SE 7, you can substitute the parameterized type of the constructor with an empty set of type parameters (<>):

Map<String, List<String>> myMap = new HashMap<>();

Note that to take advantage of automatic type inference during generic class instantiation, you must specify the diamond. In the following example, the compiler generates an unchecked conversion warning because the HashMap() constructor refers to the HashMap raw type, not the Map<String, List<String>> type:

Map<String, List<String>> myMap = new HashMap(); // unchecked conversion warning

3、Binary Literals

In Java SE 7, the integral types (byte, short, int, and long) can also be expressed using the binary number system. To specify a binary literal, add the prefix 0b or 0B to the number. The following examples show binary literals:

// An 8-bit 'byte' value:byte aByte = (byte)0b00100001;// A 16-bit 'short' value:short aShort = (short)0b1010000101000101;// Some 32-bit 'int' values:int anInt1 = 0b10100001010001011010000101000101;int anInt2 = 0b101;int anInt3 = 0B101; // The B can be upper or lower case.// A 64-bit 'long' value. Note the "L" suffix:long aLong = 0b1010000101000101101000010100010110100001010001011010000101000101L;

Binary literals can make relationships among data more apparent than they would be in hexadecimal or octal. For example, each successive number in the following array is rotated by one bit:

public static final int[] phases = {  0b00110001,  0b01100010,  0b11000100,  0b10001001,  0b00010011,  0b00100110,  0b01001100,  0b10011000}

In hexadecimal, the relationship among the numbers is not readily apparent:

public static final int[] phases = {    0x31, 0x62, 0xC4, 0x89, 0x13, 0x26, 0x4C, 0x98}

You can use binary integral constants in code that you can verify against a specifications document, such as a simulator for a hypothetical 8-bit microprocessor:

public State decodeInstruction(int instruction, State state) {  if ((instruction & 0b11100000) == 0b00000000) {    final int register = instruction & 0b00001111;    switch (instruction & 0b11110000) {      case 0b00000000: return state.nop();      case 0b00010000: return state.copyAccumTo(register);      case 0b00100000: return state.addToAccum(register);      case 0b00110000: return state.subFromAccum(register);      case 0b01000000: return state.multiplyAccumBy(register);      case 0b01010000: return state.divideAccumBy(register);      case 0b01100000: return state.setAccumFrom(register);      case 0b01110000: return state.returnFromCall();      default: throw new IllegalArgumentException();    }  } else {    final int address = instruction & 0b00011111;    switch (instruction & 0b11100000) {      case 0b00100000: return state.jumpTo(address);      case 0b01000000: return state.jumpIfAccumZeroTo(address);      case 0b01000000: return state.jumpIfAccumNonzeroTo(address);      case 0b01100000: return state.setAccumFromMemory(address);      case 0b10100000: return state.writeAccumToMemory(address);      case 0b11000000: return state.callTo(address);      default: throw new IllegalArgumentException();    }  }}

You can use binary literals to make a bitmap more readable:

public static final short[] HAPPY_FACE = {   (short)0b0000011111100000;   (short)0b0000100000010000;   (short)0b0001000000001000;   (short)0b0010000000000100;   (short)0b0100000000000010;   (short)0b1000011001100001;   (short)0b1000011001100001;   (short)0b1000000000000001;   (short)0b1000000000000001;   (short)0b1001000000001001;   (short)0b1000100000010001;   (short)0b0100011111100010;   (short)0b0010000000000100;   (short)0b0001000000001000;   (short)0b0000100000010000;   (short)0b0000011111100000;}

4、Strings in switch Statements

In the JDK 7 release, you can use a String object in the expression of a switch statement:

public String getTypeOfDayWithSwitchStatement(String dayOfWeekArg) {     String typeOfDay;     switch (dayOfWeekArg) {         case "Monday":             typeOfDay = "Start of work week";             break;         case "Tuesday":         case "Wednesday":         case "Thursday":             typeOfDay = "Midweek";             break;         case "Friday":             typeOfDay = "End of work week";             break;         case "Saturday":         case "Sunday":             typeOfDay = "Weekend";             break;         default:             throw new IllegalArgumentException("Invalid day of the week: " + dayOfWeekArg);     }     return typeOfDay;}

5、Underscores in Numeric Literals

In Java SE 7 and later, any number of underscore characters (_) can appear anywhere between digits in a numerical literal. This feature enables you, for example, to separate groups of digits in numeric literals, which can improve the readability of your code.
For instance, if your code contains numbers with many digits, you can use an underscore character to separate digits in groups of three, similar to how you would use a punctuation mark like a comma, or a space, as a separator.
The following example shows other ways you can use the underscore in numeric literals:

long creditCardNumber = 1234_5678_9012_3456L;long socialSecurityNumber = 999_99_9999L;float pi = 3.14_15F;long hexBytes = 0xFF_EC_DE_5E;long hexWords = 0xCAFE_BABE;long maxLong = 0x7fff_ffff_ffff_ffffL;byte nybbles = 0b0010_0101;long bytes = 0b11010010_01101001_10010100_10010010;

You can place underscores only between digits; you cannot place underscores in the following places:
    At the beginning or end of a number
    Adjacent to a decimal point in a floating point literal
    Prior to an F or L suffix
    In positions where a string of digits is expected
The following examples demonstrate valid and invalid underscore placements (which are highlighted) in numeric literals:

float pi1 = 3_.1415F;      // Invalid; cannot put underscores adjacent to a decimal pointfloat pi2 = 3._1415F;      // Invalid; cannot put underscores adjacent to a decimal pointlong socialSecurityNumber1  = 999_99_9999_L;         // Invalid; cannot put underscores prior to an L suffixint x1 = _52;              // This is an identifier, not a numeric literalint x2 = 5_2;              // OK (decimal literal)int x3 = 52_;              // Invalid; cannot put underscores at the end of a literalint x4 = 5_______2;        // OK (decimal literal)int x5 = 0_x52;            // Invalid; cannot put underscores in the 0x radix prefixint x6 = 0x_52;            // Invalid; cannot put underscores at the beginning of a numberint x7 = 0x5_2;            // OK (hexadecimal literal)int x8 = 0x52_;            // Invalid; cannot put underscores at the end of a numberint x9 = 0_52;             // OK (octal literal)int x10 = 05_2;            // OK (octal literal)int x11 = 052_;            // Invalid; cannot put underscores at the end of a number