Java nodrošina daudzu veidu operatorus, kurus var izmantot atbilstoši vajadzībām. Tie tiek klasificēti, pamatojoties uz to sniegto funkcionalitāti. Šajā rakstā mēs uzzināsim par Java operatoriem un uzzināsim visus to veidus.

Kas ir Java operatori?

Java operatori ir simboli, ko izmanto konkrētu operāciju veikšanai Java. Operatori veic tādus uzdevumus kā saskaitīšana, reizināšana utt., kas izskatās vienkārši, lai gan šo uzdevumu īstenošana ir diezgan sarežģīta.

Operatoru veidi Java

Java ir vairāku veidu operatori, visi ir minēti tālāk:

1. Aritmētiskie operatori
2. Unārie operatori
3. Uzdevuma operators
4. Relāciju operatori
5. Loģiskie operatori
6. Trīskāršs operators
7. Bitu operatori
8. Maiņu operatori
9. operatora piemērs

1. Aritmētiskie operatori

Tos izmanto, lai veiktu vienkāršas aritmētiskas darbības ar primitīviem datu tipiem.

• * : Reizināšana
• / : Divīzija
• %: Modulis
• + : Papildinājums
• – : Atņemšana

Piemērs:

// 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. Unārie operatori

Unārajiem operatoriem ir nepieciešams tikai viens operands. Tos izmanto, lai palielinātu, samazinātu vai noliegtu vērtību.

• – : Vienots mīnuss , ko izmanto vērtību noliegšanai.
• + : Vienots pluss norāda pozitīvo vērtību (tomēr skaitļi ir pozitīvi bez tā). Tas veic automātisku pārveidošanu par int, ja tā operanda veids ir baits, rakstzīme vai īss. To sauc par vienreizēju ciparu paaugstināšanu.
• ++: Palielināšanas operators , ko izmanto, lai palielinātu vērtību par 1. Ir divi pieauguma operatoru veidi.
  
  • Pēcpieaugums: Vērtība vispirms tiek izmantota rezultāta aprēķināšanai un pēc tam tiek palielināta.
  • Iepriekšējs pieaugums: Vispirms tiek palielināta vērtība, un pēc tam tiek aprēķināts rezultāts.
• – – : samazināšanas operators , ko izmanto vērtības samazināšanai par 1. Ir divi samazināšanas operatoru veidi.
  
  • Pēc samazinājuma: Vērtība vispirms tiek izmantota rezultāta aprēķināšanai un pēc tam tiek samazināta.
  • Iepriekšēja samazināšana: vērtība vispirms tiek samazināts, un pēc tam tiek aprēķināts rezultāts.
• ! : loģiski, nevis operators , ko izmanto Būla vērtības invertēšanai.

Piemērs:

// 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. Piešķiršanas operators

'=' Piešķiršanas operators tiek izmantots, lai piešķirtu vērtību jebkuram mainīgajam. Tam ir asociativitāte no labās puses uz kreiso, t.i., vērtība, kas norādīta operatora labajā pusē, tiek piešķirta mainīgajam, kas atrodas kreisajā pusē, un tāpēc labās puses vērtība ir jādeklarē pirms tā izmantošanas vai tai jābūt konstantei.

virknes funkcijas java

Vispārīgais uzdevuma operatora formāts ir:

variable   =   value;>

Daudzos gadījumos piešķiršanas operatoru var apvienot ar citiem operatoriem, lai izveidotu īsāku priekšraksta versiju, ko sauc par a Saliktais paziņojums . Piemēram, a vietā = a+5, varam uzrakstīt a += 5.

• += , lai pievienotu kreiso operandu ar labo operandu un pēc tam piešķirtu to mainīgajam kreisajā pusē.
• -= , lai atņemtu labo operandu no kreisā operanda un pēc tam piešķirtu to mainīgajam kreisajā pusē.
• *= , lai reizinātu kreiso operandu ar labo operandu un pēc tam piešķirtu to mainīgajam kreisajā pusē.
• /= , lai dalītu kreiso operandu ar labo operandu un pēc tam piešķirtu to mainīgajam kreisajā pusē.
• %= , lai piešķirtu kreisā operanda moduli ar labo operandu un pēc tam piešķirtu to mainīgajam kreisajā pusē.

Piemērs:

