sábado, 24 de diciembre de 2011

Novedades en Java 7

votar
   Acabo de leer un panfleto escrito por Madhusudhan Konda y publicado por O´Reilly sobre algunas de las novedades en Java 7 y he pensado que estaría bien hacer un resumen para aquellos que no lo conozcáis. Todos los ejemplos que aparecen a continuación son parte del escrito de Konda. Obviamente, no se tratan aquí todas las novedades que hay en Java 7, pero sí algunas de las que serán más útiles a los desarrolladores.

   Konda empieza tratando de las mejoras del lenguaje que se solicitaron a través del Project Coin. Una de las mejoras que se reclamaban en este proyecto era sobre el uso de Genéricos. Un ejemplo del uso de Genéricos hasta Java 7 sería como sigue:
   Map<String, List<Trade>>  trades = new TreeMap<String, List<Trade>>( );
   Esto resulta un poco lioso, porque hay que declarar los tipos a ambos lados. Observad ahora como quedaría usando Java 7:
   Map<String, List<Trade>> trades = new TreeMap<>( );
   Mucho mejor, ¿verdad?. Ya no hay que declarar los tipos a la derecha, porque el compilador infiere de qué tipos se trata viendo los que hay a la izquierda. Incluso sería legal omitir el operador de Genéricos (diamond operator), así:
   trades = new TreeMap( );
pero el compilador lanzaría advertencias de seguridad.

   Otra de las peticiones que se hicieron en el proyecto Coin fue el poder usar strings en sentencias Switch. Hasta ahora, las sentencias Switch usaban o bien tipos primitivos o bien tipos enumerados. Con Java 7 se pueden usar también strings, que antes tendrían que ir en una serie de if-else como estos:
   private void processTrade(Trade t){
         String status = t.getStatus( );
            if(status.equalsIgnoreCase(NEW)){
              newTrade(t);
             }else if(status.equalsIgnoreCase(EXECUTE)){
              executeTrade(t);
             }else if(status.equalsIgnoreCase(PENDING)){
              pendingTrade(t);
             }
           }
   Comparadlo ahora en como queda al poder usar una sentencia Switch:
      public void processTrade(Trade t){
         String status = t.getStatus( );
         switch (status){
            case NEW : newTrade(t);
                  break;
             case EXECUTE : executeTrade(t);
                  break;
             case PENDING : pendingTrade(t);
                  break; 
             default : break;
           }
         }

   Konda habla a continuación del manejo automático de recursos tales como Files, Input/OutputStreams, etc., que los desarrolladores tienen que cerrar manualmente, pero que ahora Java 7 puede realizar de forma automática. Hasta ahora el proceso era el siguiente:
   public void oldTry( ){
        try{
               fos = new FileOutputStream("movies.txt");
              dos = new DataOutputStream(fos);
              dos.writeUTF("Java 7 Block Buster");
       }catch (IOException e){
               e.printStackTrace( );
       }finally{
            try{
                   fos.close( );
                  dos.close( );
            }catch (IOException e){
                     //maneja la excepción
           }
        }
     }
   Y así es como se haría con Java 7:
   public void newTry( ){
            try(FileOutputStream fos = new FileOutputStream("movies.txt");
                 DataOutputStream dos = new DataOuputStream(fos))
                {
                    dos.writeUTF("Java 7 Block Buster");
                 }catch (IOException e){
                        //maneja la excepción
                }
       }
   Eso sí, para que esto funcione, los recursos que queremos que se cierren automáticamente tienen que implementar la interfaz java.lang.AutoCloseable. 

   Otra de las novedades introducidas en Java 7 es el uso de la barra baja para separar números literales y que sea más fácil leerlos. Por ejemplo, si hasta ahora un millón se escribía así:
   1000000
