Java tarjoaa monenlaisia ​​operaattoreita, joita voidaan käyttää tarpeen mukaan. Ne luokitellaan niiden tarjoamien toimintojen perusteella. Tässä artikkelissa opimme Java-operaattoreista ja opimme kaikki niiden tyypit.

Mitä Java-operaattorit ovat?

Java-operaattorit ovat symboleja, joita käytetään tiettyjen toimintojen suorittamiseen Javassa. Operaattorit tekevät tehtäviä, kuten yhteenlasku-, kertolasku-, jne., jotka näyttävät helpolta, vaikka näiden tehtävien toteuttaminen on melko monimutkaista.

Operaattoreiden tyypit Javassa

Javassa on useita operaattoreita, jotka kaikki mainitaan alla:

1. Aritmeettiset operaattorit
2. Yksittäiset operaattorit
3. Tehtäväoperaattori
4. Relaatiooperaattorit
5. Loogiset operaattorit
6. Kolmiosainen operaattori
7. Bittikohtaiset operaattorit
8. Vuorooperaattorit
9. operaattorin esimerkki

1. Aritmeettiset operaattorit

Niitä käytetään yksinkertaisten aritmeettisten operaatioiden suorittamiseen primitiivisille tietotyypeille.

• * : Kertominen
• / : Division
• %: Moduuli
• + : Lisäys
• – : Vähennyslasku

Esimerkki:

// 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. Yksittäiset operaattorit

Unaarioperaattorit tarvitsevat vain yhden operandin. Niitä käytetään lisäämään, vähentämään tai mitätöimään arvoa.

• – : Yksinäinen miinus , käytetään arvojen kumoamiseen.
• + : Yksinäinen plussa osoittaa positiivista arvoa (luvut ovat kuitenkin positiivisia ilman tätä). Se suorittaa automaattisen muunnoksen int:ksi, kun sen operandin tyyppi on tavu, merkki tai lyhyt. Tätä kutsutaan unaariseksi numeeriseksi edistämiseksi.
• ++: Kasvatusoperaattori , jota käytetään arvon lisäämiseen yhdellä. Lisäysoperaattoreita on kahta erilaista.
  
  • Jälkilisäys: Arvoa käytetään ensin tuloksen laskemiseen ja sitten sitä lisätään.
  • Ennakkolisäys: Arvoa kasvatetaan ensin, ja sitten tulos lasketaan.
• – – : Vähennä operaattoria , jota käytetään arvon pienentämiseen 1:llä. Vähennysoperaattoreita on kahdenlaisia.
  
  • Vähennyksen jälkeinen: Arvoa käytetään ensin tuloksen laskemiseen ja sitten sitä vähennetään.
  • Pre-Decrement: Arvo vähennetään ensin ja sitten lasketaan tulos.
• ! : Looginen ei operaattori , jota käytetään loogisen arvon kääntämiseen.

Esimerkki:

// 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. Tehtäväoperaattori

'=' Assignment-operaattoria käytetään arvon määrittämiseen mille tahansa muuttujalle. Sillä on oikealta vasemmalle assosiatiivisuus, eli operaattorin oikealla puolella annettu arvo on määritetty vasemmalla olevalle muuttujalle, ja siksi oikean puolen arvo on ilmoitettava ennen sen käyttöä tai sen tulee olla vakio.

julkinen vs yksityinen java

Tehtäväoperaattorin yleinen muoto on:

variable   =   value;>

Monissa tapauksissa osoitusoperaattori voidaan yhdistää muiden operaattoreiden kanssa lyhyemmän version luomiseksi käskystä nimeltä a Yhdistelmälausunto . Esimerkiksi a = a+5, voimme kirjoittaa a += 5.

• += , vasemman operandin lisäämiseen oikean operandin kanssa ja sen liittämiseen sitten vasemmalla olevaan muuttujaan.
• -= , jolla vähennetään oikea operandi vasemmasta operaandista ja määritetään se sitten vasemmalla olevaan muuttujaan.
• *= , vasemman operandin kertomiseen oikealla ja sen määrittämiseksi vasemmalla olevaan muuttujaan.
• /= , vasemman operandin jakamiseen oikealla ja sen määrittämiseksi vasemmalla olevaan muuttujaan.
• %= , vasemman operandin moduulin osoittamiseksi oikealla operandilla ja sen osoittamiseksi vasemmalla olevalle muuttujalle.

Esimerkki:

