Java7 tdc2011

Globalcode – Open4education

JDK 7 – Modificações na Linguagem Eder Magalhães

@edermag www.yaw.com.br


Agenda

!  Expectativa na evolução da Linguagem Java !  Qual o papel do OpenJDK ? !  Especificação do Java 7 !  Mudanças na linguagem (Projeto Coin) !  New IO no Java 7 (NIO.2) !  Suporte a linguagens com tipagem dinâmica !  Fork/Join Framework; !   JDBC 4.1; !  Planejamento do Java 8;


Histórico

!  Última versão com mudanças na linguagem: !  Java 5 (Tiger) – 30/09/2004;

!   Java 6 (Mustang) foi disponibilizado em 11/12/2006;

!   Java 7 (Dolphin) começou em 08/2006 e foi disponibilizado em 28/07/2011;


Durante esses 5 anos

!  Grande expectativa por novas funcionalidades;

!  Oracle adquire a Sun;

!  Novo planejamento de entrega: !  Plano A:

!  JDK 7 completo com previsão para 2012;

!  Plano B: !  JDK 7 com algumas features com previsão para 2011; !  JDK 8 com funcionalidades complementares com previsão para o

fim de 2012;


Qual papel do OpenJDK?

!  Tornar o desenvolvimento do JDK open source (código aberto e livre);

!  Criado pela Sun em 2007;

!   JDK 7 foi o segundo projeto do OpenJDK;

!  Organiza a evolução do JDK em sub-projetos;

!  Pode ser visto com uma opção mais agíl na evolução do Java, em relação demora/burocrácia do JCP;


JSR 336 – Especificação do Java 7

!  Melhorias: !  Linguagem; !  Virtual Machine; !  Class loader; !   I/O, Rede e Concorrência; !  JDBC; !  Swing; !  Web; !  Javadoc;


Projeto Coin

!   Implementa a especificação JSR 334;

!  O objetivo do projeto é prover melhorias para a linguagem Java;

!  Reduz, um pouco, a verbosidade da linguagem;

!  Subprojeto do OpenJDK;


Separador de dígitos em literais numéricos

int i = 1_234_567_890;!!// isso eh esquisito...mas compila!!Integer i1 = new Integer(12_34_56_78_90);!Integer i2 = new Integer(1_2_3_4_5_6_7_8_9_0); System.out.println(i == i1); // imprime true System.out.println(i1.equals(i2)); // imprime true!

float f1 = 123_456.7_5F;!double d1 = 12____345D;!double d2 = 0x1.ffff_ffff_ffff_fP1_023;!!// isso nao compila:!int intRuim1 = _1234;!int intRuim2 = 1234_;!float zuado = 123_456.75_F;!!


Literais binários

public static final int ALARME = 0b001; // o valor é 1 !public static final int FECHADA = 0b010; // o valor é 2 !public static final int ABERTA = 0b100; // o valor é 4 !!public void mostraEstado(int ultimaLeitura) { ! final int[] mascaras = {ALARME, FECHADA, ABERTA}; ! final String[] mensagens = {"alarme", "fechada", "aberta"};!! for (int i = 0; i < mascaras.length; i++) { ! if ((ultimaLeitura & mascaras[i]) == mascaras[i]) ! System.out.println(mensagens[i]);! }!}!


