Whats new in Java7?

I know it kind of late to write this post considering Java 7 which was a major update and made available to developers on July 28, 2011.  We have seen a lot of updates and patches for it since then. In fact java 8 is due 18 march 2014. However I though it would be a good idea to list down some of the major features introduced in Java 7.

1. Strings in switch statement
   
   From java 7 you can use String in the Switch statements. The switch statement compares the String object in its expression with the expressions associated with each case label as if it were using the String.equals method; consequently, the comparison of String objects in switch statements is case sensitive. The Java compiler generates generally more efficient bytecode from switch statements that use String objects than from chained if-then-else statements.(More on Switch statement)
   
   Example
   
   

       public static void main(String args[]){
   
           System.out.println("Enter your country");
           Scanner scanner = new Scanner(System.in);
           String input = scanner.nextLine();
   
           switch(input){
   
               case "USA" :
                   System.out.println("You are from USA");
                   break;
               case "India" :
                   System.out.println("You are from India");
                   break;
               default :
                   System.out.println("You are from " + input);
           }
       }
   

   
   
   
2. The try-with-resources StatementThe try-with-resources statement is a try statement that declares one or more resources. A resource is as an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implement java.io.Closeable, can be used as a resource.
   
   Prior to java 7 when this feature was not available programmers use to close the resources in the finally statement . For Example lets say you need to write a function that takes file path as an argument and return first line from that file. Prior to Java 7 you would do
   
   

   static String readFirstLineFromFileWithFinallyBlock(String path) throws IOException {
     BufferedReader br = new BufferedReader(new FileReader(path));
     try {
       return br.readLine();
     } finally {
       if (br != null) br.close();
     }
   }
   

   
   
   but now you can do
   
   

   static String readFirstLineFromFile(String path) throws IOException {
     try (BufferedReader br = new BufferedReader(new FileReader(path))) {
       return br.readLine();
     }
   }
   

   
   Simple and elegant!
   
   Note: A try-with-resources statement can have catch and finally blocks just like an ordinary try statement. In a try-with-resources statement, any catch or finally block is run after the resources declared have been closed.
   
   Note :  The close methods of resources are called in the opposite order of their creation.
   
   Note : In a simple try catch statement if try block (or catch block) throws an Exception and finally block throws an Exception then the Exception from try block is ignored and the one from finally block is thrown.
   
   Note : In Java 7  try with resource statements there is a twist. Now even try-with-resource statement can throw exception. Again if exception is thrown by finally statement then that is the one that will suppress all other exception. If that is not the case - Exception is thrown from try-with-resource statement (during close) and try block then the one from try block get precedence. However of exception is thrown at initialization (in try-with-res block) try block will not even execute.
   
   
3. Catching Multiple Exception Types
   
   In Java SE 7 and later, a single catch block can handle more than one type of exception. This feature can reduce code duplication and lessen the temptation to catch an overly broad exception.
   
   Consider the following example, which contains duplicate code in each of the catch blocks:
   
   

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

   
   
   The following example, which is valid in Java SE 7 and later, eliminates the duplicated code:
   
   

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

   
   
   The catch clause specifies the types of exceptions that the block can handle, and each exception type is separated with a vertical bar (|).
   
   Note: If a catch block handles more than one exception type, then the catch parameter is implicitly final. In this example, the catch parameter ex is final and therefore you cannot assign any values to it within the catch block.
   
   Note : In a multi-catch block, you cannot combine catch handlers for two exceptions that share a base- and derived-class relationship. You can only combine catch handlers for exceptions that do not share the parent-child relationship between them.
   
   Bytecode generated by compiling a catch block that handles multiple exception types will be smaller (and thus superior) than compiling many catch blocks that handle only one exception type each. A catch block that handles multiple exception types creates no duplication in the bytecode generated by the compiler; the bytecode has no replication of exception handlers.
   
   More details on this part.
4. JDBC
   
   JDBC 4 that comes with Java 7 has following features
   
   
   • You no longer have to explicitly load the driver class using Class.ForName(driver). From JDBC 4 driver class is automatically loaded from the class path.
   • Another addition is the ability to use a try-with-resources statement to automatically close resources of type Connection, ResultSet, and Statement.
   • There is also introduction of the RowSetFactory interface and the RowSetProvider class, which enable you to create all types of row sets supported by your JDBC driver.
5. Interned Strings are allocated in heap area rather that permgen area
   
   In JDK 7, interned strings are no longer allocated in the permanent generation of the Java heap, but are instead allocated in the main part of the Java heap (known as the young and old generations), along with the other objects created by the application. This change will result in more data residing in the main Java heap, and less data in the permanent generation, and thus may require heap sizes to be adjusted. Most applications will see only relatively small differences in heap usage due to this change, but larger applications that load many classes or make heavy use of the String.intern() method will see more significant differences.
6. Garbage-First Collector(G1)
   
   The Garbage-First (G1) garbage collector is fully supported in Oracle JDK 7 update 4 and later releases. The G1 collector is a server-style garbage collector, targeted for multi-processor machines with large memories. It meets garbage collection (GC) pause time goals with high probability, while achieving high throughput. Whole-heap operations, such as global marking, are performed concurrently with the application threads. This prevents interruptions proportional to heap or live-data size.
7. Java File I/O (NIO.2)
   
   In Java 7 new set of I/O APIs were introduced called NIO.2. You can read that in the detailed post - Java File I/O (NIO.2)

Important Links

• How is String in switch statement more efficient then corresponding if-else statement? 
•  How is driver class located in JDBC4
•  Getting Started with the G1 Garbage Collector
• Suppressed exceptions in java 7 (OSFG) 
• Java File I/O (NIO.2) (OSFG)
• Understanding Localization in Java(OSFG)