Ayúdame a ponerme al día con lo que me he perdido desde Java 1.4.2 [cerrado]

Estoy a punto de comenzar mi primer puesto profesional como desarrollador de software, y probablemente escribiré mucho código Java. No sé mucho acerca de lo que escribiré específicamente, y además, tengo intereses bastante amplios cuando se trata de código de todos modos.

Por razones que no vale la pena discutir, mi última pasantía me hizo codificar solo para los SDK de Java 1.3 y 1.4. Además, mi educación universitaria se ha centrado principalmente en algoritmos, estructuras de datos y otras teorías, no en características del lenguaje o bibliotecas.

Entonces, con lo anterior en mente, ¿qué características, clases, etc. en la versión actual de Java (de todos modos, ¿en qué número estamos ahora?) Valdría la pena leer y por qué? ¿Qué me he perdido desde 1.4.2 que te hace la vida más fácil como programador?

Ejemplos e historias de cómo descubrió un paquete en particular o algo así y lo puso en uso también sería genial.

Los cambios que considero más importantes son:

• Genéricos (por ejemplo, colecciones escritas, como Set)

• Mejorado para loop (para (String s: set) {...})

• Autoboxing / unboxing (convierte automáticamente entre tipos como Integer a int y viceversa)

• Enums Typesafe (enum ahora es una palabra clave, los tipos se pueden crear a partir de enumeraciones)

• Varargs (para la función printf (), permite un número variable de argumentos)

• Importación estática (ahora puede importar métodos estáticos de una clase, como java.lang.Math)

• Anotaciones

• java.util.concurrent (demuestra la concurrencia de java)

Lea también ¿A qué Java apunta? , para comprender mejor cada una de las tres versiones.

El cambio más importante en su vida diaria de programación es la introducción de genéricos que probablemente se utilizarán en cada módulo nuevo que se le pedirá que escriba, y es una sintaxis nueva y confusa.

El genérico es el mecanismo que permite, por ejemplo, que Lista contenga cadenas en lugar de objetos desnudos, donde el compilador exige que un elemento que se incluya en la lista sea una Cadena, y sabe que cuando obtiene un elemento de una lista es una Cadena .

Esto mejora los programas ya que evita el tiempo de ejecución explícito al tipo de destino (que es una fuente frecuente de errores si se equivoca) y el IDE puede ayudarlo a hacer todo el trabajo sucio ya que sabe mucho más sobre su código que lo hizo cuando era solo una lista de objetos.

Joshua Bloch ha escrito una buena introducción a los genéricos, que está disponible como el capítulo de muestra en http://java.sun.com/docs/books/effective/

Autoboxing es una buena característica introducida con Java 5. Al igual que en C #, el compilador ahora realiza una conversión automática entre los tipos primitivos (básicos) y sus correspondientes clases de contenedor de objetos (int a Integer, etc.) y viceversa. Eso hace que trabajar con Java Collections sea mucho menos doloroso.

Creo que también cada uno de los bucles era nuevo en Java 5. Facilita la iteración sobre matrices (y colecciones), ya que elimina gran parte del desorden habitual que involucra la configuración y administración de una variable de índice o iteradores. En el ejemplo:

void myMethod(Collection<myObjectType> c) {
    for (myObjectType o : c)
        o.foo();
}