// 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. Relāciju operatori    
Šie operatori tiek izmantoti, lai pārbaudītu attiecības, piemēram, vienlīdzība, lielāks par un mazāks par. Tie pēc salīdzināšanas atgriež Būla rezultātus un tiek plaši izmantoti cilpas priekšrakstos, kā arī nosacījumos if-else priekšrakstos. Vispārējais formāts ir,
 Daži no relāciju operatoriem ir -
 
    ==, vienāds ar    atgriež patieso, ja kreisā puse ir vienāda ar labo pusi.
    !=, nav vienāds ar    atgriež patieso, ja kreisā puse nav vienāda ar labo pusi.
    <, mazāk nekā:    atgriež patieso vērtību, ja kreisā puse ir mazāka par labo pusi.
    <=, mazāks par vai vienāds ar    atgriež patieso vērtību, ja kreisā puse ir mazāka vai vienāda ar labo pusi.
    >, lielāks par:    atgriež patieso vērtību, ja kreisā puse ir lielāka par labo pusi.
    >=, Lielāks par vai vienāds ar    atgriež patieso vērtību, ja kreisā puse ir lielāka vai vienāda ar labo pusi.
    Piemērs:    
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));  } }>
   
  Izvade  
a>b: patiess a = b: patiess a<= b: false a == c: false a != c: true>
 
    5. Loģiskie operatori    
Šie operatori tiek izmantoti, lai veiktu loģiskās UN un loģiskās VAI darbības, t.i., funkciju, kas līdzīga UN vārtiem un VAI vārtiem digitālajā elektronikā. Viena lieta, kas jāpatur prātā, ir tas, ka otrais nosacījums netiek novērtēts, ja pirmais ir nepatiess, t.i., tam ir īssavienojuma efekts. Plaši izmantots, lai pārbaudītu vairākus lēmuma pieņemšanas nosacījumus. Java ir arī Loģiskais NOT, kas atgriež patiesu, ja nosacījums ir nepatiess, un otrādi
 
Nosacītie operatori ir:
 
    &&, loģiski UN:    atgriež patiesu, ja abi nosacījumi ir patiesi.
    ||, loģisks VAI:    atgriež patiesu, ja vismaz viens nosacījums ir patiess.
    !, Loģiski NĒ:    atgriež patieso vērtību, ja nosacījums ir nepatiess, un otrādi
    Piemērs:    
windows.open javascript
Java 
// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>
   
  Izvade  
x && y: false x || y: true !x: false>
 
    6. Trīskāršs operators    
Trīskāršais operators ir priekšraksta if-else saīsināta versija. Tam ir trīs operandi, un līdz ar to nosaukums Ternary.
 
Vispārējais formāts ir šāds:
 
condition   ?   if true   :   if false>
Iepriekš minētais paziņojums nozīmē, ka, ja nosacījums tiek novērtēts kā patiess, izpildiet paziņojumus pēc “?”, pretējā gadījumā izpildiet paziņojumus pēc “:”.
 
    Piemērs:    
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('Maksimālais trīs skaitļu skaits = ' + rezultāts);  } }>
   
  Izvade  
Max of three numbers = 30>
 
    7. Bitu operatori    
Šie operatori tiek izmantoti, lai veiktu manipulācijas ar atsevišķiem skaitļa bitiem. Tos var izmantot ar jebkuru no veselu skaitļu veidiem. Tie tiek izmantoti, veicot bināro indeksēto koku atjaunināšanas un vaicājumu darbības.
 
    &, Bitu UN operators:    atgriež pa bitiem UN ievades vērtības.
    |, Bitu VAI operators:    atgriež bitu pa bitam VAI ievades vērtības.
    ^, bitu XOR operators:    atgriež ievades vērtību bitu pa bitam XOR.
    ~, Bitwise Complement operators:    Šis ir unārs operators, kas atgriež ievades vērtības viena komplementa attēlojumu, t.i., ar apgrieztiem bitiem.
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  }>
   
  Izvade  
d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1: 6 un>>> 1: 6>>> 
    8. Maiņu operatori    
Šos operatorus izmanto, lai pārvietotu skaitļa bitus pa kreisi vai pa labi, tādējādi attiecīgi reizinot vai dalot skaitli ar divi. Tos var izmantot, ja mums ir jāreizina vai jādala skaitlis ar divi. Vispārīgs formāts -
     <<, Kreisās maiņas operators:    pārbīda skaitļa bitus pa kreisi un rezultātā aizpilda 0 tukšumos. Līdzīgs efekts kā skaitļa reizināšana ar kādu divu jaudu.
    >>, Parakstīts labās maiņas operators:    pārbīda skaitļa bitus pa labi un rezultātā aizpilda 0 tukšos laukumos. Kreisākais bits ir atkarīgs no sākotnējā skaitļa zīmes. Līdzīgs efekts kā skaitļa dalīšana ar kādu divu pakāpju.
    >>>, Neparakstīts labās maiņas operators:    pārbīda skaitļa bitus pa labi un rezultātā aizpilda 0 tukšos laukumos. Kreisākais bits ir iestatīts uz 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));  } }>
   
  Izvade  
a<<1 : 20 a>>1:5>>
 
    9. operatora instance    
Operatora gadījums tiek izmantots tipa pārbaudei. To var izmantot, lai pārbaudītu, vai objekts ir klases, apakšklases vai interfeisa gadījums. Vispārīgs formāts -
java polimorfisms
 
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 { }>
   
  Izvade  
obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
 
Java operatoru prioritāte un asociativitāte
Prioritātes un asociatīvie noteikumi tiek izmantoti, strādājot ar hibrīdvienādojumiem, kuros iesaistīti vairāk nekā viena veida operatori. Šādos gadījumos šie noteikumi nosaka, kura vienādojuma daļa jāņem vērā vispirms, jo vienam un tam pašam vienādojumam var būt daudz dažādu vērtējumu. Zemāk esošajā tabulā ir attēlota operatoru prioritāte dilstošā secībā kā lielums, augšā apzīmē augstāko prioritāti un apakšā ir zemāko prioritāti.
 
 
 
Interesanti jautājumi par Java operatoriem
    1. Prioritāte un asociācija:    
Bieži vien rodas neskaidrības, kad runa ir par hibrīdvienādojumiem, kas ir vienādojumi ar vairākiem operatoriem. Problēma ir tāda, kuru daļu vispirms atrisināt. Šādās situācijās ir jāievēro zelta likums. Ja operatoriem ir atšķirīga prioritāte, vispirms atrisiniet augstāko prioritāti. Ja tiem ir vienāda prioritāte, atrisiniet saskaņā ar asociativitāti, tas ir, vai nu no labās uz kreiso pusi, vai no kreisās uz labo. Tālāk norādītās programmas skaidrojums ir labi uzrakstīts komentāros pašā programmā.
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.  // (* = / = %)>(+ = -) // izdrukā a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // ja tāda pati prioritāte, tad tiek ievēroti asociatīvie // noteikumi.  // 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));  } }>
   
  Izvade  
a+b/d = 20 a+b*d-e/f = 219>
 
    2. Esiet kompilators:    
Mūsu sistēmu kompilators izmanto lex rīku, lai, ģenerējot marķierus, atrastu vislielāko atbilstību. Tas rada nelielas problēmas, ja to neievēro. Piemēram, apsveriet paziņojumu    a=b+++c    ; šķiet, ka pārāk daudzi lasītāji rada kompilatora kļūdu. Bet šis apgalvojums ir pilnīgi pareizs, jo lex radītais marķieris ir a, =, b, ++, +, c. Tāpēc šim apgalvojumam ir līdzīgs efekts, vispirms a piešķirot b+c un pēc tam palielinot b. Līdzīgi a=b+++++c; radītu kļūdu, jo ģenerētie marķieri ir a, =, b, ++, ++, +, c. kas patiesībā ir kļūda, jo pēc otrā unārā operanda nav neviena operanda.
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);  } }>
   
  Izvade  
Value of a(b+c), b(b+1), c = 10, 11, 0>
 
    3. Izmantojot + virs ():    
Ja iekšpusē izmantojat operatoru +      system.out.println()      noteikti veiciet pievienošanu, izmantojot iekavas. Ja mēs rakstām kaut ko pirms pievienošanas, tad notiek virknes pievienošana, tas ir, pievienošanas asociativitāte tiek veikta no kreisās uz labo pusi, un tādējādi veseli skaitļi tiek pievienoti virknei, kas vispirms veido virkni, un virknes objekti tiek savienoti, izmantojot +. Tāpēc tas var radīt nevēlamus rezultātus.
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));  } }>
   
  Izvade  
Concatenation (x+y)= 58 Addition (x+y) = 13>
 
Java operatoru priekšrocības
Tālāk ir minētas Java operatoru izmantošanas priekšrocības:
 
    Izteiksmīgums    : Java operatori nodrošina īsu un lasāmu veidu, kā veikt sarežģītus aprēķinus un loģiskas darbības.
    Laika taupīšana:    Java operatori ietaupa laiku, samazinot noteiktu uzdevumu veikšanai nepieciešamā koda daudzumu.
    Uzlabota veiktspēja    : operatoru izmantošana var uzlabot veiktspēju, jo tie bieži tiek ieviesti aparatūras līmenī, padarot tos ātrākus par līdzvērtīgu Java kodu.
Java operatoru trūkumi
Tālāk ir minēti Java operatoru trūkumi:
 
    Operatora prioritāte:    Java operatoriem ir noteikta prioritāte, kas var novest pie negaidītiem rezultātiem, ja tos neizmanto pareizi.
    Tipa piespiešana    : Java, izmantojot operatorus, veic netiešas tipa konversijas, kas var izraisīt negaidītus rezultātus vai kļūdas, ja to neizmanto pareizi.
Bieži uzdotie jautājumi programmā Java operatori
1. Kas ir operatori Java ar piemēru?
Operatori ir īpašie simboli, kas tiek izmantoti noteiktu darbību veikšanai. Piemēram, “+” tiek izmantots saskaitīšanai, kur 5+4 atgriež vērtību 9.