1. O interruptor suporta string como parâmetros
/*** * O switch suporta parâmetros de string jdk7 * @author huangjiawei */public class switchTest {public static void switchTest (string arg) {switch (arg) {case "lisa": system.err.println ("eu sou lisa!"); quebrar; case "Mike": System.err.println ("Eu sou Mike!"); quebrar; Padrão: System.err.println ("Eu sou seu único!"); quebrar; }} public static void main (string [] args) {switchTest ("lisa"); // eu sou lisa! SwitchTest ("Mike"); // Eu sou Mike! SwitchTest (""); // Eu sou seu único! }}Suporte de enumeração da mudança
/** * A enumeração do switch suporta jdk5 * @author huangjiawei * */public classe switchmonthtest {public static void swithmonthtest (mês mês) {switch (mês) {case em janeiro: System.err.println ("Este é janeiro"); quebrar; caso de fevereiro: System.err.println ("Isso é fevereiro"); quebrar; Caso março: System.err.println ("This Is March"); quebrar; }} public static void main (string [] args) {swithmonthtest (mês.january); // Este é em janeiro Swithmonthtest (mês.febrovery); // Este é o swithmontest de fevereiro (Month.march); // em março}}}}}}}}}}}}}}2. Melhoria dos literais numéricos
2.1. Antes de Java7, suporta decimal (1234), octal (01234) e hexadecimal (0x1234)
Java 8 suporta binário (0B111110001)
2.2. Pode ser separado por sublinhado_
classe pública Binária Binária {private estática int a = 16; // estática privada decimal int b = 020; // estático privado octal int c = 0x10; // hexadecimal private static int d = 0b0001_0000; // binário, use delimitadores para separar o anul público público (string (string [] args). System.err.println (b); // 16 system.err.println (c); // 16 system.err.println (d); // 16}}3. Os recursos são fechados automaticamente
Em Java, há muitos recursos que precisam ser fechados depois de serem usados. Pegue uma castanha, inputstream, escritor, soquetes, conexão etc. Antes de Java 7, geralmente exibe o método Close (). No Java 7, você pode ignorar se não está fechado. Podemos usar o bloco de código TRY-S-S-SOUSOURCES.
importar java.io.bufferedReader; importar java.io.fileReader; public class Trytest { /** Aceite o caminho para um arquivo antes do java 7* / public static string trytest (string path) {buffarredreader br = null; tente {Br = new BufferredReader (new FileReader (Path)); return b.readline (); } Catch (Exceção e) {System.err.println ("Exceção buffarreder" + e); } finalmente {if (br! = null) {tente {Br.Close (); B.Ready (); // O fluxo foi fechado, uma exceção é lançada aqui} Catch (Exceção e) {System.err.println ("BufferredReader Close Exception" + E); } } } retornar ""; } / * * O caminho para aceitar um arquivo java7 * /public static string trytest1 (caminho da string) { / * * Quando o bloco de instrução Try é executado, o FileInputStream será fechado automaticamente. Isso ocorre porque o FileInputStream implementa a interface java.lang.autocloseable em java. * Todas as classes que implementam essa interface podem ser usadas na estrutura Try-With-RESOURCES. */ Try (BufferEredReader Br = new BufferredReader (novo FileReader (Path))) {return b.readline (); } Catch (Exceção e) {System.err.println ("Exceção buffarreder" + e); } retornar ""; } public static void main (string [] args) {trytest ("c: //users//huangjiawei//desktop//my-release-key.keystore"); Trytest1 ("c: //users//huangjiawei//desktop//my-release-key.keystore"); }}4. Pegue várias exceções
Antes do Java 7, várias cláusulas de captura devem ser incluídas para capturar várias exceções. No Java 7, podemos escrever desta maneira:
Importar java.util.date;/*** Múltiplas instruções de captura executarão apenas a primeira exceção de captura que corresponde. Não importa quantas capturas existam, elas serão ignoradas * @author huangjiawei * */public class CatchTest {/ * * antes do java 7 */public static void cattTest () {int a = 100; int b = 0; Data data = nulo; tente {System.err.println (date.gettime ()); // A exceção é lançada aqui, e a seguinte declaração não será executada! int resultado = a/b; // system.err.println (resultado); // não executado} catch (nullPointerException e) {System.err.println (e); // java.lang.nullPointerException} Catch (arithmeticexception e) {System.err.printlnnnn (e); } catch (Exceção e) {System.err.println (e); }} / * * java 7 * / public static void catchTest1 () {int a = 100; int b = 0; Data data = nulo; tente {int resultado = a/b; System.err.println (resultado); System.err.println (date.gettime ()); } catch (arithmeticexception | nullPointerException e) {System.err.println (e); // java.lang.arithmeticexception:/por zero}} public static void main (string [] args) {catchTest (); CatchTest1 (); }}5. Inferência do tipo de criação da instância
importar java.util.ArrayList; importar java.util.list; public class TypeTest { /** antes e depois do Java 7, ambos os tipos devem ser declarados* / list <String> list = new ArrayList <String> (); /** Java 7, depois de <> não precisa declarar o tipo, e seu tipo será automaticamente inferido com base no anterior6. Sistema de arquivo aprimorado
O Java7 lançou uma nova API do NIO2.0 para alterar o inconveniente contra o gerenciamento de arquivos, de modo que o uso de tipos comumente usados, como caminho, caminhos, arquivos, serviços de relógios, sistema de arquivos e outros produtos no pacote java.nio.file, pode simplificar bastante o trabalho de codificação dos desenvolvedores em gerenciamento de arquivos.
6.1 Classe de interface e caminhos
Algumas funções da interface do caminho podem realmente ser equivalentes à classe de arquivo no pacote java.io. Obviamente, essas funções são limitadas a operações somente leitura. No desenvolvimento real, os desenvolvedores podem usar a interface do caminho e a classe Paths para obter uma série de informações de contexto do arquivo.
Use a interface do caminho e o tipo de caminho para obter informações de arquivo:
import java.nio.file.Path;import java.nio.file.Paths;public class PathPathsTest { public static void main(String[] args) { Path path = Paths.get("C:////Users///huangjiawei////Desktop////my-release-key.keystore"); System.out.println ("Número de nós de arquivo:" + path.getNamecount ()); // Número de nós do arquivo: 4 System.out.println ("Nome do arquivo:" + path.getfilename ()); // Nome do arquivo: my-release-key.keystore system.out.println ("diretório raiz do arquivo:" + path.getroot ()); // Diretório de root de arquivo: c: /system.out.println ("diretório de associação superior do arquivo:" + path.getParent ()); // Diretório da Associação Superior de Arquivo: C:/Usuários/Huangjiawei/Desktop}}6.2. Classe de arquivos
Usando a interface do caminho e a classe Paths pode acessar facilmente as informações de contexto do arquivo de destino. Obviamente, essas operações são somente leitura. Se os desenvolvedores quiserem executar outras operações não leituras em arquivos, como criação, modificação, exclusão etc., eles podem usar o tipo de arquivos para operar.
Os métodos comuns de arquivos tipo são os seguintes:
Exemplo de copiar e colar arquivos usando arquivos Tipo:
Files.copy (paths.get ("/test/src.xml"), paths.get ("/test/target.xml"));O uso de arquivos do tipo para gerenciar arquivos é mais conveniente e simples do que os métodos de E/S tradicionais. Como a implementação de operação específica será entregue à API do NIO2.0, os desenvolvedores não precisam prestar atenção.
6.3. WatchService
O Java7 também fornece aos desenvolvedores um novo conjunto de funções do sistema de arquivos, como monitoramento de arquivos. Pode haver muitos amigos aqui que não sabem qual é o significado e o objetivo do monitoramento de arquivos. Portanto, lembre -se do contêiner da web que foi depurado em uma função de liberação quente. Quando o projeto é iterado e re-implantado, os desenvolvedores não precisam reiniciá-lo manualmente porque, uma vez que o contêiner da web detecta que o arquivo altera, ele se adaptará automaticamente a essas "alterações" e recarregará internamente. A função de publicação a quente dos contêineres da Web também é baseada na função de monitoramento de arquivos, portanto, deve -se admitir que o surgimento da função de monitoramento de arquivos é de grande significado para o sistema de arquivos Java.
O monitoramento de arquivos é orientado a eventos e o acionamento de eventos é um pré-requisito para o monitoramento. Os desenvolvedores podem usar as três constantes literais fornecidas pelo tipo StandardWatchEventKinds no pacote java.nio.file para definir tipos de eventos de monitoramento. Vale ressaltar que os eventos de monitoramento precisam ser registrados na instância do WatchService.
Eventos de monitoramento fornecidos pelo StandardWatchEventKinds Tipo:
Exemplo completo de implementação de monitoramento de arquivos usando a classe WatchService:
importar java.nio.file.filesystems; importar java.nio.file.path; importar java.nio.file.paths; importar java.nio.file.standardwatcheventkinds; import java.nio.file.watchevent; import java.nio.file; Sistema de monitoramento de arquivos* @author huangjiawei*/public class WatchViewTest {public static void testWatch () {/* Monitora caminho de destino*/caminho do caminho = paths.get ("c: // usuários // huangjiawei // desktop"); tente { /* Crie um objeto de monitoramento de arquivos. */ WatchService WatchService = filesystems.getDefault (). Newwatchservice (); /* Registre todos os tipos de eventos para monitoramento de arquivos. */ path.register (WatchService, StandardWatchEventkinds.entry_create, StandardWatchEventkinds.entry_Delete, StandardWatchEventkinds.entry_modify); /* Arquivo de monitoramento de loop. */ while (true) {watchKey watchKey = watchService.take (); /* Itreate sobre todos os arquivos que acionam o evento*/ para (WatchEvent <?> Event: watchKey.pollevents ()) {System.out.println (event.Context (). ToString () + "Tipo de evento:" + event.kind ()); } if (! watchKey.reset ()) {return; }}} catch (Exceção e) {e.printStackTrace (); }} public static void main (string [] args) {testwatch (); }} Através dos exemplos do programa acima, podemos ver que o uso da interface WatchService para monitoramento de arquivos é muito simples e conveniente. Primeiro, precisamos definir o caminho de monitoramento de destino e, em seguida, ligar para o método newWatchService () do tipo de sistemas de arquivos para criar um objeto WatchService. Em seguida, precisamos usar o método Register () da interface do caminho para registrar a instância do WatchService e monitorar eventos. Quando todas essas camadas básicas de trabalho estiverem prontas, escrevemos um ciclo de monitoramento em tempo real periférico. Finalmente, itera sobre o WatchKey para obter todos os arquivos que acionam eventos de monitoramento.
Agora eu finalmente conheço o princípio básico da chamada atualização de dev-tools em Botta na primavera! Acontece que o JDK fornece essas APIs.
Resumir
O exposto acima é a análise de código do JDK 7 novos recursos breves Introdução pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!