Enums , para reemplazar las estadísticas y constantes finales y ayudarlo a eliminar referencias a cadenas y números mágicos. Un ejemplo tomado de las buenas personas en sun / orracle :

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7),
    PLUTO   (1.27e+22,  1.137e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass()   { return mass; }
    public double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

y

public static void main(String[] args) {
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }

java.util.concurrent se introdujo en 1.5. El mejor recurso para aprenderlo es (probablemente) el libro Java Concurrency in Practice . La concurrencia en mi humilde opinión es la ventaja competitiva más importante de Java en comparación con cualquier otra cosa, por lo que definitivamente vale la pena conocerla bien.

Bueno, StringBuilderme ayudó a acelerar mi programa. Es equivalente a la StringBufferseguridad sin rosca.

Ayudaré clasificando la respuesta útil de @ykombinator. Su lista es una lista de los elementos que usará diariamente mientras realiza el desarrollo "general" de Java.

Bajo impacto y baja dificultad:

• Mejorado para loop (para (String s: set) {...})
• Autoboxing / unboxing (convierte automáticamente entre tipos como Integer a int y viceversa)
• Varargs (para la función printf (), permite un número variable de argumentos)
• Importación estática (ahora puede importar métodos estáticos de una clase, como java.lang.Math)

Alto impacto y dificultad media:

• Enums Typesafe (enum ahora es una palabra clave, los tipos se pueden crear a partir de enumeraciones)

Alto impacto y alta dificultad:

• Anotaciones
• Genéricos

Bajo impacto y alta dificultad (solo se usará a menos que realice un enhebrado avanzado)

• java.util.concurrent (demuestra la concurrencia de java)

Por lo tanto, te sugiero que leas los documentos / ayuda sobre piezas difíciles y de bajo impacto: son fáciles de aprender. Pase mucho tiempo en anotaciones y genéricos: las anotaciones son muy útiles y los genéricos pueden ser bastante complicados.

Solo mire el nuevo contenido de concurrencia si necesita hacer subprocesos.

Como no puedo comentar porque tengo menos de 50 años, dejaré una respuesta. Ya se ha mencionado pero lo repetiré de nuevo: ¡Anotaciones! Este tipo de metadatos se convirtió en lo más importante en mis años de experiencia en Java. Se usa bien como lo hacen algunos frameworks, lo que hace que el código sea mucho más conciso y limpio. Por ejemplo, las anotaciones pueden:

• Convierta un objeto en una entidad @Entity
• Convierta un método en un servicio REST @GET
• Explique que un método nunca devolverá nulo @nonnull
• Establecer un objeto en un campo para inyección de dependencia @inject

Y, por supuesto, puede crear sus propias anotaciones y saber si un método, clase o campo se anota mediante la reflexión.

Aprender con el ejemplo me funciona

Aquí hay un ejemplo rápido de idiomática Java 6

public class Main {
  public static void main(String[] args) {
    // Shows a list forced to be Strings only
    // The Arrays helper uses generics to identify the return type
    // and takes varargs (...) to allow arbitary number of arguments
    List<String> genericisedList = Arrays.asList("A","B","C");

    // Demonstrates a for:each loop (read as for each item in genericisedList)
    for (String item: genericisedList) {
      System.out.printf("Using print formatting: %s%n",item);
    }

    // Note that the object is initialised directly with a primitive (autoboxing)
    Integer autoboxedInteger = 1;
    System.out.println(autoboxedInteger);

  }
}

No te molestes con Java5, está en desuso con respecto a Java6.

Siguiente paso, anotaciones. Estos solo definen aspectos de su código que permiten a los lectores de anotaciones completar la configuración estándar por usted. Considere un servicio web simple que utiliza la especificación JAX-RS (comprende los URI RESTful). No desea molestarse en hacer todo el desagradable WSDL y en jugar con Axis2, etc., desea un resultado rápido. Bien, haz esto:

// Response to URIs that start with /Service (after the application context name)
@Path("/Service")
public class WebService {

  // Respond to GET requests within the /Service selection
  @GET
  // Specify a path matcher that takes anything and assigns it to rawPathParams
  @Path("/{rawPathParams:.*}")
  public Response service(@Context HttpServletRequest request, @PathParam("rawPathParams") String rawPathParams) {
    // Do some stuff with the raw path parameters 

    // Return a 200_OK
    return Response.status(200).build();
  }
}

Explosión. Con un poco de magia de configuración en tu web.xml, estás listo. Si está compilando con Maven y tiene configurado el complemento Jetty, su proyecto tendrá su propio pequeño servidor web listo para usar (no tiene que jugar con JBoss o Tomcat para usted), y el código anterior responderá a los URI del formar:

GET http://localhost:8080/contextName/Service/the/raw/path/params

Trabajo hecho.

¡Guau, eso fue una explosión del pasado! No he usado Java durante 4 años, ¡y nada ha cambiado en absoluto en ese tiempo!

Hay una lista de características por versión , pero aquí está el bit importante (plagiado, por supuesto) ...

J2SE 5.0 (30 de septiembre de 2004)

• Genéricos: proporciona seguridad de tipo en tiempo de compilación (estática) para colecciones y elimina la necesidad de la mayoría de los tipos de conversión (conversión de tipo).
• Metadatos: también llamados anotaciones; permite que las construcciones de lenguaje, tales como clases y métodos, se etiqueten con datos adicionales, que luego pueden ser procesados ​​por utilidades conscientes de metadatos.
• Autoboxing / unboxing: conversiones automáticas entre tipos primitivos (como int) y clases de envoltorio primitivo (como Integer).
• Enumeraciones: la palabra clave enum crea una lista ordenada de valores de tipo seguro (como Day.MONDAY, Day.TUESDAY, etc.). Anteriormente, esto solo podía lograrse mediante enteros constantes no seguros de tipo o clases construidas manualmente (patrón de enumeración seguro de tipo).
• Swing: nuevo aspecto y aspecto skinnable, llamado sintetizador.
• Varargs: El último parámetro de un método ahora se puede declarar usando un nombre de tipo seguido de tres puntos (por ejemplo, void drawtext (String ... lines)). En el código de llamada se puede usar cualquier número de parámetros de ese tipo y luego se colocan en una matriz para pasar al método, o alternativamente el código de llamada puede pasar una matriz de ese tipo.
• Mejorado para cada bucle: la sintaxis del bucle for se extiende con una sintaxis especial para iterar sobre cada miembro de una matriz o cualquier Iterable, como las clases de Colección estándar, utilizando una construcción de la forma:

Java SE 6 (11 de diciembre de 2006)

• Soporte para versiones anteriores de Win9x caído. Extraoficialmente, Java 6 Update 7 es la última versión de Java que funciona en estas versiones de Windows. Se cree que esto se debe a los principales cambios en la Actualización 10.
• Soporte de lenguaje de scripting: API genérica para una estrecha integración con lenguajes de scripting e integración integrada de Mozilla JavaScript Rhino
• Mejoras dramáticas de rendimiento para la plataforma central y Swing.
• Soporte mejorado del servicio web a través de JAX-WS
• Soporte JDBC 4.0.
• Java Compiler API una API que permite que un programa Java seleccione e invoque un compilador Java mediante programación.
• Actualización de JAXB a la versión 2.0: incluida la integración de un analizador StAX.
• Soporte para anotaciones conectables
• Muchas mejoras de la GUI, como la integración de SwingWorker en la API, la clasificación y el filtrado de tablas, y el verdadero búfer doble de Swing (eliminando el efecto de área gris).
• Las mejoras de JVM incluyen: optimizaciones de sincronización y rendimiento del compilador, nuevos algoritmos y actualizaciones a los algoritmos de recolección de basura existentes y rendimiento de inicio de aplicaciones.

Eso es todo. Java SE 7.0 parece más interesante pero aún no se ha lanzado.

Teniendo en cuenta cuántas nuevas funciones de lenguaje y API se han agregado a C # en los últimos 4 años, estoy bastante asombrado. ¿Qué ha estado sucediendo en Sun / Oracle?