Ajude-me a recuperar o atraso que perdi desde o Java 1.4.2 [fechado]

Estou prestes a começar minha primeira posição profissional como desenvolvedor de software e provavelmente escreverei muito código Java. Não sei muito sobre o que especificamente escreverei e, além disso, tenho interesses bastante amplos no que diz respeito ao código.

Por razões que não valem a pena discutir, meu último estágio me fez codificar apenas para os SDKs Java 1.3 e 1.4. Além disso, minha formação universitária se concentrou principalmente em algoritmos, estruturas de dados e outras teorias, não em recursos ou bibliotecas de idiomas.

Portanto, com o exposto acima, quais recursos, classes, etc., na versão atual do Java (em que número estamos agora, afinal?) Valeria meu tempo lendo e por quê? O que eu perdi desde a versão 1.4.2 que facilita sua vida como programador?

Exemplos e histórias de como você descobriu um pacote específico ou algo parecido e o colocou em uso também seriam ótimos.

As mudanças que considero mais importantes são:

• Genéricos (por exemplo, coleções digitadas, como Set)

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

• Caixa automática / unboxing (converte automaticamente entre tipos como Inteiro para int e vice-versa)

• Enumerações Typesafe (enum agora é uma palavra-chave, tipos podem ser criados a partir de enumerações)

• Varargs (para a função printf (), permite número variável de argumentos)

• Importação estática (agora pode importar métodos estáticos de uma classe, como java.lang.Math)

• Anotações

• java.util.concurrent (demonstra a simultaneidade de java)

Leia também O que Java você está buscando? , para entender melhor cada uma das três versões.

A mudança mais importante na sua vida cotidiana na programação é a introdução de genéricos que provavelmente serão usados ​​em todos os novos módulos que você precisará escrever, e é uma nova sintaxe confusa.

Genéricos é o mecanismo que permite, por exemplo, um List a conter seqüências de caracteres em vez de objetos nus, onde o compilador impõe que um item a ser colocado na lista seja uma String e sabe que quando você extrai um item de uma lista, ele é uma String .

Isso cria melhores programas à medida que você evita a conversão explícita do tempo de execução para o tipo de destino (que é uma fonte frequente de erros, se você errar) e o IDE pode ajudá-lo a fazer todo o trabalho sujo, pois sabe muito mais sobre seu código do que aconteceu quando era apenas uma lista de objetos.

Joshua Bloch escreveu uma boa introdução a Genéricos, disponível como exemplo de capítulo em http://java.sun.com/docs/books/effective/

A autoboxing é um recurso interessante introduzido no Java 5. Assim como no C #, o compilador agora faz uma conversão automática entre os tipos primitivos (básicos) e suas classes correspondentes de wrapper de objetos (int para Integer etc.) e vice-versa. Isso torna o trabalho com Java Collections muito menos trabalhoso.

Para cada loop também era novo no Java 5, eu acho. Facilita a iteração de matrizes (e coleções), porque elimina grande parte da confusão usual que envolve a configuração e o gerenciamento de uma variável ou iteradores de índice. Por exemplo:

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

Enums , para substituir estática e constantes finais e ajudá-lo a remover referências a seqüências de caracteres e números mágicos. Um exemplo tirado das pessoas boas da sun / oracle :

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();
    }
}

e

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));
    }

O java.util.concurrent foi introduzido na 1.5. O melhor recurso para aprender é (provavelmente) o livro Concorrência Java na Prática . A simultaneidade IMHO é a vantagem competitiva mais importante do Java em comparação com qualquer outra coisa, portanto vale a pena conhecer bem.

Bem, StringBuilderme ajudou a acelerar meu programa. É equivalente à StringBuffersegurança sem rosca.

Ajudarei a categorizar a resposta útil de @ykombinator. Sua lista é uma lista dos elementos que você usará diariamente enquanto estiver desenvolvendo java "geral".

Baixo impacto e baixa dificuldade:

• Aprimorado para loop (para (String s: set) {...})
• Caixa automática / unboxing (converte automaticamente entre tipos como Inteiro para int e vice-versa)
• Varargs (para a função printf (), permite número variável de argumentos)
• Importação estática (agora pode importar métodos estáticos de uma classe, como java.lang.Math)

Alto impacto e dificuldade média:

• Enumerações Typesafe (enum agora é uma palavra-chave, tipos podem ser criados a partir de enumerações)

Alto impacto e alta dificuldade:

• Anotações
• Genéricos

Baixo impacto e alta dificuldade (será usado apenas a menos que você faça rosqueamento avançado)

• java.util.concurrent (demonstra a simultaneidade de java)

Sugiro, portanto, que você leia os documentos / ajuda sobre peças difíceis e de baixo impacto - elas são fáceis de entender. Gaste muito tempo em anotações e genéricos - as anotações são muito úteis e os genéricos podem ficar bastante complicados.

