Java oferă multe tipuri de operatori care pot fi utilizați în funcție de necesități. Ele sunt clasificate în funcție de funcționalitatea pe care o oferă. În acest articol, vom afla despre Operatorii Java și vom afla toate tipurile acestora.

Ce sunt operatorii Java?

Operatorii în Java sunt simbolurile folosite pentru a efectua operații specifice în Java. Operatorii realizează sarcini precum adunarea, înmulțirea etc., care par ușoare, deși implementarea acestor sarcini este destul de complexă.

Tipuri de operatori în Java

Există mai multe tipuri de operatori în Java, toate sunt menționate mai jos:

1. Operatori aritmetici
2. Operatori unari
3. Operator de atribuire
4. Operatori Relaționali
5. Operatori logici
6. Operator ternar
7. Operatori pe biți
8. Operatori în schimburi
9. instanță de operator

1. Operatori aritmetici

Sunt folosite pentru a efectua operații aritmetice simple pe tipuri de date primitive.

arraylist în sortare java

• * : Multiplicare
• / : Divizia
• %: Modul
• + : Plus
• – : Scădere

Exemplu:

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

Operatorii unari au nevoie de un singur operand. Ele sunt folosite pentru a crește, a decrementa sau a anula o valoare.

• – : Minus unar , folosit pentru anularea valorilor.
• + : Plus unar indică valoarea pozitivă (numerele sunt pozitive fără aceasta, totuși). Efectuează o conversie automată în int atunci când tipul operandului său este byte, char sau short. Aceasta se numește promovare numerică unară.
• ++: Operator de creștere , folosit pentru incrementarea valorii cu 1. Există două tipuri de operatori de incrementare.
  
  • După creștere: Valoarea este mai întâi utilizată pentru calcularea rezultatului și apoi incrementată.
  • Pre-crementare: Valoarea este mai întâi incrementată, apoi rezultatul este calculat.
• – – : Operator de decrementare , folosit pentru decrementarea valorii cu 1. Există două varietăți de operatori de decrementare.
  
  • Post-decrementare: Valoarea este mai întâi utilizată pentru calcularea rezultatului și apoi decrementată.
  • Pre-Decrement: valoarea este mai întâi decrementat, apoi rezultatul este calculat.
• ! : Operator logic nu , folosit pentru inversarea unei valori booleene.

Exemplu:

matrice de programare java

// 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. Operator de atribuire

'=' Operatorul de atribuire este folosit pentru a atribui o valoare oricărei variabile. Are asociativitate de la dreapta la stânga, adică valoarea dată în partea dreaptă a operatorului este atribuită variabilei din stânga și, prin urmare, valoarea din partea dreaptă trebuie declarată înainte de a o utiliza sau ar trebui să fie o constantă.

Formatul general al operatorului de atribuire este:

variable   =   value;>

În multe cazuri, operatorul de atribuire poate fi combinat cu alți operatori pentru a construi o versiune mai scurtă a instrucțiunii numită Declarație compusă . De exemplu, în loc de a = a+5, putem scrie a += 5.

• += , pentru a adăuga operandul din stânga cu operandul din dreapta și apoi pentru a-l atribui variabilei din stânga.
• -= , pentru a scădea operandul drept din operandul stâng și apoi a-l atribui variabilei din stânga.
• *= , pentru a înmulți operandul din stânga cu operandul din dreapta și apoi a-l atribui variabilei din stânga.
• /= , pentru a împărți operandul din stânga la operandul din dreapta și apoi a-l atribui variabilei din stânga.
• %= , pentru alocarea modulo operandului din stânga de către operandul din dreapta și apoi atribuirea lui variabilei din stânga.

Exemplu:

// 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 relaționali    
Acești operatori sunt utilizați pentru a verifica relații precum egalitate, mai mare decât și mai mică decât. Ele returnează rezultate booleene după comparație și sunt utilizate pe scară largă în instrucțiuni de buclă, precum și în instrucțiuni condiționale if-else. Formatul general este,
 Unii dintre operatorii relaționali sunt:
 
    ==, Egal cu    returnează adevărat dacă partea stângă este egală cu partea dreaptă.
    !=, Nu este egal cu    returnează adevărat dacă partea stângă nu este egală cu partea dreaptă.
    <, mai puțin de:    returnează adevărat dacă partea stângă este mai mică decât partea dreaptă.
    <=, mai mic sau egal cu    returnează adevărat dacă partea stângă este mai mică sau egală cu partea dreaptă.
    >, mai mare decât:    returnează adevărat dacă partea stângă este mai mare decât partea dreaptă.
    >=, Mai mare sau egal cu    returnează adevărat dacă partea stângă este mai mare sau egală cu partea dreaptă.
    Exemplu:    
