Java fornisce molti tipi di operatori che possono essere utilizzati a seconda delle necessità. Sono classificati in base alla funzionalità che forniscono. In questo articolo impareremo gli operatori Java e ne impareremo tutti i tipi.

Cosa sono gli operatori Java?

Gli operatori in Java sono i simboli utilizzati per eseguire operazioni specifiche in Java. Gli operatori svolgono compiti come addizione, moltiplicazione, ecc. che sembrano facili sebbene l'implementazione di questi compiti sia piuttosto complessa.

Tipi di operatori in Java

Esistono diversi tipi di operatori in Java, tutti menzionati di seguito:

1. Operatori aritmetici
2. Operatori unari
3. Operatore di assegnazione
4. Operatori relazionali
5. Operatori logici
6. Operatore ternario
7. Operatori bit a bit
8. Operatori di turno
9. istanza di operatore

1. Operatori aritmetici

Vengono utilizzati per eseguire semplici operazioni aritmetiche su tipi di dati primitivi.

• *: Moltiplicazione
• /: Divisione
• %: Modulo
• +: Aggiunta
• –: Sottrazione

Esempio:

// Java Program to implement // Arithmetic Operators import java.io.*; // Drive Class class GFG {  // Main Function  public static void main (String[] args) {    // Arithmetic operators  int a = 10;  int b = 3;    System.out.println('a + b = ' + (a + b));  System.out.println('a - b = ' + (a - b));  System.out.println('a * b = ' + (a * b));  System.out.println('a / b = ' + (a / b));  System.out.println('a % b = ' + (a % b));    } }>

a + b = 13 a - b = 7 a * b = 30 a / b = 3 a % b = 1>

2. Operatori unari

Gli operatori unari necessitano di un solo operando. Vengono utilizzati per incrementare, decrementare o negare un valore.

è Java vuoto

• –: Meno unario , utilizzato per negare i valori.
• +: Più unario indica il valore positivo (senza questo però i numeri sono positivi). Esegue una conversione automatica in int quando il tipo del suo operando è byte, carattere o short. Questa è chiamata promozione numerica unaria.
• ++: Operatore di incremento , utilizzato per incrementare il valore di 1. Esistono due varietà di operatori di incremento.
  
  • Post-incremento: Il valore viene prima utilizzato per calcolare il risultato e poi incrementato.
  • Pre-incremento: Il valore viene prima incrementato, quindi viene calcolato il risultato.
• – – : operatore di decremento , utilizzato per diminuire il valore di 1. Esistono due varietà di operatori di decremento.
  
  • Post-decremento: Il valore viene prima utilizzato per calcolare il risultato e poi decrementato.
  • Pre-decremento: il valore viene prima diminuito, quindi viene calcolato il risultato.
• ! : Operatore non logico , utilizzato per invertire un valore booleano.

Esempio:

// Java Program to implement // Unary Operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  // Interger declared  int a = 10;  int b = 10;  // Using unary operators  System.out.println('Postincrement : ' + (a++));  System.out.println('Preincrement : ' + (++a));  System.out.println('Postdecrement : ' + (b--));  System.out.println('Predecrement : ' + (--b));  } }>

Postincrement : 10 Preincrement : 12 Postdecrement : 10 Predecrement : 8>

3. Operatore di Assegnazione

'=' L'operatore di assegnazione viene utilizzato per assegnare un valore a qualsiasi variabile. Ha associatività da destra a sinistra, ovvero il valore fornito sul lato destro dell'operatore è assegnato alla variabile a sinistra, e pertanto il valore del lato destro deve essere dichiarato prima di utilizzarlo o dovrebbe essere una costante.

Il formato generale dell'operatore di assegnazione è:

variable   =   value;>

In molti casi, l'operatore di assegnazione può essere combinato con altri operatori per creare una versione più breve dell'istruzione chiamata a Dichiarazione composta . Ad esempio, invece di a = a+5, possiamo scrivere a += 5.

