Java ofereix molts tipus d'operadors que es poden utilitzar segons les necessitats. Es classifiquen en funció de la funcionalitat que proporcionen. En aquest article, coneixerem els operadors Java i coneixerem tots els seus tipus.

Què són els operadors Java?

Els operadors en Java són els símbols utilitzats per realitzar operacions específiques en Java. Els operadors fan tasques com sumes, multiplicacions, etc. que semblen fàcils, encara que la implementació d'aquestes tasques és força complexa.

Tipus d'operadors en Java

Hi ha diversos tipus d'operadors a Java, tots s'esmenten a continuació:

1. Operadors aritmètics
2. Operadors unaris
3. Operador d'assignació
4. Operadors relacionals
5. Operadors lògics
6. Operador Ternari
7. Operadors per bits
8. Operadors de torn
9. instància de l'operador

1. Operadors aritmètics

S'utilitzen per realitzar operacions aritmètiques senzilles sobre tipus de dades primitius.

• * : Multiplicació
• / : Divisió
• % : Mòdul
• + : Addició
• – : Resta

Exemple:

// 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. Operadors unaris

Els operadors unaris només necessiten un operand. S'utilitzen per augmentar, disminuir o negar un valor.

• – : Menys unari , utilitzat per negar els valors.
• + : Plus unari indica el valor positiu (els nombres són positius sense això, però). Realitza una conversió automàtica a int quan el tipus del seu operand és byte, char o short. Això s'anomena promoció numèrica unària.
• ++ : Operador d'increment , utilitzat per incrementar el valor en 1. Hi ha dues varietats d'operadors d'increment.
  
  • Post-increment: El valor s'utilitza primer per calcular el resultat i després s'incrementa.
  • Increment previ: El valor s'incrementa primer i després es calcula el resultat.
• – – : Operador de disminució , utilitzat per disminuir el valor en 1. Hi ha dues varietats d'operadors de disminució.
  
  • Post-disminució: El valor s'utilitza primer per calcular el resultat i després es disminueix.
  • Pre-disminució: el valor primer es disminueix i després es calcula el resultat.
• ! : Operador lògic no , utilitzat per invertir un valor booleà.

Exemple:

// 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. Operador d'assignació

‘=’ L'operador d'assignació s'utilitza per assignar un valor a qualsevol variable. Té associativitat de dreta a esquerra, és a dir, el valor donat a la part dreta de l'operador s'assigna a la variable de l'esquerra i, per tant, el valor de la dreta s'ha de declarar abans d'utilitzar-lo o hauria de ser una constant.

bash altrament si

El format general de l'operador d'assignació és:

variable   =   value;>

En molts casos, l'operador d'assignació es pot combinar amb altres operadors per crear una versió més curta de la instrucció anomenada Declaració composta . Per exemple, en lloc d'a = a+5, podem escriure a += 5.

• += , per afegir l'operand esquerre amb l'operand dret i després assignar-lo a la variable de l'esquerra.
• -= , per restar l'operand dret de l'operand esquerre i després assignar-lo a la variable de l'esquerra.
• *= , per multiplicar l'operand esquerre per l'operand dret i després assignar-lo a la variable de l'esquerra.
• /= , per dividir l'operand esquerre per l'operand dret i després assignar-lo a la variable de l'esquerra.
• %= , per assignar el mòdul de l'operand esquerre per l'operand dret i després assignar-lo a la variable de l'esquerra.

Exemple:

// 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. Operadors relacionals    
Aquests operadors s'utilitzen per comprovar si hi ha relacions com la igualtat, major que i menor que. Retornen resultats booleans després de la comparació i s'utilitzen àmpliament en declaracions de bucle, així com en declaracions condicionals if-else. El format general és,
 Alguns dels operadors relacionals són:
 
    ==, Igual a    retorna cert si el costat esquerre és igual al costat dret.
    !=, No és igual a    retorna cert si el costat esquerre no és igual al costat dret.
    <, menys de:    retorna cert si el costat esquerre és menor que el costat dret.
    <=, menor o igual a    retorna cert si el costat esquerre és menor o igual que el costat dret.
    >, més gran que:    retorna cert si el costat esquerre és més gran que el costat dret.
    >=, Major o igual a    retorna cert si el costat esquerre és més gran o igual que el costat dret.
    Exemple:    
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));  } }>
   
  Sortida  