Java 
// 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));  } }>
   
  Ieșire  
a>b: adevărat a = b: adevărat a<= b: false a == c: false a != c: true>
 
    5. Operatori logici    
Acești operatori sunt utilizați pentru a efectua operații logice ȘI și SAU logice, adică o funcție similară cu poarta ȘI și poarta SAU din electronica digitală. Un lucru de reținut este că a doua condiție nu este evaluată dacă prima este falsă, adică are un efect de scurtcircuitare. Folosit pe scară largă pentru a testa mai multe condiții pentru luarea unei decizii. Java are, de asemenea, logic NOT, care returnează adevărat atunci când condiția este falsă și invers
 
Operatorii condiționali sunt:
 
    &&, ȘI logic:    returnează adevărat când ambele condiții sunt adevărate.
    ||, SAU logic:    returnează adevărat dacă cel puțin o condiție este adevărată.
    !, NU logic:    returnează adevărat când o condiție este falsă și invers
    Exemplu:    
Java 
// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>
   
  Ieșire  
x && y: false x || y: true !x: false>
 
    6. Operator ternar    
Operatorul ternar este o versiune scurtă a instrucțiunii if-else. Are trei operanzi și de aici și numele Ternar.
np.unde
 
Formatul general este:
 
condition   ?   if true   :   if false>
Declarația de mai sus înseamnă că, dacă condiția este evaluată la adevărat, atunci executați instrucțiunile după „?”, altfel executați instrucțiunile după „:”.
cum se generează un număr aleator în java
 
    Exemplu:    
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) ? b : c);  System.out.println('Max de trei numere = ' + rezultat);  } }>>>  
  Ieșire  
Max of three numbers = 30>
  
    7. Operatori pe biți    
Acești operatori sunt utilizați pentru a efectua manipularea biților individuali ai unui număr. Ele pot fi utilizate cu oricare dintre tipurile întregi. Ele sunt utilizate atunci când se efectuează operațiuni de actualizare și interogare a arborilor indexați binari.
 
    &, operator AND pe biți:    returnează bit cu bit ȘI valorile de intrare.
    |, operator SAU pe biți:    returnează bit cu bit SAU valorile de intrare.
    ^, operator XOR pe biți:    returnează bit cu bit XOR al valorilor de intrare.
    ~, operator de complement pe biți:    Acesta este un operator unar care returnează reprezentarea complementului unu a valorii de intrare, adică cu toți biții inversați.
Java 
// 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  }>
   
  Ieșire  Acești operatori sunt utilizați pentru a deplasa biții unui număr la stânga sau la dreapta, înmulțind sau împărțind astfel numărul cu doi. Ele pot fi folosite atunci când trebuie să înmulțim sau să împărțim un număr cu doi. format general-
     <<, operator de schimbare la stânga:    mută biții numărului la stânga și completează 0 în golurile rămase ca rezultat. Efect similar cu înmulțirea numărului cu o putere de doi.
    >>, operator de schimbare la dreapta semnat:    mută biții numărului la dreapta și completează 0 în golurile rămase ca rezultat. Bitul din stânga depinde de semnul numărului inițial. Efect similar cu împărțirea numărului cu o putere de doi.
    >>>, operator de schimbare la dreapta nesemnat:    mută biții numărului la dreapta și completează 0 în golurile rămase ca rezultat. Bitul din stânga este setat la 0.
Java 
// 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));  } }>>>  
  Ieșire  
a<<1 : 20 a>>1 : 5>>
  
    9. instanţă de operator    
Instanța operatorului este utilizată pentru verificarea tipului. Poate fi folosit pentru a testa dacă un obiect este o instanță a unei clase, a unei subclase sau a unei interfețe. format general-
  
// 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 { }>
   
  Ieșire  
obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
 
