Java biedt vele soorten operators die naar behoefte kunnen worden gebruikt. Ze worden geclassificeerd op basis van de functionaliteit die ze bieden. In dit artikel leren we over Java-operators en leren we al hun typen.

Wat zijn de Java-operators?

Operators in Java zijn de symbolen die worden gebruikt voor het uitvoeren van specifieke bewerkingen in Java. Operators maken taken zoals optellen, vermenigvuldigen, enz. die er gemakkelijk uitzien, hoewel de implementatie van deze taken behoorlijk complex is.

string naar int in java

Soorten operators in Java

Er zijn meerdere soorten operators in Java, ze worden allemaal hieronder vermeld:

1. Rekenkundige operatoren
2. Unaire operators
3. Opdracht Operator
4. Relationele operators
5. Logische operatoren
6. Ternaire operator
7. Bitwise-operatoren
8. Shift-operatoren
9. exemplaar van operator

1. Rekenkundige operatoren

Ze worden gebruikt om eenvoudige rekenkundige bewerkingen uit te voeren op primitieve gegevenstypen.

• * : Vermenigvuldiging
• / : Divisie
• %: Module
• + : Toevoeging
• – : Aftrekken

Voorbeeld:

// 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. Unaire operatoren

Unaire operatoren hebben slechts één operand nodig. Ze worden gebruikt om een ​​waarde te verhogen, verlagen of teniet te doen.

• – : Unair min , gebruikt voor het ontkennen van de waarden.
• + : Unair plus geeft de positieve waarde aan (cijfers zijn echter positief zonder deze waarde). Het voert een automatische conversie uit naar int wanneer het type operand byte, char of short is. Dit wordt unaire numerieke promotie genoemd.
• ++: Operator voor ophogen , gebruikt om de waarde met 1 te verhogen. Er zijn twee varianten van verhogingsoperatoren.
  
  • Post-verhoging: De waarde wordt eerst gebruikt voor het berekenen van het resultaat en vervolgens verhoogd.
  • Pre-verhoging: De waarde wordt eerst verhoogd en vervolgens wordt het resultaat berekend.
• – – : Operator verlagen , gebruikt om de waarde met 1 te verlagen. Er zijn twee varianten van verlagingsoperatoren.
  
  • Post-verlaging: De waarde wordt eerst gebruikt voor het berekenen van het resultaat en vervolgens verlaagd.
  • Pre-verlaging: de waarde wordt eerst verlaagd en vervolgens wordt het resultaat berekend.
• ! : Logisch, geen operator , gebruikt voor het omkeren van een Booleaanse waarde.

Voorbeeld:

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

'=' De toewijzingsoperator wordt gebruikt om een ​​waarde aan een variabele toe te wijzen. Het heeft een associativiteit van rechts naar links, dat wil zeggen dat de waarde die aan de rechterkant van de operator wordt gegeven, wordt toegewezen aan de variabele aan de linkerkant, en daarom moet de waarde aan de rechterkant worden gedeclareerd voordat deze wordt gebruikt, anders moet deze een constante zijn.

Het algemene formaat van de toewijzingsoperator is:

variable   =   value;>

In veel gevallen kan de toewijzingsoperator worden gecombineerd met andere operators om een ​​kortere versie van de instructie te bouwen, genaamd a Samengestelde verklaring . In plaats van bijvoorbeeld een = a+5, we kunnen a schrijven += 5.

• += , voor het optellen van de linker operand bij de rechter operand en het vervolgens toewijzen ervan aan de variabele aan de linkerkant.
• -= , voor het aftrekken van de rechter operand van de linker operand en deze vervolgens toewijzen aan de variabele aan de linkerkant.
• *= , voor het vermenigvuldigen van de linker operand met de rechter operand en het vervolgens toewijzen ervan aan de variabele aan de linkerkant.
• /= , voor het delen van de linker operand door de rechter operand en deze vervolgens toe te wijzen aan de variabele aan de linkerkant.
• %= , voor het toewijzen van de modulo van de linker operand door de rechter operand en deze vervolgens toe te wijzen aan de variabele aan de linkerkant.

Voorbeeld:

// 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. Relationele operators

Deze operatoren worden gebruikt om te controleren op relaties zoals gelijkheid, groter dan en kleiner dan. Ze retourneren booleaanse resultaten na de vergelijking en worden uitgebreid gebruikt in looping-instructies en voorwaardelijke if-else-instructies. Het algemene formaat is,

variable   relation_operator   value>

Sommige van de relationele operatoren zijn-