Observe apenas o novo conteúdo de simultaneidade se precisar fazer a segmentação.

Como não posso comentar porque tenho menos de 50 anos, vou deixar uma resposta. Já foi mencionado, mas vou repetir novamente: anotações! Esse tipo de metadado se tornou a coisa mais importante nos meus anos de experiência em Java. É bem usado, como algumas estruturas, torna o código muito mais conciso e limpo. Por exemplo, as anotações podem:

• Converter um objeto em uma entidade @Entity
• Converter um método em um serviço REST @GET
• Explique que um método nunca retornará null @nonnull
• Defina um objeto como um campo para injeção de dependência @inject

E, é claro, você pode criar suas próprias anotações e saber se um método, classe ou campo é anotado usando reflexão.

Aprender pelo exemplo funciona para mim

Aqui está um exemplo rápido do Java 6 idiomático

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);

  }
}

Não se preocupe com o Java5, ele foi descontinuado em relação ao Java6.

Próxima etapa, anotações. Eles apenas definem aspectos do seu código que permitem que os leitores de anotações preencham a configuração padrão para você. Considere um serviço da web simples que use a especificação JAX-RS (ele entende URIs RESTful). Você não quer se incomodar em fazer todo o WSDL desagradável e mexer com o Axis2 etc, deseja um resultado rápido. Certo, faça o seguinte:

// 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();
  }
}

Bang. Com um pouco de magia de configuração no seu web.xml, você está fora. Se você estiver construindo com o Maven e tiver o plug-in Jetty configurado, seu projeto terá seu próprio servidor da Web pronto para uso (sem mexer no JBoss ou Tomcat para você), e o código acima responderá aos URIs do Formato:

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

Tarefa concluída.

Uau, isso foi uma explosão do passado! Não uso Java há 4 anos - e nada mudou nesse período!

Há uma lista de recursos por versão , mas aqui está a parte importante (plagiada, é claro) ...

J2SE 5.0 (30 de setembro de 2004)

• Genéricos: fornece segurança de tipo em tempo de compilação (estática) para coleções e elimina a necessidade da maioria das previsões de tipo (conversão de tipo).
• Metadados: também chamados de anotações; permite que construções de linguagem, como classes e métodos, sejam marcadas com dados adicionais, que podem ser processados ​​por utilitários com reconhecimento de metadados.
• Caixa automática / unboxing: conversões automáticas entre tipos primitivos (como int) e classes de invólucro primitivo (como Inteiro).
• Enumerações: a palavra-chave enum cria uma lista de valores ordenada e com segurança de tipos (como Day.MONDAY, Day.TUESDAY etc.). Anteriormente, isso só podia ser alcançado por números inteiros constantes que não são tipicamente seguros ou por classes construídas manualmente (padrão de enumeração typesafe).
• Swing: Nova aparência skinnable, chamada synth.
• Varargs: O último parâmetro de um método agora pode ser declarado usando um nome de tipo seguido por três pontos (por exemplo, void drawtext (String ... lines)). No código de chamada, qualquer número de parâmetros desse tipo pode ser usado e, em seguida, eles são colocados em uma matriz a ser passada para o método ou, alternativamente, o código de chamada pode passar uma matriz desse tipo.
• Aprimorado para cada loop: a sintaxe do loop for é estendida com sintaxe especial para iterar sobre cada membro de uma matriz ou de qualquer Iterável, como as classes Collection padrão, usando uma construção do formulário:

Java SE 6 (11 de dezembro de 2006)

• Suporte para versões mais antigas do Win9x caiu. Extraordinariamente, o Java 6 Update 7 é a última versão do Java mostrada para funcionar nessas versões do Windows. Acredita-se que isso ocorra devido às principais alterações na atualização 10.
• Suporte à linguagem de script: API genérica para forte integração com linguagens de script e integração interna do Mozilla JavaScript Rhino
• Melhorias dramáticas no desempenho da plataforma principal e no Swing.
• Suporte aprimorado ao serviço da Web por meio do JAX-WS
• Suporte ao JDBC 4.0.
• API do Java Compiler, uma API que permite que um programa Java selecione e chame um Java Compiler programaticamente.
• Atualização do JAXB para a versão 2.0: Incluindo a integração de um analisador StAX.
• Suporte para anotações conectáveis
• Muitas melhorias na GUI, como a integração do SwingWorker na API, a classificação e filtragem de tabelas e o buffer duplo verdadeiro do Swing (eliminando o efeito da área cinza).
• As melhorias da JVM incluem: otimizações de desempenho de sincronização e compilador, novos algoritmos e atualizações dos algoritmos de coleta de lixo existentes e desempenho de inicialização do aplicativo.

É sobre isso. O Java SE 7.0 parece mais interessante, mas ainda não foi lançado.

Considerando quantos novos recursos de linguagem e APIs foram adicionados ao C # nos últimos 4 anos, estou bastante surpreso. O que está acontecendo na Sun / Oracle?