[JAVA] Autoboxing, das ich als NullPointerException im Kurzvergleich gelernt habe

String hoge = "hoge";
String fuga = "hogehoge";
fuga = fuga.substring(4); // << "hoge"

//
boolean isEqual1 = hoge == fuga;

//Es wird oft im Vergleich von String gesagt. Wenn Sie im Vergleich `==` verwenden, wird die Referenz ** für ** Referenztyp wie Wrapper verglichen, und der Wert ** wird für ** primitiven Typ verglichen. Da die Referenzziele verglichen werden, wird es "falsch". Da die Werte verglichen werden, wird es "wahr".
boolean isEqual2 = hoge.equals(fuga);
System.out.print(isEqual2);

Selbst wenn Sie zum Vergleichen von Shorts == verwenden, werden die Werte im Bereich von "-128 bis 127" verglichen.

Ich habe versehentlich Short (Short Wrapper) mit == verglichen, aber ich habe es nicht auf halbem Weg bemerkt, ich habe es bemerkt, als der Wert ungefähr 200 erreichte. Ich wusste es nicht ... aber du solltest "gleich" verwenden.

Boolean isEquala = null;
// 「-128~Da es außerhalb des Bereichs von "127" liegt, wird es "falsch".
Short a1 = -129;
Short a2 = -129;
isEqual = a1 == a2;
// 「-128~Da es im Bereich von "127" liegt, wird es "wahr".
Short b1 = -128;
Short b2 = -128;
isEqual = b1 == b2;
// 「-128~Da es im Bereich von "127" liegt, wird es "wahr".
Short c1 = 127;
Short c2 = 127;
isEqual = c1 == c2;
// 「-128~Da es außerhalb des Bereichs von "127" liegt, wird es "falsch".
Short d1 = 128;
Short d2 = 128;
isEqual = d1 == d2;

Wahrscheinlich aus dem gleichen Grund wie Integer.

Weil "Integer.valueOf ()" anstelle von "new Integer ()" von int zu Integer verwendet wird. Dies gibt (derzeit) zwischengespeicherte Ganzzahlen im Bereich -128-127 zurück, sodass sie in diesem Bereich dieselbe Instanz sind. Selbst wenn sie mit == verglichen werden, sind sie daher gleich. Java-Typ-Memo (Hishidamas Java-Typ-Memo)

NullPointerException, auch wenn im Kurzvergleich == verwendet wird

Ich war überrascht ... ich verstehe nicht

Short a = null;
Boolean isOne = null;
//NullPointerException wie erwartet
isOne = a.equals(1);
//Werden Sie "wahr", wie Sie sich vorstellen können
isOne = a == null;
//Überraschenderweise bekomme ich eine NullPointerException!
isOne = a == 1;
//Dies ist "false" anstelle einer NullPointerException
isOne = a == new Short("1");
//Dies wird auch "falsch" sein
Integer i = 1;
isOne = a == new Short(i.shortValue());

Es gibt eine Boxtransformation, die primitive Typen und Wrapper-Klassen automatisch transformiert

Es scheint, dass es ab JDK1.5 möglich wurde, und ich wusste nicht, dass es einen solchen Namen gibt.

//Gewöhnliche Zuordnung zur Wrapper-Klasse
Short a1 = new Short("1000");
//Autoboxing: Automatische Konvertierung primitiver Typen in Wrapper-Klassen
Short a2 = 1000; //Wenn ich die Klassendatei rückwärts kompiliere, sieht es so aus>> Short a2 = Short.valueOf((short)1000);

//Gewöhnliche Zuordnung zum primitiven Typ
short b1 = a1.shortValue();
//Unboxing: Automatische Konvertierung von Wrapper-Klassen in primitive Typen
short b2 = a2; //Wenn ich die Klassendatei rückwärts kompiliere, sieht es so aus>> short b2 = a2.shortValue();

Ich habe versucht, die Stelle, an der "==" im Kurzvergleich verwendet wurde, rückwärts zu kompilieren, um festzustellen, ob die Box konvertiert wurde

Es scheint, dass Sie erkennen können, ob es durch umgekehrtes Kompilieren konvertiert wurde. Also habe ich versucht, es rückwärts zu kompilieren.

Wenn ich die kompilierte Version rückwärts kompiliere, wird sie einfach durch die Konvertierungsmethode ersetzt ... Java-Typ-Memo (Hishidamas Java-Typ-Memo)

isOne = a.equals(1);
//↑ Wenn Sie dies kompilieren und rückwärts kompilieren, wird es so sein ↓
isOne = Boolean.valueOf(a.equals(Integer.valueOf(1)));

isOne = a == null;
//↑ Wenn Sie dies kompilieren und rückwärts kompilieren, wird es so sein ↓
isOne = Boolean.valueOf(a == null);

isOne = a == 1;
//↑ Wenn Sie dies kompilieren und rückwärts kompilieren, wird es so sein ↓
isOne = Boolean.valueOf(a.shortValue() == 1);

isOne = a == new Short("1");
//↑ Wenn Sie dies kompilieren und rückwärts kompilieren, wird es so sein ↓
isOne = Boolean.valueOf(a == new Short("1"));

Integer i = 1;
isOne = a == new Short(i.shortValue());
//↑ Wenn Sie dies kompilieren und rückwärts kompilieren, wird es so sein ↓
Integer i = Integer.valueOf(1);
isOne = Boolean.valueOf(a == new Short(i.shortValue()));

Der Vergleich von Short mit einem primitiven Typ durch == führt zu einer NullPointerException, da shortValue () ausgeführt wird!

a == 1;
//↑ wird so ↓
Boolean.valueOf(a.shortValue() == 1);

Ich verstehe den Grund für NullPointerException, aber warum ist es "shortValue ()" nur, wenn es eine Literalzahl ist? a == new Short (" 1 "); wird nicht Boolean.valueOf (a.shortValue () == new Short (i.shortValue ())) sein;?

@Swordone hat mir so eine Frage gestellt.

Wenn Sie die Wrapper-Klasse (Referenztyp) mit dem primitiven Typ vergleichen, wird das Autoboxing durchgeführt Wenn das Vergleichsziel ein Referenztyp ist, wird .shortValue () nicht ausgeführt und es tritt keine NullPointerException auf.

//Dies liegt beispielsweise daran, dass das Vergleichsziel ein primitiver Typ ist
boolean isOne = a == (short) 1;
//Auto Boxing wird durchgeführt(↓ Kompilierungsergebnis umkehren)
boolean isOne = a.shortValue() == 1;