ahora lo escribiremos de esta forma:
   1_000_000
   También se introducen los literales binarios, con lo que ya no hay que convertirlos a hexadecimales y nos ahorramos un trabajo.

   Se ha mejorado también el manejo de excepciones múltiples, que ahora se pueden atrapar usando un único bloque. Hasta ahora, si tenías un método con, por ejemplo, tres excepciones, tenías que atraparlas de forma individual. Con Java 7 se puede hacer lo siguiente:
   public void newMultiCatch( ){
      try{
         methodThatThrowsThreeExceptions( );
      }catch(ExceptionOne | ExceptionTwo | ExceptionThree e){
             //maneja las excepciones
      }
    }
   Sin embargo, si tienes excepciones que pertenecen a distintos tipos que deben manejarse de distinta manera, se puede hacer lo siguiente: 
   public void newMultiMultiCatch( ){
       try{
          methodThatThrowsThreeExceptions( );
       }catch (ExceptionOne e){
              //maneja ExceptionOne
       }catch (ExceptionTwo | ExceptionThree e){
             //maneja ExceptionTwo y ExceptionThree
       }
   }

   Java 7 tiene también una nueva API, NIO 2.0, que proporciona mejoras a la hora de trabajar con Java IO. El nuevo paquete java.nio.file viene con nuevas clases e interfaces como Path, Paths, FileSystem, FileSystems y otras. Path, por ejemplo, es el equivalente mejorado de java.io.File. Lo mejor para comprobar como funciona NIO 2.0 es ir a los docs de Oracle y ver allí cómo funcionan estas nuevas clases y métodos.

   Otras de las mejoras está relacionada con la multitarea, para lo que se han creado las nuevas clases ForkJoinPool y ForkJoinTask.

   Por último, hay que mencionar la creación de otro nuevo paquete, java.lang.invoke, que permite que  la JVM soporte mucho mejor la utilización de lenguajes dinámicos tales como Phyton, Ruby y Clojure. Algunas de las nuevas clases que incorpora este paquete son MethodHandle y CallSite.

   Os recuerdo que este trabajo y los ejemplos aquí expuestos son obra de Madhusudhan Konda, que lo ha publicado en O´Reilly. Si queréis leerlo completo, yo me he descargado una versión gratuita a través de Amazon, y supongo que O´Reilly también ofrecerá esta posibilidad. ; )
   





   
   

8 comentarios:

  1. esta buenicimo para tomarlo en cuenta

    ResponderEliminar
  2. Buen aporte, te deja con las ganas de seguir investigando al respecto. Felicitaciones

    ResponderEliminar
  3. ¡Gracias XTO! Esa es mi meta, animar a la gente a aprender más.:-)

    ResponderEliminar
  4. Gracias por la información esta muy entendible, habia visto codigos como en el ejemplo:
    Map> trades = new TreeMap<>( );
    pero no lo entendia porque funcionaba, ahora ya se que es una caracteristica de JAVA 7 °o°

    ResponderEliminar
  5. Hola Sonia, mi nombre es luis quisiera saber porque un programa que tengo en java no me funciona. Tiene una sentencia asi: public List pero el compilador java builder 7 no me reconoce los caracteres < ni > ,no se que significan y no puedo ejecutar mi programa. Me podrias ayudar?

    ResponderEliminar
    Respuestas
    1. Hola Luis.
      Necesitaría algún dato más para poder ayudarte. El compilador a que te refieres, ¿es el Java Builder de Eclipse o el WYSIWYG Java GUI Builder, o cuál?
      En el primer caso, algo está mal escrito en el código para que no te reconozca los caracteres. En el segundo, no lo he usado nunca, así que no sabría decirte.
      De cualquier manera, necesitaría saber exactamente qué mensaje de error te da, y leer el código para encontrar el fallo.
      En cuanto a que tú no sabes lo que significan los caracteres, ¿no has escrito tú el programa? Lo que va entre < y > indica el tipo de objetos que conforman la lista. Por ejemplo List sería una lista formada por Strings.
      Un saludo.

      Eliminar
    2. Acabo de ver que he escrito mal el final del comentario. Corrijo:
      List < String > sería una lista formada por String.
      ¡Es difícil desde el móvil! ;-)

      Eliminar