Bedienertyp

Vorbestimmt ** Symbol für die Durchführung einer vorgegebenen Verarbeitung **
Vom Operator verarbeitete Variablen sind ** inaktiv (Operator) **
Arithmetischer Operator
Aufgabenverwalter
Beziehungsoperator
Logischer Operator
Bitoperator

Arithmetischer Operator

+ Betreiber

- Benimmt sich je nach Operantentyp unterschiedlich
Wenn einer der Operanden eine Zeichenfolge ist, wird ** + als Zeichenfolge verknüpft **
Wenn eines kein Objekt ist, ** konvertiere es mit der toString-Methode in einen String und kombiniere es **

import java.time.LocalDateTime;

public class Main {
    public static void main(String[] args) throws Exception {
    System.out.println("a"+LocalDateTime.now()); //a2020-10-29T…
    }
}

Numerische und nicht objektbezogene + Operationen sind nicht möglich
Wenn Sie die Zeichen mit + kombinieren
Da 3 Zeichenfolgen der ursprünglichen Zeichenfolge, der zu verkettenden Zeichenfolge und der Ergebniszeichenfolge generiert werden, kann die Speicherbereinigung erhöht werden. ..
→ ** Verwenden Sie die Append-Methode der StringBuilder-Klasse **, um eine Zeichenfolge variabler Länge darzustellen, die eine bestimmte Größe sichert, sodass Sie die Zeichenfolge im reservierten Bereich frei ändern können.
→ ** Es werden weniger Instanzen erstellt und zerstört! ** **.
Wenn die Anzahl der Zeichen im Voraus geschätzt werden kann, optimieren Sie den Prozess der eindeutigen Angabe der Größe und der Erweiterung der Zeichenfolge sowie der Neuzuweisung des Speichers zum Zeitpunkt der Instanziierung
In der neuesten Java-Version wird der Operator + intern in StringBuilder konvertiert. Bei einer einmaligen Verkettung von Zeichenfolgen ist der Operator + in Ordnung.

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        var builder = new StringBuilder();
        for (var i=0;  i<100000; i++){
        	builder.append("mohu");
            //result += "mohu" ; 
        	}
        var result = builder.toString();
        System.out.println(result);
    }
}

Inkrement-Operator

++ i: ** Präfixaddition (Addition vor Substitution) **
- i = 3; j = ++i → i = 4 j = 4
i ++: ** Nachaddition (Addition nach Substitution) **
- i = 3; j = i++ → i = 4 j = 3

Achten Sie beim Teilen auf den Typ

/: Teilen
- 6 / 3 = 2 *%: Überschuss (zu viel)
- 10 % 4 = 2

//NG **Da es sich um eine Berechnung zwischen Ganzzahlen handelt, ist das Ergebnis auch eine Ganzzahl**
System.out.println( 3 / 4 ); //0

//NG **Es ist der Zeitpunkt der Berechnung, der in eine ganze Zahl umgewandelt wird!**
double result = 3 / 4 ;
System.out.println(result); //0.0

//OK **Verdoppeln Sie explizit einen der Operanten
System.out.println( 3d / 4 ); //0.75

Behandlung von Null

//NG **Die Beschleunigung der Konstanten 0 ist ein Fehler**
System.out.println( 5 / 0 ); //0

//OK **Operant ist Gleitkomma**
System.out.println( 5d / 0 ); //Infinity(Unendlichkeit)

//OK 
System.out.println( 5d % 0 ); //NaN (Not a number:Nicht numerisch)

Achtung in der Gleitkomma-Arithmetik

System.out.println(Math.floor(( 0.7 + 0.1 )*10 )); //7.0

Der Gleitkommatyp wird binär berechnet
Abnahme 0.1 → Binär ist ein unendlich kreisförmiger Bruch
→ ** BigDecimal-Klasse verwenden **
Intern wird der Dezimalpunkt für ganze Zahlen und eine kleine Anzahl von Glückspositionen separat verwaltet.
(Hinweis) Verwenden Sie beim Instanziieren ** Zeichenfolgen anstelle von Gleitkomma-Literalen! ** **.
var bd1 = neues BigDecimal (0.7); // NG-Beispiel

import java.util.*;
import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) throws Exception {
    var bd1 = new BigDecimal("0.7");
    var bd2 = new BigDecimal("0.1");
    var bd3 = new BigDecimal("10");
    System.out.println(bd1.add(bd2).multiply(bd3)); //8.0
    }
}

Aufgabenverwalter

Das Verhalten unterscheidet sich zwischen Basistyp und Referenztyp
Da der Wert des Basistyps so gespeichert wird, wie er in der Variablen enthalten ist, wirkt sich die kopierte Variable (y) auch dann nicht aus, wenn die ursprüngliche Variable geändert wird.
Im Referenztyp wird die Adresse im Speicher, in dem der Wert gespeichert ist, in der Variablen gespeichert, sodass die kopierte Adresse auch auf das Objekt mit derselben Adresse zeigt.

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
    var x = 1;
    var y = x;
    x += 10;
    System.out.println(x); //11
    System.out.println(y); //1

    var builder1 = new StringBuilder("abc");
    var builder2 = builder1; //Adresse kopieren
    builder1.append("de");
    System.out.println(builder1.toString()); //abcde
    System.out.println(builder2.toString()); //abcde
    }
}