a>b: veritable a = b: vertader a<= b: false a == c: false a != c: true>
 
    5. Operadors lògics    
Aquests operadors s'utilitzen per realitzar operacions AND lògiques i OR lògiques, és a dir, una funció similar a la porta AND i la porta OR en electrònica digital. Una cosa a tenir en compte és que la segona condició no s'avalua si la primera és falsa, és a dir, té un efecte de curtcircuit. S'utilitza àmpliament per provar diverses condicions per prendre una decisió. Java també té un NOT lògic, que retorna cert quan la condició és falsa i viceversa
 
Els operadors condicionals són:
 
    &&, I lògic:    retorna cert quan les dues condicions són certes.
    ||, OR lògic:    retorna cert si almenys una condició és certa.
    !, NO lògic:    retorna cert quan una condició és falsa i viceversa
    Exemple:    
jquery un clic
Java 
// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>
   
  Sortida  
x && y: false x || y: true !x: false>
 
    6. Operador ternari    
L'operador ternari és una versió abreujada de la instrucció if-else. Té tres operands i d'aquí el nom Ternary.
 
El format general és:
 
condition   ?   if true   :   if false>
La declaració anterior vol dir que si la condició s'avalua com a vertadera, executeu les declaracions després del '?', sinó executeu les declaracions després del ':'.
 
    Exemple:    
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('Màxim de tres números = ' + resultat);  } }>>>  
  Sortida  
Max of three numbers = 30>
  
    7. Operadors bit a bit    
Aquests operadors s'utilitzen per realitzar la manipulació de bits individuals d'un nombre. Es poden utilitzar amb qualsevol dels tipus enters. S'utilitzen quan es realitzen operacions d'actualització i consulta dels arbres indexats binaris.
 
    &, operador AND bit a bit:    retorna bit a bit AND dels valors d'entrada.
    |, operador OR bit a bit:    retorna bit a bit OR dels valors d'entrada.
    ^, operador XOR bit a bit:    retorna XOR bit a bit dels valors d'entrada.
    ~, operador de complement bit a bit:    Aquest és un operador unari que retorna la representació del complement d'un del valor d'entrada, és a dir, amb tots els bits invertits.
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  }>
   
  Sortida  Aquests operadors s'utilitzen per desplaçar els bits d'un nombre cap a l'esquerra o cap a la dreta, multiplicant o dividint el nombre per dos, respectivament. Es poden utilitzar quan hem de multiplicar o dividir un nombre per dos. Format general-
     <<, Operador de desplaçament a l'esquerra:    desplaça els bits del número cap a l'esquerra i com a resultat omple 0 als buits que queden. Efecte similar al de multiplicar el nombre amb una mica de potència de dos.
    >>, Operador de desplaçament a la dreta signat:    desplaça els bits del número cap a la dreta i com a resultat omple 0 als buits que queden. El bit més esquerre depèn del signe del número inicial. Efecte similar al de dividir el nombre amb una potència de dos.
    >>>, operador de desplaçament a la dreta sense signar:    desplaça els bits del número cap a la dreta i com a resultat omple 0 als buits que queden. El bit més a l'esquerra s'estableix a 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));  } }>>>  
  Sortida  
a<<1 : 20 a>>1 : 5>
  
    9. instància d'operador    
La instància de l'operador s'utilitza per a la comprovació de tipus. Es pot utilitzar per provar si un objecte és una instància d'una classe, una subclasse o una interfície. 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 { }>
   
  Sortida  
obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
 
