Spiegazione dettagliata degli operatori e del loro uso in Java

Nel contenuto precedente abbiamo imparato come definire e inizializzare variabili. Lo scopo della definizione delle variabili è quello di operare sui dati. Il linguaggio Java ci fornisce simboli di codice specifici per operare su questi dati, noto come "operatori".

Secondo l'uso degli operatori, possiamo classificarli in diverse categorie:

Operatori aritmetici

Operatori di assegnamento

Operatori di incrementazione e decrementazione

operatore logico

operatore di relazione

Operatori bitwise

Non preoccuparti, sono solo simboli che ci aiutano a gestire i dati delle operazioni. Di seguito, con esempi di codice, illustreremo l'uso di questi operatori.

1. Operatori aritmetici

Gli operatori aritmetici sono operazioni aritmetiche specifiche per variabili numeriche come addizione, sottrazione, moltiplicazione, divisione e calcolo del resto:

Aggiunta: +
Sottrazione: -
Moltiplicazione: *
Divisione: /
Calcolo del resto: %

public class OperatorsDemo {
 public static void main(String[] args) {
 int num1 = 100;
 int num2 = 20;
 	// Aggiunta
 System.out.println("num1 + num2: " + (num1 + num2) );
 // Sottrazione
 	System.out.println("num1 - num2: " + (num1 - num2) );
 // Moltiplicazione
 	System.out.println("num1 * num2: " + (num1 * num2) );
 // Divisione
 	System.out.println("num1 / num2: " + (num1 / num2) );
 // Calcolo del resto
 	System.out.println("num1 % num2: " + (num1 % num2) );
 }
}

Risultato di output:

num1 + num2: 120
num1 - num2: 80
num1 * num2: 2000
num1 / num2: 5
num1 % num2: 0

2. Operatori di assegnamento

Come la maggior parte dei linguaggi di programmazione, Java utilizza l'operatore '=' per eseguire l'operazione di assegnazione. Questa operazione assegna il risultato del calcolo a destra (noto come valore destro) alla variabile a sinistra. Gli operatori di assegnazione in Java sono:

= (num2 = num1 )
+= (equivalente a num2 += num1) aggiunta
-= (equivalente a num2 -= num1) sottrazione
*= (equivalente a num2 *= num1) moltiplicazione
/= (equivalente a num2 /= num1) divisione
%= (equivalente a num2 %= num1) modulo

public class OperatorsDemo {
 public static void main(String[] args) {
 int num1 = 10;
 int num2 = 20;
 num2 = num1;
 System.out.println("= Output: "+num2);
 num2 += num1;
 System.out.println("+= Output: "+num2);
 num2 -= num1;
 System.out.println("-= Output: "+num2);
 num2 *= num1;
 System.out.println("*= Output: "+num2);
 num2 /= num1;
 System.out.println("/= Output: "+num2);
 num2 %= num1;
 System.out.println("%= Output: "+num2);
 }
}

Output:

= Output: 10
+= Output: 20
-= Output: 10
*= Output: 100
/= Output: 10
%= Output: 0

3. Operatori di incremento e decremento

Gli operatori di incremento e decremento, operano solo su una variabile, cambiando il valore della variabile.

num++ (equivalente a num = num + 1) incremento, principalmente per variabili numeriche, aumenta il valore della variabile di 1.
num—(equivalente a num = num -1) decremento, principalmente per variabili numeriche, riduce il valore della variabile di 1.

public class OperatorsDemo {
 public static void main(String[] args) {
 int num1=100;
 int num2=200;
 num1++;
 num2--;
 System.out.println("num1++ è: "+num1);
 System.out.println("num2-- è: "+num2);
 }
}

Output:

num1++ è: 101
num2-- è: 199

4. Operatore logico

Gli operatori logici, come si dice, sono usati per giudizi logici, i risultati delle operazioni sono valori di tipo booleano, ovvero true o false. Gli operatori logici uniformi includono