// 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. Relaatiooperaattorit    
Näitä operaattoreita käytetään tarkistamaan suhteita, kuten yhtäläisyys, suurempi kuin ja pienempi kuin. Ne palauttavat loogiset tulokset vertailun jälkeen ja niitä käytetään laajalti silmukkalausekkeissa sekä ehdollisissa if-else -lauseissa. Yleinen muoto on
 Jotkut relaatiooperaattoreista ovat
 
    ==, yhtä suuri kuin    palauttaa arvon tosi, jos vasen puoli on yhtä suuri kuin oikea puoli.
    !=, Ei yhtä suuri kuin    palauttaa arvon tosi, jos vasen puoli ei ole yhtä suuri kuin oikea puoli.
    <, vähemmän kuin:    palauttaa arvon tosi, jos vasen puoli on pienempi kuin oikea.
    <=, pienempi tai yhtä suuri kuin    palauttaa arvon tosi, jos vasen puoli on pienempi tai yhtä suuri kuin oikea puoli.
    >, suurempi kuin:    palauttaa arvon tosi, jos vasen puoli on suurempi kuin oikea.
    >=, Suurempi tai yhtä suuri kuin    palauttaa arvon tosi, jos vasen puoli on suurempi tai yhtä suuri kuin oikea puoli.
    Esimerkki:    
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));  } }>
   
  Lähtö  
a>b: tosi a = b: tosi a<= b: false a == c: false a != c: true>
 
    5. Loogiset operaattorit    
Näitä operaattoreita käytetään suorittamaan loogisia JA- ja loogisia TAI-operaatioita, eli toimintoa, joka on samanlainen kuin AND-portti ja TAI-portti digitaalisessa elektroniikassa. Yksi asia on pidettävä mielessä, että toista ehtoa ei arvioida, jos ensimmäinen on väärä, eli sillä on oikosulkuvaikutus. Käytetään laajasti useiden päätöksenteon edellytysten testaamiseen. Javassa on myös Looginen EI, joka palauttaa tosi, kun ehto on epätosi ja päinvastoin
 
Ehdolliset operaattorit ovat:
 
    &&, Looginen JA:    palauttaa tosi, kun molemmat ehdot ovat tosia.
    ||, Looginen TAI:    palauttaa tosi, jos ainakin yksi ehto on tosi.
    !, Looginen EI:    palauttaa tosi, kun ehto on epätosi ja päinvastoin
    Esimerkki:    
js monirivinen merkkijono
Java 
// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>
   
  Lähtö  
x && y: false x || y: true !x: false>
 
    6. Kolmiosainen operaattori    
Kolmiosainen operaattori on lyhennetty versio if-else-lauseesta. Sillä on kolme operandia ja siitä syystä nimi Ternary.
 
Yleinen muoto on:
 
condition   ?   if true   :   if false>
Yllä oleva lauseke tarkoittaa, että jos ehdon arvo on tosi, suorita lauseet '?':n jälkeen, muuten suorita lauseet ':':n jälkeen.
 
    Esimerkki:    
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('Kolmen numeron enimmäismäärä = ' + tulos);  } }>
   
  Lähtö  
Max of three numbers = 30>
 
    7. Bittioperaattorit    
Näitä operaattoreita käytetään luvun yksittäisten bittien käsittelyyn. Niitä voidaan käyttää minkä tahansa kokonaislukutyypin kanssa. Niitä käytetään suoritettaessa binaaristen indeksoitujen puiden päivitys- ja kyselytoimintoja.
 
    &, Bittikohtainen AND-operaattori:    palauttaa syöttöarvot bitti bitiltä JA.
    |, Bittikohtainen TAI -operaattori:    palauttaa syöttöarvot bitti bitiltä TAI.
    ^, Bitwise XOR-operaattori:    palauttaa tuloarvojen bitti bitiltä XOR.
    ~, Bitwise Complement -operaattori:    Tämä on unaarioperaattori, joka palauttaa tuloarvon yhden komplementin esityksen, eli kaikki bitit käänteisinä.
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  }>
   
  Lähtö  
d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1:6 ja>>> 1:6>>> 
    8. Vuorotyöntekijät    
Näitä operaattoreita käytetään siirtämään luvun bittejä vasemmalle tai oikealle, jolloin luku kerrotaan tai jaetaan vastaavasti kahdella. Niitä voidaan käyttää, kun meidän on kerrottava tai jaettava luku kahdella. Yleinen muoto-
     <<, Vasen vaihtooperaattori:    siirtää luvun bittejä vasemmalle ja täyttää tämän seurauksena 0:n jäljellä oleviin aukkoihin. Samanlainen vaikutus kuin luvun kertominen kahdella.
    >>, Signeerattu Oikean vuorooperaattori:    siirtää luvun bittejä oikealle ja täyttää tämän seurauksena 0:n vasemmalla olevat tyhjät kohdat. Vasemmanpuoleisin bitti riippuu alkuluvun etumerkistä. Samanlainen vaikutus kuin luvun jakaminen jollain kahdella potenssilla.
    >>>, Allekirjoittamaton Oikean vuorooperaattori:    siirtää luvun bittejä oikealle ja täyttää tämän seurauksena 0:n vasemmalla olevat tyhjät kohdat. Vasemmanpuoleisin bitti on asetettu arvoon 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));  } }>
   
  Lähtö  
a<<1 : 20 a>>1:5>>
 
    9. instanceof-operaattori    