• += , per aggiungere l'operando di sinistra con l'operando di destra e quindi assegnarlo alla variabile di sinistra.
• -= , per sottrarre l'operando di destra dall'operando di sinistra e quindi assegnarlo alla variabile di sinistra.
• *= , per moltiplicare l'operando di sinistra con l'operando di destra e quindi assegnarlo alla variabile di sinistra.
• /= , per dividere l'operando sinistro per l'operando destro e quindi assegnarlo alla variabile a sinistra.
• %= , per assegnare il modulo dell'operando di sinistra tramite l'operando di destra e quindi assegnarlo alla variabile di sinistra.

Esempio:

// Java Program to implement // Assignment Operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  = 0b1100: ' + (f  }>

f += 3: 10 f -= 2: 8 f *= 4: 32 f /= 3: 10 f %= 2: 0 f &= 0b1010: 0 f |= 0b1100: 12 f ^= 0b1010: 6 f <>= 1: 12 f>>>= 1: 6>>

4. Operatori Relazionali

Questi operatori vengono utilizzati per verificare relazioni come uguaglianza, maggiore di e minore di. Restituiscono risultati booleani dopo il confronto e sono ampiamente utilizzati nelle istruzioni di loop e nelle istruzioni condizionali if-else. Il formato generale è,

variable   relation_operator   value>

Alcuni degli operatori relazionali sono-

• ==, Uguale a restituisce vero se il lato sinistro è uguale al lato destro.
• !=, Diverso da restituisce vero se il lato sinistro non è uguale al lato destro.
• <, inferiore a: restituisce vero se il lato sinistro è minore del lato destro.
• <=, minore o uguale a restituisce vero se il lato sinistro è minore o uguale al lato destro.
• >, Maggiore di: restituisce vero se il lato sinistro è maggiore del lato destro.
• >=, Maggiore o uguale a restituisce vero se il lato sinistro è maggiore o uguale al lato destro.

Esempio:

// Java Program to implement // Relational Operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  // Comparison operators  int a = 10;  int b = 3;  int c = 5;  System.out.println('a>b: ' + (a> b));  System.out.println('a + (a< b));  System.out.println('a>= b: ' + (a>= b));  System.out.println('a<= b: ' + (a <= b));  System.out.println('a == c: ' + (a == c));  System.out.println('a != c: ' + (a != c));  } }>

a>b: vero a = b: vero a<= b: false a == c: false a != c: true>

5. Operatori logici

Questi operatori vengono utilizzati per eseguire operazioni logiche AND e OR logiche, ovvero una funzione simile alla porta AND e alla porta OR nell'elettronica digitale. Una cosa da tenere presente è che la seconda condizione non viene valutata se la prima è falsa, cioè ha un effetto di cortocircuito. Utilizzato ampiamente per testare diverse condizioni per prendere una decisione. Java ha anche il NOT logico, che restituisce vero quando la condizione è falsa e viceversa

Gli operatori condizionali sono:

• &&, AND logico: restituisce vero quando entrambe le condizioni sono vere.
• ||, OR logico: restituisce vero se almeno una condizione è vera.
• !, NON logico: restituisce vero quando una condizione è falsa e viceversa

Esempio:

// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>

x && y: false x || y: true !x: false>

6. Operatore ternario

L'operatore ternario è una versione abbreviata dell'istruzione if-else. Ha tre operandi e da qui il nome Ternario.

Il formato generale è:

condition   ?   if true   :   if false>

L'affermazione di cui sopra significa che se la condizione risulta vera, allora esegui le istruzioni dopo '?' altrimenti esegui le istruzioni dopo ':'.

Esempio:

array di byte per stringere java

// Java program to illustrate // max of three numbers using // ternary operator. public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 30, result;  // result holds max of three  // numbers  result  = ((a>B) ? (a> c) ? a : c : (b> c) ? avanti Cristo);  System.out.println('Massimo tre numeri = ' + risultato);  } }>

Max of three numbers = 30>

7. Operatori bit a bit

Questi operatori vengono utilizzati per eseguire la manipolazione dei singoli bit di un numero. Possono essere utilizzati con qualsiasi tipo intero. Vengono utilizzati durante l'esecuzione di operazioni di aggiornamento e query degli alberi indicizzati binari.

