O que há de novo no Java 7

    Bem no meu primeiro post, vamos falar sobre as novidades trazidas pelo Java 7. Muitos desenvolvedores, inclusive eu, ainda desenvolvem usando o Java 5 ou 6 e se perguntaram o que o Java 7 vem trazendo de novidade para a linguagem. Algumas novidades são bem interessantes, como o uso de Strings em uma instrução switch, a nova API para manipular arquivos, gerenciamento de recursos automático dentro de um try/catch, dentre outras. Resumidamente, vamos falar sobre algumas:

public void processaProduto(Produto produto) {
        String status = produto.getStatus();

        if (status.equalsIgnoreCase(NOVO)) {
              // faz alguma coisa com o produto novo
        } else if (status.equalsIgnoreCase(SEMINOVO)) {
              // faz alguma coisa com o produto seminovo
        } else if (status.equalsIgnoreCase(USADO)) {
              // faz alguma coisa com o produto usado
        }
}

     Não vou entrar no mérito de questionar se essa seria melhor forma de fazer. O ponto aqui é que essa era forma de testarmos várias condições antes. Se tivermos muitas condições, o trabalho será enorme. No Java 7 podemos trabalhar com o switch melhorado que recebe uma String como argumento:

 public void processaProduto(Produto produto) {
            String status = produto.getStatus();

            switch (status) {
                case NOVO:
                    // faz alguma coisa com o produto novo
                    break;
                case SEMINOVO:
                    // faz alguma coisa com o produto seminovo
                    break;
                case USADO:
                    // faz alguma coisa com o produto usado
                    break;
                default:
                    break;
             }
   }

  Nesse caso,o status é sempre comparado com o case usando status.equals(case)

Diamond Operator

    Muitas vezes nos deparamos com o compilador reclamando de tipos quando trabalhamos com Generics. Por exemplo, se quisermos trabalhar com um mapa onde a chave é uma String e o valor uma lista de Produto. Teríamos algo assim:

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

  

    Essa declaração é um pouco confusa pra quem não está habituado com a sintaxe. Além disso, ela é um pouco redundante. Precisamos colocar os tipos nos dois lados da atribuição. A partir do Java 7 podemos omitir os tipos da direita. Algo assim:

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

  O compilador deduz pelos tipos da esquerda quais são os tipos da direita.

Gerenciamento automático de Recursos 

      Geralmente quando trabalhamos com conexões de banco, arquivos, etc devemos encerrar o recurso após o uso. Para isso usamos um bloco try/catch/finally para fechar cada recurso.

  try{
          Recurso file = new Recurso("arquivo");
          // faz alguma coisa com o recurso
      }catch(IOException e){
          // loga a exceção
      }finally{
          try {
              file.close();
          } catch (IOException e) {
              // loga a exceção
          }
      }

      O Java introduziu uma nova feature para gerenciar os recursos de forma automática. Funciona de uma maneira bem simples, basta declarar os recursos no try. A sintaxe é a seguinte:

 
 try(Recurso file = new Recurso("arquivo")){
           // faz alguma coisa com o recurso
      }catch(IOException e){
          // loga a exceção
      }

      Múltiplos recursos podem ser declarados também. Basta separá-los por ponto-e-vírgula.

      try(Recurso file1 = new Recurso("arquivo1"); Recurso file2 = new Recurso("arquivo2") ){
           // faz alguma coisa com o recurso
      }catch(IOException e){
          // loga a exceção
      }

      Dessa forma não precisamos fechar o recurso já que eles passam a ser fechados automaticamente assim que o bloco try for executado.

     Vale notar que não é todo recurso que pode ser gerenciado automaticamente. Apenas os recursos que implementam a interface java.lang.AutoCloseable podem ser gerenciados automaticamente.

Literais numéricos com "_"

     Quem já não se pegou contando os zeros de um número muito grande, digamos, 10000000000. É difícil identificar sem contar os zeros da direita pra esquerda. Uma melhoria bem útil é podermos separar os grupos de zeros com "_". Podemos declarar os números como abaixo:

      int mil = 1_000;

ou

      int mil = 1000

. .

      int umbilhao = 1_000_000_000

ou

      int umbilhao = 1000000000

Melhora no tratamento de exceções

        O Java 7 introduziu a funcionalidade chamada de multi-catch para lidarmos com código que trata múltiplas exceções. Suponha um código que trata múltiplas exceções. Faríamos da seguinte forma:

         try {
             metodoquelancaexcecoes();
         } catch (Excecao1 e) {
                // trata a Excecao1
         } catch (Excecao2 e) {
                // trata a Excecao2
         } catch (Excecao2 e) {
                // trata a Excecao3
         }

Agora a versão melhorada:

         try {
             metodoquelancaexcecoes();
         } catch (Excecao1 | Excecao2 | Excecao2 e) {
                // trata as três exceções
         }

Nada impede de termos uma mistura das duas formas:

         try {
             metodoquelancaexcecoes();
         } catch (Excecao1 e) {
                // trata a Excecao1
         } catch (Excecao2 | Excecao2 e) {
                // trata as duas exceções restantes
         }

    Bem essas foram algumas das melhorias na linguagem. Existem outras é claro. Outra bem legal é a nova API para trabalhar com arquivos. Talvez em um post futuro eu fale sobre isso. Para ver todas as melhorias, o link é esse http://www.oracle.com/technetwork/java/javase/jdk7-relnotes-418459.html.