Operaattorin ilmentymää käytetään tyyppitarkistukseen. Sitä voidaan käyttää testaamaan, onko objekti luokan, alaluokan vai rajapinnan esiintymä. Yleinen muoto -
 
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 { }>
   
  Lähtö  
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-operaattoreiden etusija ja assosiaatio
Ensisijaisuus- ja assosiatiivisia sääntöjä käytetään käsiteltäessä hybridiyhtälöitä, joissa on useampi kuin yksi operaattorityyppi. Tällaisissa tapauksissa nämä säännöt määräävät, mikä yhtälön osa otetaan huomioon ensin, koska samalle yhtälölle voi olla useita erilaisia ​​arvostuksia. Alla olevassa taulukossa on esitetty operaattoreiden tärkeysjärjestys suuruusluokituksena laskevassa järjestyksessä siten, että ylempi edustaa suurinta ja alaosa pienintä.
 
 
 
Mielenkiintoisia kysymyksiä Java-operaattoreista
    1. Ensisijaisuus ja assosiatiivisuus:    
Usein on hämmennystä, kun on kyse hybridiyhtälöistä, jotka ovat yhtälöitä, joissa on useita operaattoreita. Ongelmana on, mikä osa ratkaistaan ​​ensin. Näissä tilanteissa on noudatettava kultaista sääntöä. Jos operaattoreilla on erilainen prioriteetti, ratkaise ensin korkeampi prioriteetti. Jos niillä on sama etusija, ratkaise assosiatiivisuuden mukaan, eli joko oikealta vasemmalle tai vasemmalta oikealle. Alla olevan ohjelman selitys on kirjoitettu hyvin itse ohjelman kommentteihin.
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.  // (* = / = %)>(+ = -) // tulostaa a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // jos sama ensisijaisuus, noudatetaan assosiatiivisia // sääntöjä.  // 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));  } }>
   
  Lähtö  
a+b/d = 20 a+b*d-e/f = 219>
 
    2. Ole kääntäjä:    
Järjestelmiemme kääntäjä käyttää lex-työkalua löytääkseen parhaan vastaavuuden tunnuksia luodessaan. Tämä aiheuttaa pienen ongelman, jos se jätetään huomiotta. Harkitse esimerkiksi väitettä    a=b+++c    ; liian monet lukijat saattavat näyttää aiheuttavan kääntäjävirheen. Mutta tämä väite on täysin oikea, koska lexin luoma merkki on a, =, b, ++, +, c. Siksi tällä lauseella on samanlainen vaikutus, kun ensin osoitetaan b+c a:lle ja sitten lisätään b:tä. Vastaavasti a=b+++++c; aiheuttaisi virheen, koska generoidut merkit ovat a, =, b, ++, ++, +, c. mikä on itse asiassa virhe, koska toisen unaarisen operandin jälkeen ei ole operandia.
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);  } }>
   
  Lähtö  
Value of a(b+c), b(b+1), c = 10, 11, 0>
 
    3. Käytä + yli ():    
Kun käytät +-operaattoria sisällä      system.out.println()      muista tehdä lisäys suluilla. Jos kirjoitamme jotain ennen yhteenlaskua, tapahtuu merkkijonojen yhteenlasku, eli summauksen assosiatiivisuus on vasemmalta oikealle, jolloin kokonaisluvut lisätään ensin merkkijonoon, joka tuottaa merkkijonon, ja merkkijonoobjektit ketjutetaan käytettäessä +. Siksi se voi luoda ei-toivottuja tuloksia.
tcp ja ip malli
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));  } }>
   
  Lähtö  
Concatenation (x+y)= 58 Addition (x+y) = 13>
 
Operaattoreiden edut Javassa
Operaattoreiden käytön edut Javassa on mainittu alla:
 
    Ilmaisukyky    : Java-operaattorit tarjoavat tiiviin ja luettavan tavan suorittaa monimutkaisia ​​laskutoimituksia ja loogisia operaatioita.
    Aikaa säästävä:    Java-operaattorit säästävät aikaa vähentämällä tiettyjen tehtävien suorittamiseen tarvittavan koodin määrää.
    Parannettu suorituskyky    : Operaattoreiden käyttö voi parantaa suorituskykyä, koska ne on usein toteutettu laitteistotasolla, mikä tekee niistä nopeampia kuin vastaava Java-koodi.
Java-operaattoreiden haitat
Java-operaattoreiden haitat on mainittu alla:
 
    Operaattorin etusija:    Java-operaattoreilla on määritelty etusija, mikä voi johtaa odottamattomiin tuloksiin, jos niitä ei käytetä oikein.
    Tyyppi Pakko    : Java suorittaa implisiittisiä tyyppimuunnoksia käytettäessä operaattoreita, mikä voi johtaa odottamattomiin tuloksiin tai virheisiin, jos sitä ei käytetä oikein.
Usein kysytyt kysymykset Java-operaattoreissa
1. Mitä ovat operaattorit Javassa esimerkillä?
Operaattorit ovat erikoissymboleja, joita käytetään tiettyjen toimintojen suorittamiseen. Esimerkiksi '+' käytetään summaukseen, jossa 5+4 palauttaa arvon 9.