String na condição do switch public static void main(String[] args) {! for (String arg : args) {! switch(arg) {! case "-o1”:! System.out.println("modo de alta otimização (+lento)");! break;! case "-o0":! System.out.println("modo de baixa otimização (+rápido)");! break;! default:! System.err.printf("Parâmetro %s inválido. \n", param);! System.exit(-1);! }! }!}!

O compilador considera comparação via hashcode!


!  Desde sua introdução, construções com tipos genéricos explícitos podem ser atribuídos à variáveis raw type (sem generics) ou com um wildcard:

Inferência na criação de objetos com tipos genéricos

// Java 5+!List rawList = new ArrayList<Object>();!List<?> wildList = new ArrayList<Object>();!!// consequentemente, no Java 7 c/ diamond:!List rawList = new ArrayList<>();!List<?> wildList = new ArrayList<>();!


Tipos genéricos sem operador Diamond

Map<Integer, Set<Integer>> mapOfIntegers = ! new HashMap<Integer, Set<Integer>>();!!Integer aKey = 10;!Set<Integer> aSet = new HashSet<Integer>(); !mapOfIntegers.put(aKey, aSet);!!


Tipos genéricos com operador Diamond

Map<Integer, Set<Integer>> mapOfIntegers = new HashMap<>();!!Integer aKey = 10;!Set<Integer> aSet = new HashSet<>(); !mapOfIntegers.put(aKey, aSet);!!


Tipos genéricos com operador Diamond

Map<Integer, Set<Integer>> mapOfIntegers = new HashMap<>();!!Integer aKey = 10;!Set<Integer> aSet; !mapOfIntegers.put(aKey, aSet = new HashSet<>());!!

// a instrucao a seguir nao compila! !mapOfIntegers.put(aKey, new HashSet<>());!


Simplificação na chamada de métodos com varargs

Set<Integer> aSet = new HashSet<Integer>();!aSet.add(100);!aSet.add(150);!!List<Set<Integer>> listOfSets = Arrays.asList(aSet);!

creation of type java.util.Set<java.lang.Integer>[] for varargs parameter List<Set<Integer>> listOfSets = Arrays.asList(aSet);

!   Esse warning é apresentado ao compilar (-Xlint) a classe:

!   Considere o seguinte trecho de código:



...!List<Set<Integer>> listOfSets = Arrays.asList(new Set[]{aSet});!

!   Código antes compilação, com a opção –XD-printflat:

!   Considere o seguinte trecho de código:

Set<Integer> aSet = new HashSet<Integer>();!aSet.add(100);!aSet.add(150);!!List<Set<Integer>> listOfSets = Arrays.asList(aSet);!



public static <T> List<T> asList(T... a) {! return new ArrayList<>(a);!}!

<T> Tipo<T> nomeDoMetodo(T... params)!

!   O warning é gerado para qualquer método com esse tipo de assinatura:

!   Método asList da classe Arrays:



@SafeVarargs!public static <T> List<T> asList(T... a) {! return new ArrayList<>(a);!}!

!   Solução: criar uma forma de informar o compilador que a chamada ao método asList não corre risco de problemas com tipo de dado!



public static <T> List<T> java.util.Arrays.asList(T... A)!!public static <T> boolean ! java.util.Collections.addAll(Collection<? super T>, ! c, T ... Elements)!!public static <E extends Enum<E>> ! java.util.EnumSet<E> EnumSet.of(E first, E ... Rest)!!protected final void ! javax.swing.SwingWorker.publish(V ... Chunks)!

!   Alguns métodos do Java anotados com @SafeVarargs:


Gerenciamento automático de recursos

!  Nova interface java.lang.AutoCloseable;

!  Bibliotecas adaptadas para implementar essa nova interface;

!  Mudanças em java.lang.Throwable: !  Novo construtor; !  Dois novos métodos;


Sem o gerenciamento automático… public void lerArquivo() {! FileReader reader = null;! try {! reader = new FileReader("arquivo");! // faz o processamento do arquivo ! } catch (IOException e) {! // trata a exceção ! } finally {! if(reader != null) { ! try {! reader.close(); ! } catch (IOException e) {! // tenta fazer alguma outra coisa aqui!! }! }! }!}!


Sem o gerenciamento automático… public void lerArzquivo() {! FileReader reader = null;! try {! reader = new FileReader("arquivo");! // faz o processamento do arquivo ! } catch (IOException e) {! // trata a exceção ! } finally {! if(reader != null) { ! try {! reader.close(); ! } catch (IOException e) {! // tenta fazer alguma outra coisa aqui!! }! }! }!}!


Com o gerenciamento automático

public void lerArquivo() {!! try (FileReader reader = new FileReader("arquivo”)) {! // faz o processamento do arquivo ! } catch (IOException e) {! // trata a exceção ! }!}!

Qualquer classe que implementa a interface java.lang.AutoCloseable

pode ser gerenciada pelo try!


Gerenciamento automático de recursos

protected Throwable(String message, ! Throwable cause, ! boolean enableSuppresion, ! boolean writableStackTrace)!!public final void addSuppressed(Throwable exception)!!public final Throwable[] getSuppressed()!

!  Throwable passa a suportar exceções suprimidas:


Multicatch

!  A cláusula catch está habilitada para uma série de tipos exceções separadas pelo operador “OR”, símbolo “|”, na declaração do paramêtro (tipo da exceção);

!  Dessa forma diferentes tipos de exceções podem ser tratados da mesma forma;


Antes do Multicatch

private Object novoObjeto(Class<?> clazz) {! try {! Object o = clazz.newInstance();! return o;! } catch (InstantiationException e) {! System.err.println("Erro na criação do objeto");! throw new RuntimeException(e); ! } catch (IllegalAccessException e) {! System.err.println("Erro na criação do objeto");! throw new RuntimeException(e);! }!}!


Com Multicatch

private Object novoObjeto(Class<?> clazz) {! try {! Object o = clazz.newInstance();! return o;! } catch (InstantiationException | IllegalAccessException e) {! System.err.println("Erro na criação do objeto");! throw new RuntimeException(e); ! }!}!


Rethrow

!  Se o parâmetro de uma exceção não for modificado e for relançado dentro do bloco catch, o compilador aplica uma análise mais precisa dos tipos que podem ser lançados;


Rethrow opção 1

private Object novoObjeto(Class<?> clazz) {! try {! Object o = clazz.newInstance();! return o;! } catch (InstantiationException | IllegalAccessException e) {! System.err.println("Erro na criação do objeto");! throw new RuntimeException(e); ! }!}!


Rethrow opção 2

private Object novoObjeto(Class<?> clazz)!throws InstantiationException, IllegalAccessException {! try {! Object o = clazz.newInstance();! return o;! } catch (InstantiationException | IllegalAccessException e) {! System.err.println("Erro na criação do objeto");! throw e; ! }!}!


Rethrow novo

private Object novoObjeto(Class<?> clazz)!throws InstantiationException, IllegalAccessException {! try {! Object o = clazz.newInstance();! return o;! } catch (Exception e) {! System.err.println("Erro na criação do objeto");! throw e; ! }!}!


New I/O no Java 7

!   JSR 203: Nova API para New I/O (“NIO.2”): !  FileSystem, Path !  FileSystems, Files, Paths; !  FileStore; !  BasicFileAttributes;

!  Novo pacote: java.nio.file !  Resolve algumas limitações da classe File:

!  Manipulação de arquivo (File system); !  Suporte a links simbólicos;


New I/O no Java 7 – Demo I

!  Fazer backup e mover arquivo:

��Path home = Paths.get("/home/usuario");!Path foto = home.resolve(”foto.jpg");!Path backup = home.resolve(”foto.jpg.backup");!!//faz a copia!Files.copy(foto, backup);!!//move o arquivo!Files.move(backup, home.resolve(”back/"+backup.getFileName()));!


New I/O no Java 7 – Demo II

!   Iterar em arquivos de uma pasta e verificar quais arquivos são links:

��Path dir = Paths.get("/home/usuario");!String filter = "*.jpg";!!//busca por arquivos com extensao jpg!DirectoryStream<Path> st = Files.newDirectoryStream(dir,filter);!!for (Path p: st) {! boolean isLink = Files.isSymbolicLink(p);! System.out.println(p + (isLink ? “ (link)”:””));! if (isLink) {! System.out.println(“\t link p/ ”+Files.readSymbolicLink(p));! }!}!


Ainda sobre I/O: mudanças em Sockets

!  API para socket endereçado a multicasting; !  Acesso assíncrono para sockets e arquivos; !  Suporte a multitarefa com sockets; !  Sockets Direct Protocol (SDP):

!  Maior performance em Infiniband connections (Linux e Solaris);

!  Stream Control Transmisson Protocol; !  API especifica para Solaris;

!  Suporte a (Windows) Vista Ipv6 stack;


Suporte a linguagens com tipagem dinâmica (JSR 292)

! Desde de o Java 6, outras linguagens podem ser utilizadas na plataforma (JSR 223): ! Jython, JRuby, Groovy, Rhino;

! Problema:

! Ao invocar um método, por exemplo, a VM precisa de todas as informações sobre tipagem no bytecode. Mas linguagens dinâmicas não forçam uso do tipo!



!  O compilador JavaScript deve fazer uma pré- compilação transformando o programa JS em algo completamente tipado!

Exemplo Java Exemplo JavaScript int tamanho(String p){! return p.length();! } !

function tamanho() {! return p.length;! }!



! Solução: ! Adicionar uma instrução na VM que possibilite fazer a

chamada de métodos sem a necessidade de definir tipos!

! invokeDynamic


Fork/Join framework

!  Dividir para consquitar; !  Uma nova solução para processamento paralelo; !  Framework projetado para tirar proveito de

ambientes com múltiplos processadores; !  Conceito:

if (meu fluxo de execução é pequeno o suficiente)! processe o fluxo;!else! divida o fluxo em 2 fluxos menores;! verifique a possibilidade de executar esses 2 fluxos;!


JDBC 4.1

!  Suporte a AutoCloseable; !  Nova interface: RowSetProvider;

��String query = "select nome, cpf from pessoa";!!try (Connection con = DriverManager.getConnection(...);! Statement stmt = con.createStatement();! ResultSet rs = stmt.executeQuery(query)) {!! while (rs.next()) {! String nome = rs.getString("nome");! String cpf = rs.getString("cpf");! System.out.printf("Nome:%s\t Cpf:%s %n", nome, cpf);! }!!}!


Outras melhorias

!  Performance em alguns componentes Swing; !  Ajustes na arquitetura do Class loader; !   Javadoc com visual mais interessante; !   Internacionalização:

!  Suporte a Unicode 6.0, IETF BCP47 e UTR35; !  Ajustes em dados de moeda; !  Re-organização nas formas de locale;

!  Melhorias na JVM: !  Garbage; !  Convergência (ainda inicial) com projeto HotRockit;


Java 8: Planejamento

!  Suporte a Programação Modular; !  Projeto Jigsaw; !  Projeto Lambda; !  Funcionalidades restantes para o Projeto Coin; !  Especificação guarda-chuva: JSR 337;


Links ! http://openjdk.java.net/ ! http://openjdk.java.net/projects/jdk7/features/ ! http://java.sun.com/developer/technicalArticles/javase/nio/ ! http://jcp.org/en/jsr/detail?id=336 ! http://download.oracle.com/javase/7/docs/technotes/guides/

jdbc/jdbc_41.html ! http://download.oracle.com/javase/tutorial/essential/

concurrency/forkjoin.html ! http://download.oracle.com/javase/7/docs/api/ ! http://www.infoq.com/br/articles/java7coin


[email protected] @edermag

Obrigado !

Technology

Java7 tdc2011