Precedència i associativitat dels operadors Java
Les regles de precedència i associatives s'utilitzen quan es tracta d'equacions híbrides que impliquen més d'un tipus d'operador. En aquests casos, aquestes regles determinen quina part de l'equació cal considerar primer, ja que hi pot haver moltes valoracions diferents per a la mateixa equació. La taula següent mostra la precedència dels operadors en ordre decreixent com a magnitud, amb la part superior que representa la precedència més alta i la part inferior mostrant la precedència més baixa.
 
 
 
Preguntes interessants sobre els operadors de Java
    1. Precedència i associativitat:    
Sovint hi ha confusió quan es tracta d'equacions híbrides que són equacions amb múltiples operadors. El problema és quina part s'ha de resoldre primer. Hi ha una regla d'or a seguir en aquestes situacions. Si els operadors tenen una precedència diferent, resol primer la precedència més alta. Si tenen la mateixa precedència, resol segons l'associativitat, és a dir, o bé de dreta a esquerra o d'esquerra a dreta. L'explicació del programa següent està ben escrita en comentaris dins del programa.
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.  // (* = / = %)>(+ = -) // imprimeix a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // si la mateixa precedència es segueixen // les regles associatives.  // 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));  } }>>>  
  Sortida  
a+b/d = 20 a+b*d-e/f = 219>
  
    2. Sigues compilador:    
El compilador dels nostres sistemes utilitza una eina lex per fer coincidir la major coincidència en generar fitxes. Això crea una mica de problema si es passa per alt. Per exemple, considereu la declaració    a=b++c    ; massa lectors pot semblar que creen un error del compilador. Però aquesta afirmació és absolutament correcta, ja que el testimoni creat per lex és a, =, b, ++, +, c. Per tant, aquesta declaració té un efecte similar d'assignar primer b+c a a i després incrementar b. De la mateixa manera, a=b++++c; generaria un error ja que els testimonis generats són a, =, b, ++, ++, +, c. que en realitat és un error ja que no hi ha cap operand després del segon operand unari.
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);  } }>
   
  Sortida  Quan utilitzeu l'operador + dins      system.out.println()      Assegureu-vos de fer la suma utilitzant parèntesis. Si escrivim alguna cosa abans de fer la suma, aleshores es produeix l'addició de cadena, és a dir, l'associativitat de l'addició s'agrega d'esquerra a dreta i, per tant, s'afegeixen nombres enters a una cadena produint primer una cadena, i els objectes de cadena es concatenen quan s'utilitzen +. Per tant, pot generar resultats no desitjats.
shehzad poonawala
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));  } }>
   
  Sortida  
Concatenation (x+y)= 58 Addition (x+y) = 13>
 
Avantatges dels operadors en Java
Els avantatges d'utilitzar operadors a Java s'esmenten a continuació:
 
    Expressivitat    : Els operadors de Java proporcionen una manera concisa i llegible de realitzar càlculs complexos i operacions lògiques.
    Estalvi de temps:    Els operadors de Java estalvien temps reduint la quantitat de codi necessària per realitzar determinades tasques.
    Rendiment millorat    : L'ús d'operadors pot millorar el rendiment perquè sovint s'implementen a nivell de maquinari, fent-los més ràpids que el codi Java equivalent.
Inconvenients dels operadors a Java
Els desavantatges dels operadors a Java s'esmenten a continuació:
 
    Precedència de l'operador:    Els operadors de Java tenen una precedència definida, que pot donar lloc a resultats inesperats si no s'utilitzen correctament.
    Tipus de coacció    : Java realitza conversions de tipus implícites quan utilitza operadors, la qual cosa pot provocar resultats inesperats o errors si no s'utilitza correctament.
Preguntes freqüents als operadors Java
1. Què són els operadors a Java amb exemple?
Els operadors són els símbols especials que s'utilitzen per realitzar determinades operacions. Per exemple, '+' s'utilitza per a la suma, on 5+4 retornarà el valor 9.