1. Switch prend en charge la chaîne comme paramètres
/ *** * Switch prend en charge les paramètres de chaîne jdk7 * @author huangjiaWei * / public class switchTest {public static void switchtest (string arg) {switch (arg) {case "lisa": system.err.println ("je suis lisa!"); casser; cas "Mike": System.err.println ("Je suis Mike!"); casser; par défaut: System.err.println ("Je suis votre seul!"); casser; }} public static void main (String [] args) {switchtest ("lisa"); // je suis Lisa! SwitchTest ("Mike"); // Je suis Mike! SwitchTest (""); // Je suis votre seul! }}Prise en charge de l'énumération de commutation
/ ** * Switch L'énuméation prend en charge JDK5 * @author HuangJiaWei * * / classe publique SwitchmonthTest {public static void swithmonthtest (mois mois) {switch (mois) {case janvier: system.err.println ("Ceci est janvier"); casser; Cas février: System.err.println ("Ceci est février"); casser; Case mars: System.err.println ("This Is March"); casser; }} public static void main (string [] args) {swithmonthtest (Month.january); // c'est janvier swithmonthtest (Month.February); // c'est février Swithmonthtest (Month.March); // Ceci est mars}}2. Amélioration des littéraux numériques
2.1. Avant Java7, il prend en charge décimal (1234), octal (01234) et hexadécimal (0x1234)
Java 8 prend en charge le binaire (0b11110001)
2.2. Peut être séparé par soulignement_
classe publique binarytest {private static int a = 16; // décimal private static int b = 020; // octal private static int c = 0x10; // hexadecimal private static int d = 0b0001_0000; // binary, utilisez des délimiteurs pour séparer le public static public (string [] args) {system.err.println (a); // 16 System.err.println (b); // 16 System.err.println (C); // 16 System.err.println (D); // 16}}3. Les ressources sont automatiquement fermées
À Java, il existe de nombreuses ressources qui doivent être fermées après leur utilisation. Prenez un châtaignier, une intrigue, un écrivain, des prises, une connexion, etc. Avant Java 7, il affiche généralement la méthode close (). Dans Java 7, vous pouvez ignorer s'il n'est pas fermé. Nous pouvons utiliser le bloc de code TRY-with-Resources.
Importer java.io.bufferedReader; import java.io.fileReader; public class tryTest {/ * * accepter le chemin d'accès à un fichier avant java 7 * / public static string tryTest (String path) {buffereDader br = null; try {br = new BufferedReader (new FileReader (path)); return br.readline (); } catch (exception e) {System.err.println ("exception BufferedReader" + E); } enfin {if (br! = null) {try {br.close (); br.ready (); // Le flux a été fermé, une exception est lancée ici} catch (exception e) {System.err.println ("BufferedReader Close Exception" + E); } } } retour ""; } / * * Le chemin d'accès pour accepter un fichier java7 * / public static String tryTest1 (String path) {/ * * Lorsque le bloc de l'instruction TRY s'exécute, FileInputStream sera automatiquement fermé. En effet, FileInputStream implémente l'interface java.lang.autoclosable dans Java. * Toutes les classes qui implémentent cette interface peuvent être utilisées dans la structure TRY-With-Resources. * / try (bufferedReader br = new BufferedReader (new FileReader (path))) {return br.readline (); } catch (exception e) {System.err.println ("exception BufferedReader" + E); } retour ""; } 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. Cattrez plusieurs exceptions
Avant Java 7, plusieurs clauses de capture doivent être incluses pour capter plusieurs exceptions. Dans Java 7, nous pouvons écrire de cette façon:
Importer java.util.date; / ** * Les instructions de capture multiples exécuteront uniquement la première exception de capture qui correspond. Peu importe combien de captures il y a, ils seront ignorés * @author HuangJiaWei * * / public class Catchtest {/ * * Avant Java 7 * / public static void catchtest () {int a = 100; int b = 0; Date de date = null; Essayez {System.err.println (date.getTime ()); // L'exception est lancée ici, et l'instruction suivante ne sera pas exécutée! Int result = a / b; // system.err.println (result); // non exécuté} catch (nullpointerException e) {System.err.println (e); // java.lang.nullpointerException} catch (arithmeticexception e) {System.err.println (e); } catch (exception e) {System.err.println (e); }} / * * java 7 * / public static void catchTest1 () {int a = 100; int b = 0; Date de date = null; essayez {int résultat = a / b; System.err.println (résultat); System.err.println (date.getTime ()); } catch (arithmeticexception | nullpointerException e) {system.err.println (e); // java.lang.arithmeticexception: / by zero}} public static void main (String [] args) {catchTest (); CatchTest1 (); }}5. Inférence du type de création d'instance
import java.util.arraylist; import java.util.list; classe publique typetest {/ * * avant et après Java 7, les deux types doivent être déclarés * / list <string> list = new ArrayList <string> (); / * * Java 7, après <> n'a pas besoin de déclarer le type, et son type sera automatiquement déduit en fonction du précédent <> * / list <string> list1 = new ArrayList <> ();}6. Système de fichiers amélioré
Java7 a lancé une nouvelle API NIO2.0 pour modifier l'inconvénient par rapport à la gestion des fichiers, afin que l'utilisation de types couramment utilisés tels que le chemin, les chemins, les fichiers, le service de gardien, le système de fichiers et d'autres produits sous le package java.nio.file peuvent simplifier considérablement le travail de codage des développeurs sur la gestion des fichiers.
6.1 Classe d'interface de chemin et de chemins
Certaines fonctions de l'interface de chemin peuvent en fait être équivalentes à la classe de fichiers dans le package java.io. Bien sûr, ces fonctions sont limitées aux opérations en lecture seule. Dans le développement réel, les développeurs peuvent utiliser l'interface de chemin et la classe Paths pour obtenir une série d'informations contextuelles du fichier.
Utilisez l'interface de chemin et le type de chemins pour obtenir des informations de fichier:
Importer 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///users-release-key.keystore"); System.out.println ("Nombre de nœuds de fichier:" + path.getNameCount ()); // Nombre de nœuds de fichiers: 4 System.out.println ("Nom de fichier:" + path.getFileName ()); // Nom de fichier: my-release-key.keystore System.out.println ("Directory root de fichier:" + path.getroot ()); // Répertoire racine de fichier: c: /system.out.println ("Répertoire de l'association supérieure de fichier:" + path.getParent ()); // Fichier Répertoire de l'association supérieure: c: / utilisateurs / Huangjiawei / Desktop}}6.2. Classe de fichiers
L'utilisation de l'interface de chemin et de la classe Paths peut facilement accéder aux informations de contexte du fichier cible. Bien sûr, ces opérations sont toutes en lecture seule. Si les développeurs souhaitent effectuer d'autres opérations non liées uniquement sur des fichiers, tels que la création, la modification, la suppression, etc., ils peuvent utiliser le type de fichiers pour fonctionner.
Les méthodes courantes de type de fichiers sont les suivantes:
Exemple de copie et de collage de fichiers à l'aide de fichiers Type:
Files.copy (paths.get ("/ test / src.xml"), paths.get ("/ test / target.xml"));L'utilisation de types de fichiers pour gérer les fichiers est plus pratique et simple que les méthodes d'E / S traditionnelles. Étant donné que la mise en œuvre de l'opération spécifique sera remise à l'API NIO2.0, les développeurs n'ont pas besoin de faire attention.
6.3. Watchservice
Java7 fournit également aux développeurs un nouvel ensemble de fonctions de système de fichiers, à savoir la surveillance des fichiers. Il peut y avoir beaucoup d'amis ici qui ne savent pas quelle est la signification et le but de la surveillance des fichiers. Veuillez donc rappeler le conteneur Web qui a été débogué dans une fonction de version à chaud. Lorsque le projet est itéré et redémarré, les développeurs n'ont pas besoin de le redémarrer manuellement, car une fois que le conteneur Web détecte que le fichier change, il s'adaptera automatiquement à ces "modifications" et rechargera en interne. La fonction de publication à chaud des conteneurs Web est également basée sur la fonction de surveillance des fichiers, il faut donc admettre que l'émergence de la fonction de surveillance des fichiers est d'une grande importance pour le système de fichiers Java.
La surveillance des fichiers est motivée par des événements et le déclenchement des événements est une condition préalable à la surveillance. Les développeurs peuvent utiliser les 3 constantes littérales fournies par le type standardwatchEventKinds sous le package java.nio.file pour définir les types d'événements de surveillance. Il convient de noter que la surveillance des événements doit être enregistrée sur l'instance WatchService.
Surveillance des événements fournis par le type StandardwatchEventKinds:
Exemple complet de l'implémentation de la surveillance des fichiers à l'aide de la classe WatchService:
Importer 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.watchkey; importation; java.nio.file.watchService; / ** * Système de surveillance des fichiers * @Author HuangJiAwei * / classe publique WatchViewTest {public static void testwatch () {/ * Monitor Target Path * / PathTop = Paths.get ("c: // utilisateurs // Huangjiawawei // PATHTOP"); Essayez {/ * Créez un objet de surveillance de fichiers. * / WatchService watchService = filesystems.getDefault (). NewWatchService (); / * Enregistrez tous les types d'événements pour la surveillance des fichiers. * / path.register (watchService, standardwatchEventkinds.entry_create, standardwatchEventkinds.entry_delete, standardwatchEventkinds.entry_modify); / * Fichier de surveillance en boucle. * / while (true) {watchKey watchKey = watchService.Take (); / * Itérer sur tous les fichiers qui déclenchent l'événement * / for (watchEvent <?> Event: watchKey.pollevents ()) {System.out.println (event.context (). ToString () + "Type d'événement:" + event.kind ()); } if (! watchKey.reset ()) {return; }}} catch (exception e) {e.printStackTrace (); }} public static void main (String [] args) {testwatch (); }} Grâce aux exemples de programme ci-dessus, nous pouvons voir que l'utilisation de l'interface WatchService pour la surveillance des fichiers est très simple et pratique. Tout d'abord, nous devons définir le chemin de surveillance cible, puis appeler la méthode NewWatchService () de type de système de fichiers pour créer un objet WatchService. Ensuite, nous devons utiliser la méthode Register () de l'interface de chemin pour enregistrer l'instance WatchService et le surveillant des événements. Lorsque toutes ces couches de travail de base sont prêtes, nous écrivons un cycle de surveillance périphérique en temps réel. Enfin, itérez sur WatchKey pour obtenir tous les fichiers qui déclenchent des événements de surveillance.
Maintenant, je connais enfin le principe de base de la soi-disant mise à jour de Dev-Tools à Spring Boot! Il s'avère que JDK fournit de telles API.
Résumer
Ce qui précède est l'analyse de code du JDK 7 nouvelles fonctionnalités brèves introduction par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!