• ==, gelijk aan retourneert waar als het linkerlid gelijk is aan het rechterlid.
• !=, Niet gelijk aan retourneert waar als het linkerlid niet gelijk is aan het rechterlid.
• <, minder dan: retourneert waar als het linkerlid kleiner is dan het rechterlid.
• <=, kleiner dan of gelijk aan retourneert waar als het linkerlid kleiner is dan of gelijk is aan het rechterlid.
• >, Groter dan: retourneert waar als het linkerlid groter is dan het rechterlid.
• >=, groter dan of gelijk aan retourneert waar als de linkerkant groter is dan of gelijk is aan de rechterkant.

Voorbeeld:

// 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 + (een< 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: waar a = b: waar a<= b: false a == c: false a != c: true>

5. Logische operatoren

Deze operatoren worden gebruikt om logische EN- en logische OF-bewerkingen uit te voeren, dat wil zeggen een functie die vergelijkbaar is met EN-poort en OF-poort in digitale elektronica. Eén ding om in gedachten te houden is dat de tweede voorwaarde niet wordt geëvalueerd als de eerste onwaar is, dat wil zeggen als deze een kortsluiteffect heeft. Wordt veelvuldig gebruikt om te testen op verschillende voorwaarden voor het nemen van een beslissing. Java heeft ook Logical NOT, dat waar retourneert als de voorwaarde onwaar is en omgekeerd

Voorwaardelijke operatoren zijn:

• &&, Logisch EN: retourneert waar als beide voorwaarden waar zijn.
• ||, Logisch OF: retourneert waar als ten minste één voorwaarde waar is.
• !, Logisch NIET: retourneert waar als een voorwaarde onwaar is en omgekeerd

Voorbeeld:

// 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. Ternaire operator

De ternaire operator is een verkorte versie van de if-else-instructie. Het heeft drie operanden en vandaar de naam Ternary.

Het algemene formaat is:

condition   ?   if true   :   if false>

De bovenstaande verklaring betekent dat als de voorwaarde resulteert in waar, u de instructies na de ‘?’ moet uitvoeren en anders de instructies na de ‘:’ moet uitvoeren.

Voorbeeld:

// 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) ? (een> c) ? a: c: (b> c) ? b:c);  System.out.println('Maximaal drie cijfers = ' + resultaat);  } }>

Max of three numbers = 30>

7. Bitwise-operatoren

Deze operatoren worden gebruikt om de manipulatie van individuele bits van een getal uit te voeren. Ze kunnen worden gebruikt met elk van de gehele typen. Ze worden gebruikt bij het uitvoeren van update- en querybewerkingen van de binaire geïndexeerde bomen.

• &, Bitwise AND-operator: retourneert bit voor bit EN van invoerwaarden.
• |, Bitwise OR-operator: retourneert bit voor bit OF van invoerwaarden.
• ^, Bitwise XOR-operator: retourneert bit-voor-bit XOR van invoerwaarden.
• ~, Bitsgewijze complementoperator: Dit is een unaire operator die de ene-complementrepresentatie van de invoerwaarde retourneert, dat wil zeggen met alle bits omgekeerd.

// 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 en>>> 1: 6>>> 
    8. Shiftoperatoren    
Deze operatoren worden gebruikt om de bits van een getal naar links of rechts te verschuiven, waardoor het getal respectievelijk door twee wordt vermenigvuldigd of gedeeld. Ze kunnen worden gebruikt als we een getal moeten vermenigvuldigen of delen door twee. Algemeen formaat-
     <<, Linkerploegmedewerker:    verschuift de bits van het getal naar links en vult 0 op de lege plekken die daardoor overblijven. Hetzelfde effect als het vermenigvuldigen van het getal met een macht van twee.
    >>, Getekend Rechterploegmedewerker:    verschuift de bits van het getal naar rechts en vult daardoor 0 op de lege plekken links. Het meest linkse bit is afhankelijk van het teken van het beginnummer. Hetzelfde effect als het delen van een getal met een macht van twee.
    >>>, niet-ondertekende rechterploegoperator:    verschuift de bits van het getal naar rechts en vult daardoor 0 op de lege plekken links. Het meest linkse bit wordt op 0 gezet.
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));  } }>
   
  Uitvoer  
a<<1 : 20 a>>1 : 5>>
 
    9. exemplaar van operator    
Het exemplaar van de operator wordt gebruikt voor typecontrole. Het kan worden gebruikt om te testen of een object een instantie is van een klasse, een subklasse of een interface. Algemeen formaat-
 
object   instance of   class/subclass/interface>
Java 
// 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 { }>
   
  Uitvoer  
obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
 
