La valeur nulle ou nulle de la chaîne est jugée
Pendant le processus de développement, je rencontre souvent les mauvais usages suivants:
1. Utilisation des erreurs 1:
if (name == "") {// faire quelque chose} 2. Utilisation des erreurs 2:
if (name.equals ("")) {// faire quelque chose}
3. Utilisation d'erreur Trois:
if (! name.equals ("")) {// faire quelque chose}
Expliquons:
L'utilisation d'erreur ci-dessus 1 est l'erreur la plus probable que les débutants font et sont les moins susceptibles d'être découvertes, car leur syntaxe elle-même est bien, et le compilateur Java ne signale pas d'erreur lors de la compilation. Cependant, cette condition peut provoquer un bogue dans le programme pendant l'exécution et ne sera jamais vraie. En d'autres termes, les instructions du bloc IF ne seront jamais exécutées.
L'utilisation susmentionnée 2 et l'utilisation 3 sont écrites, y compris des erreurs que de nombreux maîtrises de Java sont également faciles à faire. Pourquoi est-ce mal? Peut-être que vous serez perplexe.
Oui, leur écriture est correcte, mais il y a un manque de condition de jugement nulle. Imaginez, que se passera-t-il si name = null? La conséquence est que votre programme lèvera une exception NullPointerException, le système sera suspendu et ne fournira plus de services normaux.
Bien sûr, si vous avez déjà fait un jugement nul sur le nom, l'exception est.
La bonne façon de l'écrire devrait d'abord ajouter la condition de nom! = NULL, comme:
if (name! = null &&! name.equals ("")) {// faire quelque chose}ou
if (! "". Equals (name)) {// écrivez "" devant lui, de sorte que peu importe si le nom est nul ou non, il n'y aura pas d'erreur. // faire quelque chose}
Ici, donnons un exemple simple:
TestNullorempty.java
classe publique test {public static void main (String args []) {String value = null; TestNullorempty (valeur); value = ""; TestNullorempty (valeur); value = ""; TestNullorempty (valeur); Value = "Hello Me"; TestNullorempty (valeur); } static void testNullorempty (string value) {if (value == null) {System.out.println ("valeur est null"); } else if ("" .equals (valeur)) {System.out.println ("La valeur est vide mais pas nul"); } else {System.out.println ("valeur est /" "+ valeur +" / ""); } if (value == "") {// souscription de ng // N'utilisez pas cette écriture}}} Compiler l'exécution:
c: /> javac testnullorempty.javac: /> java testnullorempty
La valeur est null.Value est vide mais pas null.Value est "" La valeur est "Bonjour moi!"
Comparez les adresses de chaîne égales
package com; classe publique a {/ ** * @param args * / public static void main (String [] args) {String a = "Bonjour"; String b = "he"; String c = a.substring (0, 2); System.out.println (b.equals (c)); // true System.out.println (b == C); // Faux String D = new String ("Hello"); System.out.println (D.Equals (A)); // Vrai System.out.println (D == A); // Faux String E = new StringBuilder ("Hello"). ToString (); System.out.println (e.equals (a)); // true system.out.println (e == a); // false system.out.println (e.equals (d)); // true system.out.println (e == d); // false string f = "hello"; System.out.println (f.equals (a)); // true system.out.println (f == a); // true system.out.println (f == "hello"); // true System.out.println (f == "hell" + "o"); // true string g = b + "llo";; System.out.println (g == f); // false chaîne h = "he" + "llo"; System.out.println (h == f); // true}}Résumer:
1. La chaîne de nouveau est de réaffecter la mémoire, les chaînes ne sont pas partagées et plusieurs nouvelles ne sont pas partagées.
2. Les chaînes et les variables de chaîne statiques qui sont épissées ou interceptées ne sont pas partagées via des fonctions de chaîne.
3. Il existe deux situations pour les chaînes obtenues par des signes plus.
Un "he" + "llo" est une chaîne statique, qui est partagée
B String a = "he"; A + "LLO" n'est pas une chaîne statique, elle n'est pas partagée