operatore logico	relazione logica
&&	e
`
！	non

b1 && b2: se b1 e b2 sono entrambi veri, b1 && b2 restituirà true, altrimenti restituirà false

b1 || b2: se b1 e b2 sono entrambi falsi, restituirà false, altrimenti restituirà true.

！b1: restituirà il valore opposto di b1, se b1 è false, restituirà true; se b1 è true, restituirà false

public class OperatorsDemo {
 public static void main(String[] args) {
 boolean b1 = true;
 boolean b2 = false;
 System.out.println("b1 && b2: " + (b1&&b2));
 System.out.println("b1 || b2: " + (b1||b2));
 System.out.println("!(b1 && b2): " + !(b1&&b2));
 }
}

Risultato di output:

b1 && b2: false
b1 || b2: true
!(b1 && b2): true

Cortocircuitamento logico:

In Java, gli operatori logici supportano l'operazione di cortocircuito, una volta che possiamo esprimere chiaramente il valore dell'intero'espressione, non è necessario calcolare il resto dell'espressione. Ad esempio, se dobbiamo determinare se un oggetto non è vuoto e il valore di ritorno di un suo metodo non è vuoto, possiamo farlo così:

if (object != null && object.someFunction() != null) {
 // fare qualcosa.
}

Se l'oggetto è vuoto, la prima parte dell'espressione object != null restituirà false, allora indipendentemente dal risultato dell'espressione object.someFunction() != null successiva, il valore finale sarà false. Il compilatore ottimizzerà automaticamente questa parte dell'operazione e non eseguirà object.someFunction() != null.

5. Operatore di relazione

usati per confrontare le dimensioni dei dati di due variabili, restituiscono un valore booleano, ovvero true o false

Gli operatori di relazione includono:

operatore di relazione	relazione
>	maggiore di
<	minore di
==	uguale a
!=	non uguale a
>=	maggiore o uguale a
<=	minore o uguale a

'==' e '!=' si applicano a tutti i tipi di valori e oggetti (cioè variabili di tipo base e variabili di tipo riferimento).

I simboli '>'、'<'、'>=' e '<=' non si applicano ai valori booleani, poiché hanno solo true o false, e maggiore o minore non hanno significato reale.

public class OperatorsDemo {
 public static void main(String[] args) {
 int num1 = 10;
 int num2 = 50;
 if (num1==num2) {
  System.out.println("num1 e num2 sono uguali");
 } else{
  System.out.println("num1 e num2 non sono uguali");
 }
 if( num1 != num2 ){
  System.out.println("num1 e num2 non sono uguali");
 } else{
  System.out.println("num1 e num2 sono uguali");
 }
 if( num1 > num2 ){
  System.out.println("num1 è maggiore di num2");
 } else{
  System.out.println("num1 non è maggiore di num2");
 }
 if( num1 >= num2 ){
  System.out.println("num1 è maggiore o uguale a num2");
 } else{
  System.out.println("num1 è minore di num2");
 }
 if( num1 < num2 ){
  System.out.println("num1 è minore di num2");
 } else{
  System.out.println("num1 non è minore di num2");
 }
 if( num1 <= num2){
  System.out.println("num1 è minore o uguale a num2");
 } else{
  System.out.println("num1 è maggiore di num2");
 }
 }
}

Risultato di output:

num1 e num2 non sono uguali
num1 e num2 non sono uguali
num1 non è maggiore di num2
num1 è minore di num2
num1 è minore di num2
num1 è minore o uguale a num2

6. Operatori bitwise

Gli operatori di bitwise si applicano agli oggetti binari di 'bit', possono essere utilizzati con i tipi di dati integer (int), long, short, char e byte, e durante l'operazione, eseguono operazioni algebriche booleane o di spostamento sui corrispondenti bit (0 o 1).

Operatori bitwise	Logica di calcolo
&	Operazione AND: per un bit, se entrambi gli operandi sono 1, il risultato di quel bit è 1, altrimenti è 0
`	`
^	Operazione XOR: per un bit, se i due operandi sono diversi, il risultato di quel bit è 1, altrimenti è 0
~	Operazione unaria: l'operatore di complemento bit a bit inverte ogni bit dell'operando
<<	Operatore bitwise di shift a sinistra: il primo operando viene spostato a sinistra di un numero di posizioni specificato dal secondo operando
>>	Operatore bitwise di shift a destra: il primo operando viene spostato a destra di un numero di posizioni specificato dal secondo operando
>>>	Operatore bitwise di shift a destra con riempimento di zero: il valore del primo operando viene spostato a destra di un numero di posizioni specificato dal secondo operando, e i bit vuoti sono riempiti con zero

La descrizione logica del calcolo può essere un po' oscura, possiamo capire meglio come gli operatori bitwise eseguono il calcolo attraverso esempi. Supponiamo che x sia uguale a 60; y è uguale a 13; allora la loro rappresentazione binaria e i risultati degli operatori bitwise sono come segue:

x = 0011 1100
y = 0000 1101
-----------------
x & y = 0000 1100
x | y = 0011 1101
x ^ y = 0011 0001
~x = 1100 0011 
x << 2 = 1111 0000
x >> 2 = 0000 1111
x >>> 2 = 0000 1111

Attenzione alla differenza tra >> e >>>:

L'operatore di shift a destra >>, se il valore dell'operazione è positivo, inserisce 0 nell'alto; se il valore è negativo, inserisce 1 nell'alto;

L'operatore di shift a destra con riempimento di zero >>>, indipendentemente dal segno, inserisce 0 nell'alto.

Non capisco gli operatori bitwise, salto per ora. Puoi studiarli più tardi quando li utilizzerai.

7. Priorità degli operatori

La priorità degli operatori determina il raggruppamento dei termini in un'espressione. Influisce su come viene valutata un'espressione. Alcuni operatori hanno una priorità più alta rispetto ad altri.

Ad esempio, l'operatore di moltiplicazione ha una priorità più alta rispetto all'operatore di somma. Nell'espressione 1 + 5 * 6, in base alla priorità degli operatori, il compilatore calcolerà prima 5 * 6, poi 30 + 1, e il risultato finale sarà 31.

L'ordine di priorità degli operatori di vari tipi è il seguente, da alto a basso:

. (), []
unario+(sinistra a destra combinato), unario-(sinistra a destra combinato), ++, --, ~, !
* , /,%
+(sinistra a destra combinato), -(sinistra a destra combinato)
>>, <<, >>>
<, <=, >, >=
==, !=
&
|
^
&&
||
?:
=, += ecc. operatori di assegnamento

Non preoccuparti di questa lista di priorità così complessa, nella maggior parte dei casi, l'espressione stessa è abbastanza facile da vedere la priorità, come l'operatore di assegnamento è sicuramente la priorità più bassa. In quei casi in cui la priorità non è chiara, possiamo usare parentesi per cambiare la priorità secondo il nostro desiderio, quindi non è necessario ricordare molto la priorità degli operatori.

8. Altri operatori

Operatore ternario:

L'operatore condizionale in Java è un operatore ternario, la sua forma è come segue:

booleanExpression ? valueWhenTrue : valueWhenFalse

Se il valore dell'espressione booleana è true, il valore dell'espressione è il valore di valueWhenTrue, altrimenti è il valore di valueWhenFalse.

if (x >= 0) {

y = x;
 else {
}
 y = -x;
}

attraverso l'operatore ternario, è sufficiente una singola istruzione y = x >= 0 ? x : -x; per completare, più concisa.

Operatore di conversione di tipo:

Usiamo spesso la conversione di tipo. In alcuni casi appropriati, Java può anche convertire automaticamente il tipo di dati in un altro tipo di dati in base al tipo di dati. Ad esempio, se assegniamo un valore intero a una variabile float, il compilatore convertirà int in float e assegnarlo alla variabile.

Ma in molti casi, Java non può determinare se dobbiamo effettuare la conversione di tipo, in questo caso ci serve l'operatore di conversione di tipo, che ci permette di effettuare la conversione di tipo esplicita, come:

int a = 10;
long b = (long) a;
long c = (long) 100;

Possiamo effettuare la conversione di tipo sia per le variabili che per le costanti.

Quando convertiamo un numero a virgola mobile in tipo di dati, dobbiamo prestare attenzione al problema di troncamento. Ad esempio, se convertiamo 10.9 in tipo di dati: (int) 10.9, il valore non è arrotondato a 11, ma 10