1. Switch admite la cadena como parámetros
/*** * Switch admite parámetros de cadena JDK7 * @author Huangjiawei */public class switchTest {public static void switchTest (string arg) {switch (arg) {case "lisa": system.err.println ("I am lisa!"); romper; Caso "Mike": System.err.println ("¡Soy Mike!"); romper; predeterminado: system.err.println ("¡Soy tu único!"); romper; }} public static void main (string [] args) {switchTest ("lisa"); // ¡Soy lisa! SwitchTest ("Mike"); // ¡Soy Mike! switchTest (""); // ¡Soy tu único! }}Soporte de enumeración de cambio
/** * Switch Enumeration admite JDK5 * @author Huangjiawei * */public class SwitchMonthTest {public static void swithMonthTest (mes mes) {switch (mes) {case enero: system.err.println ("Esto es enero"); romper; Caso de febrero: System.err.println ("Esto es febrero"); romper; Case March: System.err.println ("This Is March"); romper; }} public static void main (string [] args) {swithMonthTest (mes.January); // Esto es enero swithmonthtest (mes.february); // Esto es febrero swithmonthtest (mes.march); // Esto es marzo}}2. Mejora de literales numéricos
2.1. Antes de Java7, admite decimal (1234), octal (01234) y hexadecimal (0x1234)
Java 8 admite binario (0b11110001)
2.2. Se puede separar por un subscore_
clase pública BinaryTest {private static int a = 16; // decimal private static int b = 020; // octal private static int c = 0x10; // hexadecimal private static int d = 0b0001_0000; // binary, use delimitadores para separar el público estático público separado (String [] args) {System.err.err.err.rintln (a); System.err.println (b); // 16 System.err.println (c); // 16 System.err.println (D); // 16}}3. Los recursos se cierran automáticamente
En Java, hay muchos recursos que deben cerrarse después de que se usan. Tome un castaño, InputStream, Writer, Sockets, Connection, etc. Antes de Java 7, generalmente muestra el método Close (). En Java 7, puedes ignorar si no está cerrado. Podemos usar el bloque de código Try-with Resources.
import java.io.bufferedReader; import java.io.filereader; public class TryTest { /** Aceptar la ruta a un archivo antes de Java 7* / public static String TryTest (string ruta) {bufferedReader br = null; intente {br = new BufferedReader (new FileReader (ruta)); return br.readline (); } Catch (Exception e) {System.err.println ("Excepción BufferedReader" + E); } finalmente {if (br! = null) {try {br.close (); br.ready (); // La transmisión ha sido cerrada, se lanza una excepción aquí} Catch (Exception e) {System.err.println ("BufferedReader Close Exception" + E); } } } devolver ""; } / * * La ruta para aceptar un archivo java7 * /public static string tryTest1 (string ruta) { / * * Cuando se ejecuta el bloque de instrucción de prueba, FileInputStream se cerrará automáticamente. Esto se debe a que FileInputStream implementa la interfaz java.lang.autoclosable en Java. * Todas las clases que implementan esta interfaz se pueden utilizar en la estructura Try-with-RESOURES. */ try (bufferedReader br = new BufferedReader (new FileReader (Path))) {return br.Readline (); } Catch (Exception e) {System.err.println ("Excepción BufferedReader" + E); } devolver ""; } 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. Captura múltiples excepciones
Antes de Java 7, se deben incluir múltiples cláusulas de captura para atrapar múltiples excepciones. En Java 7, podemos escribir de esta manera:
import java.util.date;/*** múltiples declaraciones de captura solo ejecutará la primera excepción de captura que coincide. No importa cuántas capturas haya, serán ignoradas * @author Huangjiawei * */public class CattTest {/ * * antes de Java 7 */public static void CattTest () {int a = 100; int b = 0; Fecha fecha = nulo; Pruebe {System.err.println (date.gettime ()); // La excepción se lanza aquí, ¡y la siguiente declaración no se ejecutará! int resultado = a/b; // system.err.println (resultado); // no ejecutado} capt (nullpointerException e) {system.err.println (e); // java.lang.nullpointerException} catch (arithmetException e) {system.err.println (e); } catch (excepción e) {system.err.println (e); }} / * * java 7 * / public static void gattTest1 () {int a = 100; int b = 0; Fecha fecha = nulo; intente {int resultado = a/b; System.err.println (resultado); System.err.println (date.gettime ()); } catch (arithmeticException | nullpointerException e) {system.err.println (e); // java.lang.arithmeticException:/by cero}} public static void main (string [] args) {capttest (); Catchtest1 (); }}5. Inferencia de tipo de creación de instancias
import java.util.arrayList; import java.util.list; public class typetest { /** antes y después de Java 7, ambos tipos deben declararse* / list <tring> list = new ArrayList <String> (); /** java 7, después de <> no necesita declarar el tipo, y su tipo se inferirá automáticamente en función de la anterior <>*/ list <string> list1 = new ArrayList <> ();}6. Sistema de archivos mejorado
Java7 ha lanzado una nueva API NIO2.0 para cambiar el inconveniente contra la administración de archivos, de modo que usar tipos de uso común, como rutas, rutas, archivos, WatchService, archivos sistemas y otros productos en el paquete java.nio.file puede simplificar en gran medida el trabajo de codificación de los desarrolladores en la gestión de archivos.
6.1 Interfaz de ruta y clase de rutas
Algunas funciones de la interfaz de ruta pueden ser equivalentes a la clase de archivo en el paquete Java.io. Por supuesto, estas funciones se limitan a operaciones de solo lectura. En el desarrollo real, los desarrolladores pueden usar la interfaz de ruta y la clase Paths para obtener una serie de información de contexto del archivo.
Use la interfaz de ruta y el tipo de rutas para obtener información del archivo:
import java.nio.file.path; import java.nio.file.paths; public class PathpathStest {public static void main (string [] args) {rath path = raths.get ("c: ////users///huangjiawei////desktop///my-release-key.key.key.store");; System.out.println ("Número de nodos de archivo:" + path.getNamecount ()); // Número de nodos de archivo: 4 System.out.println ("Nombre del archivo:" + Path.getFileName ()); // Nombre del archivo: my-Release-Key.Keystore System.out.println ("Archivo Root Directory:" + Path.getRoot ()); // Directorio raíz de archivo: c: /system.out.println ("Directorio de asociación superior de archivo:" + path.getParent ()); // Directorio de Asociación Superior de Archivo: C:/Users/Huangjiawei/Desktop}}6.2. Clase de archivos
El uso de la interfaz de ruta y la clase Paths pueden acceder fácilmente a la información de contexto del archivo de destino. Por supuesto, estas operaciones son todas de solo lectura. Si los desarrolladores desean realizar otras operaciones no solo de lectura en archivos, como creación, modificación, eliminación, etc., pueden usar el tipo de archivos para operar.
Los métodos comunes del tipo de archivos son los siguientes:
Ejemplo de copia y pegado de archivos usando el tipo de archivos:
Files.Copy (ratts.get ("/test/src.xml"), ratts.get ("/test/target.xml"));El uso del tipo de archivos para administrar archivos es más conveniente y simple que los métodos de E/S tradicionales. Debido a que la implementación de operación específica se entregará a la API NIO2.0, los desarrolladores no necesitan prestar atención.
6.3. Watchservice
Java7 también proporciona a los desarrolladores un nuevo conjunto de funciones del sistema de archivos, a saber, monitoreo de archivos. Puede haber muchos amigos aquí que no saben cuál es el significado y el propósito del monitoreo de archivos. Por lo tanto, recuerde el contenedor web que se ha depurado en una función de lanzamiento en caliente. Cuando el proyecto se itera y vuelve a implementar, los desarrolladores no necesitan reiniciarlo manualmente porque una vez que el contenedor web detecta que el archivo cambia, se adaptará automáticamente a estos "cambios" y recargará internamente. La función de publicación en caliente de los contenedores web también se basa en la función de monitoreo de archivos, por lo que debe admitirse que la aparición de la función de monitoreo de archivos es de gran importancia para el sistema de archivos Java.
El monitoreo de archivos se basa en eventos, y la activación de eventos es un requisito previo para el monitoreo. Los desarrolladores pueden usar las 3 constantes literales proporcionadas por el tipo StandardWatchEventKinds en el paquete java.nio.file para definir los tipos de eventos de monitoreo. Vale la pena señalar que los eventos de monitoreo deben registrarse con la instancia de WatchService.
Monitoreo de eventos proporcionados por el tipo StandardWatchEventKinds:
Ejemplo completo de implementación de monitoreo de archivos utilizando la clase WatchService:
import java.nio.file.filesystems; import java.nio.file.path; import java.nio.file.paths; import java.nio.file.standardwatcheventkinds; import java.nio.file.watchevent; import java.nio.file.watchey; import java.nio.file.watchservice;/*** Sistema de monitoreo de archivos* @author Huangjiawei*/public class WatchViewTest {public static void testwatch () {/* monitor de destino*/path path = paths.get ("c: // users // huangjiawei // escritorio"); Pruebe { /* Crea un objeto de monitoreo de archivos. */ WatchService WatchService = Filesystems.getDefault (). NewWatchService (); /* Registre todos los tipos de eventos para el monitoreo de archivos. */ Path.register (WatchService, StandardWatcheVentKinds.Entry_Create, StandardWatcheVentKinds.Entry_Delete, StandardWatcheVentKinds.entry_modify); /* Archivo de monitoreo de bucle. */ while (true) {watchKey watchKey = watchService.take (); /* Iterar sobre todos los archivos que activan el evento*/ for (watchEvent <?> Event: watchKey.pollevents ()) {System.out.println (event.context (). ToString () + "tipo de evento:" + event.kind ()); } if (! watchkey.reset ()) {return; }}} Catch (Exception e) {E.PrintStackTrace (); }} public static void main (string [] args) {testWatch (); }} A través de los ejemplos de programa anteriores, podemos ver que usar la interfaz WatchService para el monitoreo de archivos es muy simple y conveniente. Primero, necesitamos definir la ruta de monitoreo de destino y luego llamar al método NewwatchService () de los sistemas de archivos para crear un objeto WatchService. A continuación, necesitamos usar el método Registro () de la interfaz de ruta para registrar la instancia de WatchService y monitorear eventos. Cuando todas estas capas de trabajo básicas están listas, escribimos un ciclo de monitoreo periférico en tiempo real. Finalmente, ite sobre WatchKey para obtener todos los archivos que activen eventos de monitoreo.
¡Ahora finalmente conozco el principio básico de la llamada actualización de Dev-Tools Hot en Spring Boot! Resulta que JDK proporciona tales API.
Resumir
Lo anterior es el análisis de código de la breve introducción de JDK 7 nuevas características del editor. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!