Substitution zu konstant

Kann im Basistyp nicht geändert werden
Im Referenztyp kann die Konstante selbst nicht neu geschrieben werden, sondern nur der Inhalt kann neu geschrieben werden, ohne den Bandauswurf zu ändern.
Der String-Typ ist unveränderlich, daher kann sein Wert nicht geändert werden

//NG Beispiel
final int VALUE = 10;
VALUE = 15;

final int[] VALUES = { 10, 20, 30 } ;
//NG **Die Konstante selbst kann nicht neu zugewiesen werden
VALUES = new int[] { 10, 20, 30 } ; 

//OK
VALUES[0] = 100;
System.out.println(Arrays.toString(VALUES));  //[100, 20, 30]

Beziehungsoperator (Vergleichsoperator)

Vergleichen Sie beide Seiten und geben Sie true / false zurück
Identität
Äquivalenz

Unterschied zwischen == und gleich

== Operator vergleicht ** Operantenidentität (= Referenz, die den Wert speichert) **, falsch für verschiedene Objekte
In dem Basistyp, in dem der Wert selbst gespeichert ist, gibt es kein Problem, da der Wert das Vergleichsziel ist.
Die Methode equals ** vergleicht die Werte von Objekten **

var builder1 = new StringBuilder("neko");
var builder2 = new StringBuilder("neko");
System.out.println(builder1 == builder2); //false

var str1 = "neko";
var str2 = "neko";
System.out.println(str1 == str2); //true
System.out.println(str1 == "ne" + "ko"); //wahre Zeichenfolge(String-Objekt)Im Fall von wird davon ausgegangen, dass es sich um denselben Wert handelt

Vergleich der schwebenden Fraktionen

BigDeciamal
Wenn das Bewertungsergebnis 0 ist, sind der numerische Wert des Objekts und das Argument gleich, 1 ist das größere Argument, -1 ist das kleinere Argument
(Hinweis) Die Methode equals in BigDeciamal beurteilt bis zu gültigen Zahlen
- 1.0 ≠ 1.00
→ ** Verwenden Sie die compareTo ** -Methode
Rundungseinheit verwenden
EPSILON: Fehlertoleranz
True, wenn der Unterschied im EPSILON-Bereich liegt

System.out.println( 0.2*3 == 0.6 ); //false

//BigDecimal
import java.util.*;
import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) throws Exception {
    var bd1 = new BigDecimal("0.2");
    var bd2 = new BigDecimal("4");
    var bd3 = new BigDecimal("0.8");
    System.out.println(bd1.multiply(bd2).compareTo(bd3)); //0
    }
}

//Rundungseinheit verwenden
public class Main {
    public static void main(String[] args) throws Exception {
    final double EPSILON = 0.00001;  //Garantiert bis zum 5. Platz
    var x = 0.2 * 4;
    var y = 0.8;
    System.out.println(Math.abs(x - y) < EPSILON); //true
    }
}

Sequenzvergleich

Verwenden Sie die equals-Methode der Array-Klasse
Verschachteltes Array ist die Methode ** deepEquals ** Die Methode * ** Compare ** (Java 9 oder höher) vergleicht die Einfügungen in der Reihenfolge des ersten Elements. Wenn ein großes / kleines Element vorhanden ist, wird die Gesamtgröße bestätigt.

public class Main {
    public static void main(String[] args) throws Exception {
    var data1 = new String[] { "a", "b", "c" };
    var data2 = new String[] { "a", "b", "c" };
    
    var data3 = new int[][] {
      { 1, 2, 3 },
      { 4, 5, 6 },
      { 7, 8, 9 },
    };
    var data4 = new int[][] {
      { 1, 2, 3 },
      { 4, 5, 6 },
      { 7, 8, 9 },
    };
    
    System.out.println(Arrays.equals(data1, data2)); //true
    System.out.println(Arrays.deepEquals(data3, data4)); //true
    
    }
}

//Methode vergleichen
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
    var data1 = new int[] {1, 3};
    var data2 = new int[] {1, 2, 3};
    var data3 = new int[] {1, 2, 3};
    var data4 = new int[] {1, 3, 1};
    var data5 = new int[] {0, 0, 6};
    var data6 = new int[] {6, 0, 0};
    System.out.println(Arrays.compare(data1, data2)); //1
    System.out.println(Arrays.compare(data3, data4)); //-1
    System.out.println(Arrays.compare(data2, data3)); //0
    System.out.println(Arrays.compare(data3, data5)); //1
    System.out.println(Arrays.compare(data3, data6)); //-1
    }
}

Bedingter Operator (ternärer Operator)

