1. Novas características do Java JDK1.5
1. Genéricos:
List <String> strs = new ArrayList <String> (); // Especifique o tipo de armazenamento para a coleção. Ao armazenar dados na coleção acima, os dados da string devem ser armazenados, caso contrário, o compilador relatará um erro
2.For-ECO
Por exemplo, podemos atravessar a coleção acima através do for-EACH, o que torna mais fácil e claro
for (string s: strs) {System.out.println (s);}NOTA: Ao usar a For-Each para atravessar uma coleção, a coleção para atravessar deve implementar a interface do iterador
3. Funções automáticas de unboxing e embalagem
A cópia do código é a seguinte:
O que isso significa?
O JDK1.5 define uma classe de encapsulamento para cada tipo de dados básico. Faça os tipos de dados básicos em Java também têm seus próprios objetos, por exemplo: int -> Integer,
duplo -> duplo,
longo -> longo,
char -> personagem,
flutuar -> flutuar,
booleano -> booleano,
curto -> curto,
BYTE -> BYTE
Embalagem automática: converta tipos básicos em objetos, por exemplo: int -> inteiro
Desenvolvimento automático: converta objetos em tipos básicos de dados, por exemplo: Inteiro -> int
O problema que a coleção não poderia armazenar tipos de dados básicos antes que o JDK1.5 agora possa ser resolvido.
4. Enumeração:
A enumeração é um recurso comparativo introduzido pelo JDK1.5. A palavra -chave é enum
Por exemplo: Defina uma enumeração representando um semáforo
public Enum Myenum {vermelho, verde, amarelo}5. Parâmetros variáveis
O que isso significa? Deixe -me dar um exemplo: antes do JDK1.5, quando queríamos passar vários parâmetros do mesmo tipo para um método, tivemos dois métodos para resolvê -lo, 1. Passe diretamente uma matriz, 2. Passe quantos parâmetros são.
Por exemplo:
public void PrintColor (String Red, String Green, String Yellow) {} ou
public void PrintColor (String [] Colors) {} Embora os parâmetros do método de escrita dessa maneira possam alcançar o efeito que queremos, isso não é um pouco problemático? Além disso, o que devemos fazer se o número de parâmetros for incerto? Os parâmetros variáveis fornecidos pelo Java JDK1.5 podem resolver perfeitamente esse problema, por exemplo:
public void PrintColor (String ... cores) {}
Pode ser definido assim, o que significa? Se os parâmetros forem do mesmo tipo, você poderá usar o formulário "Tipo + três pontos, seguido por um nome de parâmetro". A vantagem disso é que, desde que os tipos de parâmetros sejam iguais, não há limite para o número de parâmetros passados: o parâmetro variável deve ser o último item na lista de parâmetros (esse recurso se aplica aos tipos de dados de objeto e básico)
6. Importação estática
Vantagens: O uso de importação estática pode tornar todas as variáveis estáticas e métodos estáticos da classe importada diretamente visíveis na classe atual. O uso desses membros estáticos não precisa dar seus nomes de classe.
Desvantagens: o uso excessivo reduzirá a legibilidade do código
7. Biblioteca de simultaneidade de thread
A Biblioteca de Concorrência do Thread é um recurso avançado do multithreading proposto pelo Java 1.5. Está localizado no pacote: java.util.concurrent
incluir
1. Thread Mutex Tool Class Descrição: Lock, Redwritelock
2. Descrição da comunicação do thread: Condição
3. Pool de threads
ExecutorService
3 Sincronize a fila
ArrayblockingQueue
4. Sincronize coleções
Concurrenthashmap, copywriteArrayList
5. Ferramenta de sincronização de threads
Semáforo
Ainda existem muitos conteúdos (muito importantes) sobre as bibliotecas de simultaneidade de threads, por isso não as listarei uma a uma aqui. Amigos interessados podem conferir os documentos de ajuda.
2. Novos recursos do JDK1.6
1. Desktop Classe e Systemtray Class
O primeiro pode ser usado para abrir o navegador padrão do sistema para navegar no URL especificado, abrir o cliente de email padrão do sistema para enviar e -mails para o endereço de email especificado, usar o aplicativo padrão para abrir ou editar arquivos (por exemplo, usar o bloco de notas para abrir um arquivo com TXT como sufixo) e usar o sistema de default para imprimir documentos; Este último pode ser usado para criar um programa de bandeja na área da bandeja do sistema.
2. Use Jaxb2 para implementar o mapeamento entre objetos e XML
JAXB é a abreviação da arquitetura Java para ligação ao XML, que pode converter um objeto Java em formato XML e vice -versa.
Chamamos o mapeamento entre objetos e bancos de dados relacionais ORM e, de fato, o mapeamento entre objetos e XML também pode ser chamado de oxm (mapeamento do objeto XML). Acontece que Jaxb faz parte do Java Ee. No JDK1.6, o Sun o coloca em Java SE, que também é a prática usual de Sun. A versão JAXB que vem com JDK1.6 é 2.0. Comparado com 1,0 (JSR 31), o JAXB2 (JSR 222) usa a nova anotação do recurso JDK5 para identificar as classes e atributos a serem ligados, o que simplifica bastante a carga de trabalho de desenvolvimento. De fato, no Java EE 5.0, os serviços EJB e Web também simplificam o desenvolvimento por meio da anotação. Além disso, o JAXB2 usa Stax (JSR 173) para processar documentos XML na parte inferior.
Além do JAXB, também podemos alcançar as mesmas funções através do XMLBeans e Castor, etc.
3. Entenda Stax
Stax (JSR 173) é outra API para processar documentos XML em JDK1.6.0, além de DOM e Sax.
Origem do STAX: Existem duas maneiras de processar documentos XML no JAXP1.3 (JSR 206): DOM (modelo de objeto de documento) e Sax (API simples para XML).
Como o JAXB2 (JSR 222) e JAX-WS 2.0 (JSR 224) em JDK1.6.0 Use Stax, a Sun decidiu adicionar Stax à família Jaxp e atualizar a versão Jaxp para 1.4 (Jaxp1.4 é a versão de manutenção do JAXP1.3). A versão JAXP no JDK1.6 é 1.4. Stax é a API de streaming para a abreviação de XML, uma API que usa documentos XML de pulse-puscing. O STAX fornece uma API baseada em um iterador de evento para permitir que os programadores controlem o processo de análise do documento XML. O programa atravessa esse iterador para processar cada evento de análise. O evento de análise pode ser considerado como sendo retirado pelo programa, ou seja, o programa leva o analisador a gerar um evento de análise e, em seguida, lida com o evento e, em seguida, faz com que o analisador gere o próximo evento de análise. Esse loops até que o caractere final do documento seja encontrado. O SAX também processa documentos XML com base em eventos, mas usa o modo push para analisar. Depois que o analisador analisa o documento XML completo, ele gera apenas eventos de análise e empurra -os para o programa para processar esses eventos. O DOM adota o método para mapear todo o documento XML para uma árvore de memória, para que os dados do nó pai, dos nós filhos e do irmão possam ser facilmente obtidos, mas se o documento for grande, afetará seriamente o desempenho.
4. Use API do compilador
Agora, podemos usar a API do compilador de JDK1.6 (JSR 199) para compilar os arquivos de origem Java dinamicamente. A API do compilador combina a função de reflexão para obter geração dinâmica de código Java e compilar e executar esses códigos, o que é um recurso de linguagem dinâmica.
Esse recurso é muito útil para alguns aplicativos que requerem compilação dinâmica, como o JSP Web Server. Quando modificamos manualmente o JSP, não queremos reiniciar o servidor da web para ver o efeito. No momento, podemos usar a API do compilador para implementar a compilação dinâmica de arquivos JSP. Obviamente, o servidor Web JSP atual também suporta a implantação do JSP Hot. O servidor Web JSP atual chama o JAVAC através do RUNTime.Exec ou ProcessBuilder para compilar código durante a operação. Esse método exige que geramos outro processo para fazer compilação, que não é elegante o suficiente e é fácil de fazer com que o código dependa de um sistema operacional específico. A API do Compiler fornece uma maneira mais rica de fazer compilação dinâmica através de um conjunto de APIs padrão fáceis de usar e é uma plataforma cruzada.
5. API de servidor HTTP leve
O JDK1.6 fornece uma API de servidor HTTP simples. De acordo com isso, podemos criar nosso próprio servidor HTTP incorporado, que suporta os protocolos HTTP e HTTPS e fornece parte da implementação do HTTP1.1. A peça que não é implementada pode ser implementada, estendendo a API do servidor HTTP existente. Os programadores devem implementar a interface httphandler por si mesmos. O HTTPSERVER chamará o método de retorno de chamada da classe de implementação httphandler para lidar com solicitações do cliente. Aqui, chamamos uma solicitação HTTP e sua resposta de uma troca, que é embrulhada em uma classe HTTPEXCHANGE. O HttpServer é responsável por passar o HTTPEXCHANGE para o método de retorno de chamada da classe de implementação Httphandler.
6. API de processamento de anotação reprodutiva (API de processamento de anotações de anotação flash)
A API de processamento de anotação plug-in (JSR 269) fornece uma API padrão para lidar com anotações (JSR 175)
De fato, o JSR 269 não é usado apenas para lidar com a anotação. Eu acho que a função mais poderosa é que ela estabelece um modelo da própria linguagem Java. Ele mapeia elementos da linguagem Java, como método, pacote, construtor, tipo, variável, enumeração, anotação em tipos e elementos (qual é a diferença entre os dois?), Mapeando assim a semântica da linguagem Java em objetos. Podemos ver essas classes no pacote javax.lang.model. Assim, podemos usar a API fornecida pelo JSR 269 para criar um ambiente de metaprogramação rico em recursos. O JSR 269 usa o processador de anotação para processar a anotação durante a compilação e não durante a operação. O processador de anotação é equivalente a um plug-in do compilador, por isso é chamado de processamento de anotação de inserção. Se o novo código Java for gerado quando o processador de anotação processou a anotação (executando o método do processo), o compilador chamará o processador de anotação novamente. Se o novo código for gerado para o segundo processamento, ele chamará o processador de anotação até que nenhum novo código seja gerado. Cada vez que o método Process () é executado, ele é chamado de "rodada", para que todo o processo de processamento da anotação possa ser considerado uma sequência redonda.
O JSR 269 é projetado principalmente como uma API para ferramentas ou contêineres. Por exemplo, queremos estabelecer uma estrutura de teste de unidade baseada em anotação (como o TestNG) para usar a anotação para identificar os métodos de teste que precisam ser executados durante o teste.
7. Use o console para desenvolver programas de console
O JDK1.6 fornece a classe Java.io.Console usada especificamente para acessar dispositivos de console baseados em caracteres. Se o seu programa quiser interagir com o CMD no Windows ou terminal no Linux, você poderá usar a classe de console para fazê -lo. Mas nem sempre temos o console disponível, se uma JVM possui console disponível depende da plataforma subjacente e de como a JVM é chamada. Se a JVM for iniciada em uma linha de comando interativa (como o Windows CMD) e a entrada e a saída não forem redirecionadas em outro lugar, você poderá obter uma instância de console disponível.
8. Suporte para linguagens de script
Como: Ruby, Groovy, JavaScript.
9. Anotações comuns
As anotações comuns eram originalmente parte da especificação Java EE 5.0 (JSR 244), e agora o Sun coloca parte dela no Java SE 6.0.
Com a adição da função dos metadados da anotação (JSR 175) ao Java SE 5.0, muitas tecnologias Java (como EJB e Serviços da Web) usarão a peça de anotação para substituir os arquivos XML para configurar parâmetros de execução (ou apoiar a programação declarativa, como transações do EJB). Se essas tecnologias definirem suas próprias otações separadamente para fins gerais, é obviamente uma construção um pouco duplicada. Portanto, é valioso definir um conjunto de anotação pública para outras tecnologias Java relacionadas. Pode evitar a construção duplicada, além de garantir a consistência de várias tecnologias de Java SE e Java EE.
Os seguintes listas 10 anotações anotações comuns de retenção de anotações Descrição Gerou SourCeanNotation_Type, construtor, campo, local_variable, método, pacote, parâmetro, tipo. O código -fonte gerado pela anotação é usado para rotular o recurso gerado. O contêiner injeta dependências de recursos externos de acordo com isso. Existem dois métodos: injeção baseada em campo e injeção baseada em setter. Recursos tempo de execução. Digite rotula várias dependências externas ao mesmo tempo. O contêiner injetará todas essas dependências externas no método pós -conclusão. O método é executado depois que o contêiner injeta todas as dependências para executar o trabalho de inicialização após a injeção de dependência. Apenas um método pode ser rotulado como método de tempo de execução do PostConstruct Predestroy. Antes que a instância do objeto esteja prestes a ser excluída do contêiner, o método de retorno de chamada a ser executado deve ser rotulado como o tipo de tempo de execução do PredeStroy Runas é usado para rotular qual função de segurança executar o método da classe rotulada. Essa função de segurança deve ser consistente com a função de segurança do contêiner. Tipo de tempo de execução do ROUSCOUNDED, o método é usado para rotular funções de segurança que permitem a execução de classes ou métodos rotulados. Essa função de segurança deve ser consistente com a função de segurança do contêiner. O método permite que todas as funções executem classes ou métodos rotulados. Denyall Runtime Type. O método não permite que nenhuma função execute classes ou métodos rotulados, indicando que a classe ou métodos não pode ser executado no contêiner Java EE. O tipo de tempo de execução do Declareroles é usado para definir funções de segurança que podem ser testadas pelo aplicativo. Geralmente é usado para usar o isuserinRole para verificar as funções de segurança.
Perceber:
1. Robos arrastados, Permitall e Denyall não podem ser aplicados a Rousable ou Denyall de classe ou método, e o Denyall rotulado na aula substituirá os ROUSCIONADOS, PERMITALL, DENYALLRUNAS, ROUPESSALIDADOS, PERMITALL, DENYALL e DeclareRoles não são adicionados a Java se 6.0 para manipular as pessoas que trabalham acima. O Java SE6.0 contém apenas as classes de definição das cinco primeiras anotações na tabela acima e não contém o motor para lidar com essas anotações. Este trabalho pode ser realizado pela API de processamento de anotação emplacável (JSR 269).
Comparado com os novos recursos de 1.6, os novos recursos de 1.7 nos tornam mais animados, porque é algo que esperamos e visível e tangível.
3. Novos recursos do JDK1.7
1. Valor de face binário
No Java7, o valor do tipo de modelagem (byte, curto, int, longo) pode ser representado por tipos binários. Ao usar valores binários, OB ou OB precisa ser adicionado na frente dele, por exemplo:
int a = 0b01111_00000_11111_00000_10101_01010_10; curto b = (curto) 0B01100_00000_11111_0; byte c = (byte) 0b00000_0001;
2. Suporte de variáveis digitais para linhas deslizantes
O JDK1.7 pode adicionar uma linha de slide a uma variável do tipo numérico.
Mas existem alguns lugares que não podem ser adicionados
1. O início e o fim do número
2. Antes e depois do ponto decimal
3. Antes de l, por exemplo:
int num = 1234_5678_9;
float num2 = 222_33f;
Num3 longo = 123_000_111L;
3. O suporte do Switch para string
Você sempre teve um ponto de interrogação antes? Por que C# está disponível em Java, mas não? Ha, mas Java também está ok após o JDK1.7, por exemplo:
String status = "orderstate"; switch (status) {case "OrderCancel": system.out.println ("cancelamento do pedido"); quebrar; case "ordensuccess": system.out.println ("assinatura bem -sucedida"); quebrar; padrão: System.out.println ("status desconhecido"); }4.Ter-com-resource
Try-with-Resources é uma declaração de tentativa que define um ou mais recursos. Esse recurso refere -se ao objeto que o programa precisa fechar após o processo. Try-with-RESOURCES Garanta que todos os recursos sejam fechados após a conclusão do processamento.
Recursos que podem usar o Try-With-RESOURCES são:
Qualquer objeto que implemente a interface java.lang.Autoclosable java.io.closable.
Por exemplo:
public static string readfirstLineFromFile (String Path) lança IoException {Try (BufferReader Br = new BufferredReader (new FileReader (Path))) {return b.readline (); }}
Em Java 7 e versões posteriores, o BufferredReader implementa a interface java.lang.autoclosable.
Como o BufferredReader é definido na declaração de Try-With-RESOURCES, ele será desligado automaticamente, independentemente de a declaração de tentativa ser normal ou anormal. Antes de Java7, você precisa usar os blocos finalmente para fechar esse objeto.
5. Pegue múltiplas exceções e reencontre a exceção com a verificação de tipo aprimorada
Por exemplo:
public static void primeiro () {try {bufferredader leitor = new BufferredReader (new FileReader ("")); Conexão con = null; Declaração stmt = con.createstatement (); } catch (ioexception | sqLexception e) {// captura várias exceções, e é o tipo final E.printStackTrace (); }}Vantagens: o uso de uma captura para lidar com várias exceções é menor e mais eficiente do que usar várias capturas para lidar com uma exceção ao bytecode gerado pelo processamento de uma exceção.
6. Tipo de inferência ao criar genéricos
Desde que o compilador possa inferir parâmetros de tipo do contexto, você poderá substituir parâmetros genéricos por um par de colchetes de ângulo vazio <>. Este par de colchetes é chamado de diamante privado. Antes de Java SE 7, você deve fazer isso ao declarar um objeto genérico
List <String> list = new ArrayList <String> ();
E depois de Java SE7, você pode fazer isso
List <String> list = new ArrayList <> ();
Como o compilador pode inferir parâmetros de tipo da (lista) anterior, você não pode mais escrever parâmetros genéricos após a lista de Arraylist subsequente, basta usar um par de suportes de ângulo vazio. Obviamente, você deve carregar um "diamante" <>, caso contrário, haverá um aviso.
O Java SE7 suporta apenas o tipo limitado de inferência: você só pode usar a inferência de tipo se o tipo parametrizado do construtor for significativamente declarado no contexto, caso contrário, ele não funcionará.
List <String> list = new ArrayList <> (); list.add ("A"); // Isso não funciona list.addall (novo ArrayList <> ()); // isso pode ser lista <? estende string> list2 = new ArrayList <> (); list.addall (List2);
7. (Nenhum)
8. Adicione algumas novas ferramentas e métodos para obter informações ambientais
Por exemplo:
Arquivo system.getUserHomedir () // atual diretório do usuário do usuário system.getUserdir () // diretório onde você está ao iniciar o processo de arquivo do processo 5 do processo 5
9. Adição segura, subtração, multiplicação e divisão
Por exemplo:
int math.SefeToint (valor longo) int matemática.Safenegate (int valor) Math.SafesAfesubtract (Valor longo1, int valor2) Math.SAFESUCTRATE (Valor longo1, Valor longo2) Int Math.Sefemultiply (Int Value1, int Value2) Long.Safultiply (Long Value1, Int Value2) (Int Value1, Math.sf.sAf.sAfultiply (Long Value1, Value2) Math.Safenegate (Valor longo) int math.Safeadd (int Value1, int Value2) MATH.SAFEADD (Valor longo1, int Value2) Math.Safeadd (Valor longo1, Valor Longo2) Int Math.Safesubtract (int Value1, int Value2)
Bem, muito foi resolvido até agora. Vou adicioná -lo mais tarde.
Deve -se notar que, se você não tiver certeza da sua versão JDK anterior, não use novos recursos, caso contrário, pode haver problemas disso ou daquilo.