• &, operatore AND bit a bit: restituisce bit per bit AND dei valori di input.
• |, operatore OR bit a bit: restituisce bit per bit OR dei valori di input.
• ^, operatore XOR bit a bit: restituisce lo XOR bit per bit dei valori di input.
• ~, operatore del complemento bit a bit: Si tratta di un operatore unario che restituisce la rappresentazione in complemento a uno del valore di input, ovvero con tutti i bit invertiti.

// Java Program to implement // bitwise operators import java.io.*; // Driver class class GFG {  // main function  public static void main(String[] args)    // Bitwise operators  int d = 0b1010;  int e = 0b1100;  System.out.println('d & e: ' + (d & e));  System.out.println('d  }>

d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1: 6 e>>> 1: 6>>> 
    8. Operatori di turno    
Questi operatori vengono utilizzati per spostare i bit di un numero a sinistra o a destra, moltiplicando o dividendo il numero rispettivamente per due. Possono essere utilizzati quando dobbiamo moltiplicare o dividere un numero per due. Formato generale-
     <<, operatore di spostamento a sinistra:    sposta i bit del numero a sinistra e di conseguenza riempie 0 sui vuoti rimasti. Effetto simile alla moltiplicazione del numero per una potenza di due.
    >>, Operatore di spostamento a destra con segno:    sposta i bit del numero a destra e di conseguenza riempie 0 sui vuoti a sinistra. Il bit più a sinistra dipende dal segno del numero iniziale. Effetto simile alla divisione del numero con una potenza di due.
    >>>, operatore di spostamento a destra senza segno:    sposta i bit del numero a destra e di conseguenza riempie 0 sui vuoti a sinistra. Il bit più a sinistra è impostato su 0.
Giava 
// Java Program to implement // shift operators import java.io.*; // Driver Class class GFG {  // main function  public static void main(String[] args)  {  int a = 10;    // using left shift  System.out.println('a<<1 : ' + (a << 1));    // using right shift  System.out.println('a>>1 : ' + (a>> 1));  } }>
   
  Produzione  
a<<1 : 20 a>>1 : 5>>
 
    9. istanza dell'operatore    
L'istanza dell'operatore viene utilizzata per il controllo del tipo. Può essere utilizzato per verificare se un oggetto è un'istanza di una classe, una sottoclasse o un'interfaccia. Formato generale-
 
object   instance of   class/subclass/interface>
Giava 
// Java program to illustrate // instance of operator class operators {  public static void main(String[] args)  {  Person obj1 = new Person();  Person obj2 = new Boy();  // As obj is of type person, it is not an  // instance of Boy or interface  System.out.println('obj1 instanceof Person: '  + (obj1 instanceof Person));  System.out.println('obj1 instanceof Boy: '  + (obj1 instanceof Boy));  System.out.println('obj1 instanceof MyInterface: '  + (obj1 instanceof MyInterface));  // Since obj2 is of type boy,  // whose parent class is person  // and it implements the interface Myinterface  // it is instance of all of these classes  System.out.println('obj2 instanceof Person: '  + (obj2 instanceof Person));  System.out.println('obj2 instanceof Boy: '  + (obj2 instanceof Boy));  System.out.println('obj2 instanceof MyInterface: '  + (obj2 instanceof MyInterface));  } } class Person { } class Boy extends Person implements MyInterface { } interface MyInterface { }>
   
  Produzione  
obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
 
Precedenza e associatività degli operatori Java
Le regole di precedenza e associative vengono utilizzate quando si ha a che fare con equazioni ibride che coinvolgono più di un tipo di operatore. In questi casi, queste regole determinano quale parte dell’equazione considerare per prima, poiché possono esserci molte valutazioni diverse per la stessa equazione. La tabella seguente illustra la precedenza degli operatori in ordine decrescente come grandezza, con la parte superiore che rappresenta la precedenza più alta e quella inferiore che mostra la precedenza più bassa.
 
 
 
Domande interessanti sugli operatori Java
    1. Precedenza e associatività:    