Voorrang en associativiteit van Java-operators
Voorrangs- en associatieve regels worden gebruikt bij het omgaan met hybride vergelijkingen waarbij meer dan één type operator betrokken is. In dergelijke gevallen bepalen deze regels welk deel van de vergelijking als eerste in overweging moet worden genomen, omdat er voor dezelfde vergelijking veel verschillende waarderingen kunnen zijn. De onderstaande tabel toont de prioriteit van operatoren in afnemende volgorde van grootte, waarbij de bovenste de hoogste prioriteit vertegenwoordigt en de onderste de laagste prioriteit.
 
 
 
Interessante vragen over Java-operators
    1. Voorrang en associativiteit:    
Er bestaat vaak verwarring als het gaat om hybride vergelijkingen, dit zijn vergelijkingen met meerdere operatoren. Het probleem is welk onderdeel eerst moet worden opgelost. Er is een gouden regel die u in deze situaties moet volgen. Als de operatoren een verschillende prioriteit hebben, los dan eerst de hogere prioriteit op. Als ze dezelfde prioriteit hebben, los ze dan op volgens associativiteit, dat wil zeggen van rechts naar links of van links naar rechts. De uitleg van het onderstaande programma is goed geschreven in de commentaren binnen het programma zelf.
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.  // (* = / = %)>(+ = -) // print a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // als dezelfde prioriteit wordt gevolgd, worden associatieve // ​​regels gevolgd.  // 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));  } }>
   
  Uitvoer  
a+b/d = 20 a+b*d-e/f = 219>
 
    2. Wees een compiler:    
De compiler in onze systemen gebruikt een lex-tool om de beste match te vinden bij het genereren van tokens. Dit levert een klein probleem op als het over het hoofd wordt gezien. Denk bijvoorbeeld eens aan de verklaring    a=b+++c    ; te veel van de lezers lijken misschien een compilerfout te veroorzaken. Maar deze verklaring is absoluut correct, aangezien het token gemaakt door lex a, =, b, ++, +, c is. Daarom heeft deze verklaring een soortgelijk effect: eerst wordt b+c aan a toegewezen en vervolgens wordt b verhoogd. Op dezelfde manier geldt a=b++++++c; zou een fout genereren omdat de gegenereerde tokens a, =, b, ++, ++, +, c zijn. wat eigenlijk een fout is, aangezien er geen operand na de tweede unaire operand staat.
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);  } }>
   
  Uitvoer  
Value of a(b+c), b(b+1), c = 10, 11, 0>
 
    3. Gebruik + boven ():    
Bij gebruik van de + operator binnen      systeem.out.println()      Zorg ervoor dat u de optelling doet met behulp van haakjes. Als we iets schrijven voordat we de optelling doen, dan vindt er een optelling van de reeks plaats, dat wil zeggen dat de associativiteit van de optelling van links naar rechts wordt uitgevoerd, en daarom worden gehele getallen aan een reeks toegevoegd, waardoor eerst een reeks ontstaat, en reeksobjecten worden samengevoegd bij gebruik van +. Daarom kan het ongewenste resultaten opleveren.
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));  } }>
   
  Uitvoer  
Concatenation (x+y)= 58 Addition (x+y) = 13>
 
Voordelen van operators in Java
De voordelen van het gebruik van operators in Java worden hieronder vermeld:
 
    Expressiviteit    : Operators in Java bieden een beknopte en leesbare manier om complexe berekeningen en logische bewerkingen uit te voeren.
    Tijd besparen:    Operators in Java besparen tijd door de hoeveelheid code die nodig is om bepaalde taken uit te voeren, te verminderen.
    Verbeterde prestatie    : Het gebruik van operators kan de prestaties verbeteren omdat ze vaak op hardwareniveau worden geïmplementeerd, waardoor ze sneller zijn dan gelijkwaardige Java-code.
Nadelen van operators in Java
De nadelen van Operators in Java worden hieronder vermeld:
 
    Voorrang van operator:    Operators in Java hebben een gedefinieerde prioriteit, wat tot onverwachte resultaten kan leiden als ze niet correct worden gebruikt.
    Type dwang    : Java voert impliciete typeconversies uit bij het gebruik van operators, wat tot onverwachte resultaten of fouten kan leiden als het niet op de juiste manier wordt gebruikt.
Veelgestelde vragen over Java-operators
1. Wat zijn operators in Java met voorbeeld?
Operators zijn de speciale symbolen die worden gebruikt voor het uitvoeren van bepaalde bewerkingen. ‘+’ wordt bijvoorbeeld gebruikt voor optelling, waarbij 5+4 de waarde 9 retourneert.