(Bedingter Ausdruck) Ausdruck A: Ausdruck B.
Beim Vergleich von A und B (Gleichung A: Ausdruck B) müssen die Ausdrücke A und B einen Wert zurückgeben

public class Main {
    public static void main(String[] args) throws Exception {

    var age = 20;
    System.out.println(age >= 20 ? "aufgewachsen" : "Kinder"); //aufgewachsen

    }
}

Logischer Operator

Mehrere bedingte Ausdrücke können logisch kombiniert werden, um komplexere bedingte Ausdrücke auszudrücken
&&: ** Logisches Produkt ** (wahr, wenn beide wahr sind)
- ||：Logische Summe(Richtig, wenn man wahr ist)
^: ** Exklusive logische Summe ** (wahr, wenn nur eine wahr ist) *!: ** Negativ ** (falsch, wenn Ausdruck wahr ist, wahr, wenn Ausdruck falsch ist)

Abkürzungsbetrieb (Kurzschlussbetrieb)

** Berechnungen, bei denen nur der linke Ausdruck ausgewertet wird ** und der rechte nicht ausgewertet wird
Wenn im logischen Produkt die linke Seite falsch ist, ist sie unabhängig von der rechten Seite falsch
In logischer Summe, wenn die linke Seite wahr ist, wahr, unabhängig von der rechten Seite
** & und | Operatoren verknüpfen nicht **
Wird für die Nullprüfung verwendet
Wenn null, wird die Methode meetsWith nicht aufgerufen
Das Setzen von && auf & führt zu einem NullPoiintException-Fehler

//Nullprüfung
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {

    String str = "http://hoge";
    if (str != null && str.startsWith("http://")) {
    // if(str.startsWith("http://")) {
      System.out.println("「http://Es beginnt mit "...".");  //「http://Es beginnt mit "...". 
    }
  }
}

//Eine Nullprüfung ist auch mit der folgenden Methode möglich
 if(!Objects.isNull(str)&&str.startsWith("http://"))
        {...}
 if(Objects.nonNull(str)&&str.startsWith("http://"))
        {...}

Bitoperator

Bit logischer Operator

Konvertieren Sie eine Ganzzahl in eine Binärzahl und führen Sie dann für jede Ziffer eine logische Operation aus
Wenn beide logischen Produkte 1 sind, ist das Ergebnis auch 1 (wahr)
Gibt das Ergebnis der Operation zurück, die wieder in eine Dezimalzahl konvertiert wurde.
Negative Operation invertiert Bits
Negativ von 0101 → (Umkehrung) 1010 → (Ergebnis) −6 // Das Ergebnis ist nicht 10!
** Invertieren Sie das Vorzeichen für positiv oder negativ! ** **.
Negative Zahlen in Bits sind "Absolutwerte, die durch Addition von 1 nach Bitinversion erhalten werden".
0101 plus 1 0110 (binär) → Das Ergebnis ist -6 (dezimal) mit hinzugefügtem Vorzeichen.

Bitverschiebungsoperator

Berechnet eine Dezimalzahl als Binärzahl und verschiebt einen bestimmten Satz nach links oder rechts **
1010 (binär) → Verschiebung nach links 2 → 101000 → Ergebnis 40 (dezimal)
Arithmetische Verschiebung (>>): Verschiebung, die das höchstwertige Bit (Vorzeichen) beibehält
Logische Verschiebung (>>>): Füllt mit 0, unabhängig vom höchstwertigen Bit

Bedienerpriorität

Beschreibe explizit die Priorität in ()
Repräsentatives Beispiel

[Höchste Priorität]
Streit, [] , .
++(Nachtrag), --(Nachtrag)
++(Präfix), +(einstellig), ! , ~
* , / , %
+ , -
> , >=
== , !=
&
^
&&
?:
= , += , &=

Gesetz der Verbindung

Für die gleiche Priorität gibt es Links-Join (links → rechts) und Rechts-Join (rechts → links).
Right Join ist nur ** Zuweisungsoperator **
- j = i +=10
- j = ( i +=10 )
= Und + = haben die gleiche Priorität und sind rechtsverbunden, also bewerten Sie von rechts
Das Ergebnis der Addition von 10 wird j zugewiesen

[Java] Zusammenfassung der Operatoren (Operator)

Bedienertyp

Arithmetischer Operator

+ Betreiber

Inkrement-Operator

Achten Sie beim Teilen auf den Typ

Behandlung von Null

Achtung in der Gleitkomma-Arithmetik

Aufgabenverwalter

Substitution zu konstant

Beziehungsoperator (Vergleichsoperator)

Unterschied zwischen == und gleich

Vergleich der schwebenden Fraktionen

Sequenzvergleich

Bedingter Operator (ternärer Operator)

Logischer Operator

Abkürzungsbetrieb (Kurzschlussbetrieb)

Bitoperator

Bit logischer Operator

Bitverschiebungsoperator

Bedienerpriorität

Gesetz der Verbindung