Type d'opérateur

Symbole prédéterminé ** pour effectuer un traitement prédéterminé **
Les variables traitées par l'opérateur sont ** inactives (opérateur) **
Opérateur arithmétique
Opérateur d'assignation
Opérateur de relation
Opérateur logique
Opérateur de bits

Opérateur arithmétique

+ Opérateur

- Se comporte différemment selon le type d'opérant
Si l'un des opérandes est une chaîne, ** + joint en tant que chaîne **
Si l'un d'entre eux n'est pas un objet, ** convertissez-le en chaîne avec la méthode toString et combinez-le **

import java.time.LocalDateTime;

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

Les opérations numériques et non-objet + ne sont pas possibles
Si vous combinez les caractères avec +
Puisque 3 chaînes de chaîne de la chaîne d'origine, la chaîne à concaténer et la chaîne de résultat sont générées, le garbage collection peut être augmenté. ..
→ ** Utilisez la méthode append de la classe StringBuilder ** pour représenter une chaîne de caractères de longueur variable qui sécurise une certaine taille, afin que vous puissiez changer librement la chaîne de caractères dans la zone réservée.
→ ** Moins d'instances sont créées et détruites! ** **
Si la quantité de caractères peut être estimée à l'avance, rationalisez le processus consistant à indiquer clairement la taille au moment de l'instanciation, à étendre la chaîne de caractères et à réallouer la mémoire.
Dans la dernière version de Java, l'opérateur + est converti en interne en StringBuilder, donc dans le cas d'une concaténation de chaînes en un seul coup, l'opérateur + est OK.

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);
    }
}

Opérateur d'incrément

++ i: ** Ajout de préfixe (ajout avant substitution) **
- i = 3; j = ++i → i = 4 j = 4
i ++: ** Post-ajout (ajout après substitution) **
- i = 3; j = i++ → i = 4 j = 3

Faites attention au type lors de la division

/: Diviser
- 6 / 3 = 2 *%: Surplus (trop)
- 10 % 4 = 2

//NG **Puisqu'il s'agit d'un calcul entre des entiers, le résultat est également un entier**
System.out.println( 3 / 4 ); //0

//NG **C'est le timing du calcul qui est converti en entier!**
double result = 3 / 4 ;
System.out.println(result); //0.0

//OK **Explicitement doubler l'un des opérants
System.out.println( 3d / 4 ); //0.75

Traitement de zéro

//NG **L'accélération de la constante 0 est une erreur**
System.out.println( 5 / 0 ); //0

//OK **L'opérant est à virgule flottante**
System.out.println( 5d / 0 ); //Infinity(Infini)

//OK 
System.out.println( 5d % 0 ); //NaN (Not a number:Non numérique)

Attention en arithmétique flottante

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

Le type à virgule flottante est calculé en binaire
Decline 0.1 → Binary est une fraction infiniment circulaire
→ ** Utiliser la classe BigDecimal **
En interne, le point décimal est géré séparément pour les entiers et un petit nombre de positions de chance.
(Remarque) Utilisez ** des chaînes au lieu de littéraux à virgule flottante lors de l'instanciation! ** **
var bd1 = new BigDecimal (0.7); // Exemple NG

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
    }
}

Opérateur d'assignation

Le comportement diffère entre le type de base et le type de référence
Puisque la valeur du type de base est stockée telle quelle dans la variable, la variable copiée (y) n'affecte pas même si la variable d'origine est modifiée.
Dans le type de référence, l'adresse dans la mémoire qui stocke la valeur est stockée dans la variable, de sorte que celle copiée pointe également vers l'objet avec la même adresse.

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; //Copier l'adresse
    builder1.append("de");
    System.out.println(builder1.toString()); //abcde
    System.out.println(builder2.toString()); //abcde
    }
}

Substitution à constante

Ne peut pas être modifié dans le type de base
Dans le type de référence, la constante elle-même ne peut pas être réécrite, mais seul le contenu peut être réécrit sans changer l'éjection de bande.
Le type de chaîne est immuable, donc sa valeur ne peut pas être modifiée

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

final int[] VALUES = { 10, 20, 30 } ;
//NG **La constante elle-même ne peut pas être réaffectée
VALUES = new int[] { 10, 20, 30 } ; 

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

Opérateur de relation (opérateur de comparaison)

Comparez les deux côtés et retournez vrai / faux
Identité
Équivalence

Différence entre == et égal

== L'opérateur compare ** l'identité de l'opérant (= référence qui stocke la valeur) **, false pour différents objets
Dans le type de base qui stocke la valeur elle-même, il n'y a pas de problème car la valeur est la cible de comparaison.
La méthode equals ** compare les valeurs des objets **

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"); //vraie chaîne(Objet String)Dans le cas de, il est considéré comme identique à la même valeur

Comparaison des fractions flottantes

BigDeciamal
Si le résultat du jugement est 0, la valeur numérique de l'objet et l'argument sont égaux, 1 est le plus grand argument, -1 est le plus petit argument
(Remarque) La méthode égale dans BigDeciamal juge jusqu'à des nombres valides
- 1.0 ≠ 1.00
→ ** Utilisez la méthode compareTo **
Utiliser l'unité d'arrondi
EPSILON: Tolérance d'erreur
Vrai si la différence se situe dans la plage EPSILON

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
    }
}