C'è spesso confusione quando si tratta di equazioni ibride che sono equazioni con più operatori. Il problema è quale parte risolvere per prima. C’è una regola d’oro da seguire in queste situazioni. Se gli operatori hanno una precedenza diversa, risolvere prima la precedenza più alta. Se hanno la stessa precedenza, risolvi secondo l'associatività, cioè da destra a sinistra o da sinistra a destra. La spiegazione del programma seguente è ben scritta nei commenti all'interno del programma stesso.
Giava 
public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;  // precedence rules for arithmetic operators.  // (* = / = %)>(+ = -) // stampa a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // Se la stessa precedenza viene seguita // vengono seguite le regole associative.  // e/f -> b*d -> a+(b*d) -> a+(b*d)-(e/f) System.out.println('a+b*d-e/f = ' + (a+b*d - e/f));  } }>
   
  Produzione  
a+b/d = 20 a+b*d-e/f = 219>
 
    2. Diventa un compilatore:    
Il compilatore nei nostri sistemi utilizza uno strumento lex per trovare la corrispondenza migliore durante la generazione dei token. Questo crea un piccolo problema se trascurato. Consideriamo ad esempio la dichiarazione    a=b+++c    ; troppi lettori potrebbero sembrare creare un errore del compilatore. Ma questa affermazione è assolutamente corretta poiché il token creato da lex è a, =, b, ++, +, c. Pertanto, questa affermazione ha un effetto simile assegnando prima b+c ad a e quindi incrementando b. Allo stesso modo, a=b++++++c; genererebbe un errore poiché i token generati sono a, =, b, ++, ++, +, c. che in realtà è un errore poiché non esiste alcun operando dopo il secondo operando unario.
Giava 
public class operators {  public static void main(String[] args)  {  int a = 20, b = 10, c = 0;  // a=b+++c is compiled as  // b++ +c  // a=b+c then b=b+1  a = b++ + c;  System.out.println('Value of a(b+c), '  + ' b(b+1), c = ' + a + ', ' + b  + ', ' + c);  // a=b+++++c is compiled as  // b++ ++ +c  // which gives error.  // a=b+++++c;  // System.out.println(b+++++c);  } }>
   
  Produzione  
Value of a(b+c), b(b+1), c = 10, 11, 0>
 
    3. Utilizzando + su ():    
Quando si utilizza l'operatore + all'interno      system.out.println()      assicurati di fare l'addizione usando le parentesi. Se scriviamo qualcosa prima di eseguire l'addizione, avviene l'addizione di stringhe, ovvero l'associatività dell'addizione è da sinistra a destra, e quindi gli interi vengono aggiunti a una stringa producendo prima una stringa e gli oggetti stringa si concatenano quando si usa +. Pertanto può creare risultati indesiderati.
Giava 
public class operators {  public static void main(String[] args)  {  int x = 5, y = 8;  // concatenates x and y as  // first x is added to 'concatenation (x+y) = '  // producing 'concatenation (x+y) = 5'  // and then 8 is further concatenated.  System.out.println('Concatenation (x+y)= ' + x + y);  // addition of x and y  System.out.println('Addition (x+y) = ' + (x + y));  } }>
   
  Produzione  
Concatenation (x+y)= 58 Addition (x+y) = 13>
 
Vantaggi degli operatori in Java
I vantaggi derivanti dall'utilizzo degli operatori in Java sono menzionati di seguito:
 
    Espressività    : Gli operatori in Java forniscono un modo conciso e leggibile per eseguire calcoli complessi e operazioni logiche.
    Che fa risparmiare tempo:    Gli operatori in Java risparmiano tempo riducendo la quantità di codice richiesto per eseguire determinate attività.
    Prestazione migliorata    : L'uso degli operatori può migliorare le prestazioni perché spesso sono implementati a livello hardware, rendendoli più veloci del codice Java equivalente.
Svantaggi degli operatori in Java
Gli svantaggi degli operatori in Java sono menzionati di seguito:
 
    Precedenza dell'operatore:    Gli operatori in Java hanno una precedenza definita, che può portare a risultati imprevisti se non utilizzati correttamente.
    Tipo Coercizione    : Java esegue conversioni di tipo implicite quando si utilizzano gli operatori, che possono portare a risultati o errori imprevisti se non utilizzati correttamente.
Domande frequenti sugli operatori Java
1. Cosa sono gli operatori in Java con l'esempio?
Gli operatori sono i simboli speciali utilizzati per eseguire determinate operazioni. Ad esempio, '+' viene utilizzato per l'addizione dove 5+4 restituirà il valore 9.