Precedența și asociativitatea operatorilor Java
Regulile de prioritate și asociative sunt utilizate atunci când se lucrează cu ecuații hibride care implică mai mult de un tip de operator. În astfel de cazuri, aceste reguli determină care parte a ecuației trebuie luată în considerare mai întâi, deoarece pot exista multe evaluări diferite pentru aceeași ecuație. Tabelul de mai jos prezintă precedența operatorilor în ordine descrescătoare ca mărime, partea de sus reprezentând cea mai mare precedență, iar partea de jos arătând cea mai mică precedență.
exemplu de nume de utilizator
 
 
 
Întrebări interesante despre operatorii Java
    1. Precedenta si asociativitate:    
Există adesea confuzie când vine vorba de ecuații hibride, care sunt ecuații cu operatori multipli. Problema este ce parte trebuie rezolvată mai întâi. Există o regulă de aur de urmat în aceste situații. Dacă operatorii au prioritate diferită, rezolvați întâi prioritatea mai mare. Daca au aceeasi prioritate se rezolva dupa asociativitate, adica fie de la dreapta la stanga, fie de la stanga la dreapta. Explicația programului de mai jos este bine scrisă în comentarii în cadrul programului în sine.
Java 
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.  // (* = / = %)>(+ = -) // imprimă a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // dacă aceeași precedență, atunci se respectă // regulile asociative.  // 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));  } }>>>  
  Ieșire  
a+b/d = 20 a+b*d-e/f = 219>
  
    2. Fii un compilator:    
Compilatorul din sistemele noastre folosește un instrument lex pentru a se potrivi cu cea mai mare potrivire atunci când generează jetoane. Acest lucru creează o mică problemă dacă este trecut cu vederea. De exemplu, luați în considerare afirmația    a=b++c    ; prea mulți dintre cititori ar putea părea să creeze o eroare de compilator. Dar această afirmație este absolut corectă, deoarece simbolul creat de lex este a, =, b, ++, +, c. Prin urmare, această declarație are un efect similar de a atribui mai întâi b+c la a și apoi de a crește b. În mod similar, a=b++++c; ar genera o eroare, deoarece tokenurile generate sunt a, =, b, ++, ++, +, c. care este de fapt o eroare deoarece nu există niciun operand după al doilea operand unar.
Java 
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);  } }>
   
  Ieșire  Când utilizați operatorul + în interior      system.out.println()      asigurați-vă că faceți adaos folosind paranteze. Dacă scriem ceva înainte de a face adunarea, atunci are loc adăugarea șirurilor, adică asociativitatea adunării este de la stânga la dreapta și, prin urmare, numerele întregi sunt adăugate la un șir producând mai întâi un șir, iar obiectele șir se concatenează când se utilizează +. Prin urmare, poate crea rezultate nedorite.
Java 
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));  } }>
   
  Ieșire  
Concatenation (x+y)= 58 Addition (x+y) = 13>
 
Avantajele operatorilor în Java
Avantajele utilizării operatorilor în Java sunt menționate mai jos:
 
    Expresivitate    : Operatorii din Java oferă o modalitate concisă și lizibilă de a efectua calcule complexe și operații logice.
    Economie de timp:    Operatorii din Java economisesc timp prin reducerea cantității de cod necesare pentru a efectua anumite sarcini.
    Performanta imbunatatita    : Utilizarea operatorilor poate îmbunătăți performanța deoarece aceștia sunt adesea implementați la nivel hardware, făcându-i mai rapid decât codul Java echivalent.
Dezavantajele operatorilor în Java
Dezavantajele operatorilor în Java sunt menționate mai jos:
 
    Precedența operatorului:    Operatorii din Java au o prioritate definită, care poate duce la rezultate neașteptate dacă nu sunt utilizate corespunzător.
    Tip Coerciție    : Java realizează conversii implicite de tip atunci când utilizează operatori, ceea ce poate duce la rezultate neașteptate sau erori dacă nu este utilizat corespunzător.
Întrebări frecvente în operatorii Java
1. Ce sunt operatorii în Java cu exemplu?
Operatorii sunt simbolurile speciale care sunt folosite pentru efectuarea anumitor operațiuni. De exemplu, „+” este folosit pentru adunare, unde 5+4 va returna valoarea 9.