//Utiliser l'unité d'arrondi
public class Main {
    public static void main(String[] args) throws Exception {
    final double EPSILON = 0.00001;  //Garanti jusqu'à la 5e place
    var x = 0.2 * 4;
    var y = 0.8;
    System.out.println(Math.abs(x - y) < EPSILON); //true
    }
}

Comparaison de séquence

Utilisez la méthode equals de la classe Array
Le tableau imbriqué est la méthode ** deepEquals ** La méthode * ** Compare ** (Java 9 ou version ultérieure) compare les insertions dans l'ordre à partir du premier élément, et s'il y a un élément grand / petit, la taille globale est confirmée.

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
    
    }
}

//Comparer la méthode
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
    }
}

Opérateur conditionnel (opérateur ternaire)

(Expression conditionnelle)? Expression A: Expression B
Lors de la comparaison de A et B (équation A: Expression B) Les expressions A et B doivent renvoyer une valeur

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

    var age = 20;
    System.out.println(age >= 20 ? "adulte" : "les enfants"); //adulte

    }
}

Opérateur logique

Plusieurs expressions conditionnelles peuvent être combinées logiquement pour exprimer des expressions conditionnelles plus complexes
&&: ** Produit logique ** (vrai lorsque les deux sont vrais)
- ||：Somme logique(Vrai quand on est vrai)
^: ** Somme logique exclusive ** (vrai quand un seul est vrai)
!: ** Négatif ** (faux quand l'expression est vraie, vrai quand l'expression est fausse)

Opération de raccourci (opération de court-circuit)

** Calculs où seule l'expression de gauche est évaluée ** et la droite n'est pas évaluée
En produit logique, lorsque le côté gauche est faux, il est faux quel que soit le côté droit
En somme logique, lorsque le côté gauche est vrai, vrai quel que soit le côté droit
** Les opérateurs & et | ne raccourcissent pas **
Utilisé pour le contrôle nul
Si null, la méthode startsWith ne sera pas appelée
La définition de && sur & entraîne une erreur NullPoiintException

//chèque nul
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://Cela commence par "...".");  //「http://Cela commence par "...". 
    }
  }
}

//Le contrôle nul est également possible avec la méthode suivante
 if(!Objects.isNull(str)&&str.startsWith("http://"))
        {...}
 if(Objects.nonNull(str)&&str.startsWith("http://"))
        {...}

Opérateur de bits

Opérateur logique de bits

Convertissez un entier en nombre binaire puis effectuez une opération logique pour chaque chiffre
Lorsque les deux produits logiques sont 1, le résultat est également 1 (vrai)
Renvoie le résultat de l'opération reconverti en décimal.
L'opération négative inverse les bits
Négatif de 0101 → (inversion) 1010 → (résultat) −6 // Le résultat n'est pas 10!
** Inversez le signe indiquant positif ou négatif! ** **
Les nombres négatifs en bits sont des "valeurs absolues obtenues en ajoutant 1 après l'inversion de bit"
0101 plus 1 0110 (binaire) → Le résultat est -6 (décimal) avec le signe ajouté.

Opérateur de décalage de bits

Calcule un nombre décimal sous forme de nombre binaire et déplace une phrase spécifiée vers la gauche ou la droite **
1010 (binaire) → Maj gauche 2 → 101000 → Résultat 40 (décimal)
Décalage arithmétique (>>): Décalage qui garde le bit le plus significatif (signe)
Décalage logique (>>>): se remplit de 0 quel que soit le bit le plus significatif

Priorité de l'opérateur

Décrivez explicitement la priorité entre ()
Exemple représentatif

[Priorité la plus élevée]
argument, [] , .
++(Postscript), --(Postscript)
++(Préfixe), +(unaire), ! , ~
* , / , %
+ , -
> , >=
== , !=
&
^
&&
?:
= , += , &=

Loi de connexion

Pour la même priorité, il y a jointure gauche (gauche → droite) et jointure droite (droite → gauche)
La jointure à droite est uniquement ** opérateur d'affectation **
- j = i +=10
- j = ( i +=10 )
= Et + = ont la même priorité et sont joints à droite, alors évaluez à partir de la droite
Le résultat de l'ajout de 10 est attribué à j

[Java] Résumé des opérateurs (opérateur)

Type d'opérateur

Opérateur arithmétique

+ Opérateur

Opérateur d'incrément

Faites attention au type lors de la division

Traitement de zéro

Attention en arithmétique flottante

Opérateur d'assignation

Substitution à constante

Opérateur de relation (opérateur de comparaison)

Différence entre == et égal

Comparaison des fractions flottantes

Comparaison de séquence

Opérateur conditionnel (opérateur ternaire)

Opérateur logique

Opération de raccourci (opération de court-circuit)

Opérateur de bits

Opérateur logique de bits

Opérateur de décalage de bits

Priorité de l'opérateur

Loi de connexion