logo

TechCodeview

Operatörer i Java

Java tillhandahåller många typer av operatörer som kan användas efter behov. De klassificeras baserat på den funktionalitet de tillhandahåller. I den här artikeln kommer vi att lära oss om Java-operatörer och lära oss alla deras typer.

Vilka är Java-operatörer?

Operatörer i Java är de symboler som används för att utföra specifika operationer i Java. Operatörer gör uppgifter som addition, multiplikation etc som ser enkla ut även om genomförandet av dessa uppgifter är ganska komplicerat.



Typer av operatörer i Java

Det finns flera typer av operatörer i Java, alla nämns nedan:

  1. Aritmetiska operatorer
  2. Unära operatörer
  3. Uppdragsoperatör
  4. Relationella operatörer
  5. Logiska operatörer
  6. Ternär operatör
  7. Bitwise operatörer
  8. Skiftoperatörer
  9. instans av operatör

1. Aritmetiska operatorer

De används för att utföra enkla aritmetiska operationer på primitiva datatyper.

  • *: Multiplikation
  • / : Division
  • %: Modul
  • + : Tillägg
  • – : Subtraktion

Exempel:



Java 
// 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));    } }>
Produktion 
a + b = 13 a - b = 7 a * b = 30 a / b = 3 a % b = 1>

2. Unära operatörer

Unära operatorer behöver bara en operand. De används för att öka, minska eller förneka ett värde.

  • – : Unär minus , används för att negera värdena.
  • + : Unärt plus indikerar det positiva värdet (siffror är dock positiva utan detta). Den utför en automatisk konvertering till int när typen av dess operand är byte, char eller short. Detta kallas unär numerisk befordran.
  • ++: Öka operatör , används för att öka värdet med 1. Det finns två varianter av inkrementoperatorer.
    • Efterökning: Värdet används först för att beräkna resultatet och inkrementeras sedan.
    • Förökning: Värdet ökas först och sedan beräknas resultatet.
  • – – : Minska operatorn , används för att minska värdet med 1. Det finns två varianter av sänkningsoperatorer.
    • Efter minskning: Värdet används först för att beräkna resultatet och minskas sedan.
    • Pre-Decrement: Värdet minskas först och sedan beräknas resultatet.
  • ! : Logisk inte operator , används för att invertera ett booleskt värde.

Exempel:

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));  } }>
Produktion 
Postincrement : 10 Preincrement : 12 Postdecrement : 10 Predecrement : 8>

3. Uppdragsoperatör

'=' Tilldelningsoperator används för att tilldela ett värde till valfri variabel. Den har höger-till-vänster-associativitet, det vill säga värdet som ges på höger sida av operatorn tilldelas variabeln till vänster, och därför måste höger-sidans värde deklareras innan det används eller bör vara en konstant.



Det allmänna formatet för uppdragsoperatören är:

variable   =   value;>

I många fall kan uppdragsoperatören kombineras med andra operatörer för att bygga en kortare version av uttalandet som kallas en Sammansatt uttalande . Till exempel, istället för en = a+5, vi kan skriva a += 5.

siffror för alfabetet
  • += , för att lägga till den vänstra operanden med den högra operanden och sedan tilldela den till variabeln till vänster.
  • -= , för att subtrahera den högra operanden från den vänstra operanden och sedan tilldela den till variabeln till vänster.
  • *= , för att multiplicera den vänstra operanden med den högra operanden och sedan tilldela den till variabeln till vänster.
  • /= , för att dividera den vänstra operanden med den högra operanden och sedan tilldela den till variabeln till vänster.
  • %= , för att tilldela den vänstra operandens modulo med den högra operanden och sedan tilldela den till variabeln till vänster.

Exempel:

Java 
// Java Program to implement // Assignment Operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  = 0b1100: ' + (f  }>
Produktion 
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. Relationella operatörer

Dessa operatorer används för att kontrollera relationer som likhet, större än och mindre än. De returnerar booleska resultat efter jämförelsen och används flitigt i looping-satser såväl som villkorliga if-else-satser. Det allmänna formatet är,

variable   relation_operator   value>

Några av de relationella operatorerna är-

  • ==, Lika med returnerar sant om den vänstra sidan är lika med den högra.
  • !=, Inte lika med returnerar sant om den vänstra sidan inte är lika med den högra.
  • <, mindre än: returnerar sant om den vänstra sidan är mindre än den högra.
  • <=, mindre än eller lika med returnerar sant om den vänstra sidan är mindre än eller lika med den högra.
  • >, Större än: returnerar sant om den vänstra sidan är större än den högra.
  • >=, större än eller lika med returnerar sant om den vänstra sidan är större än eller lika med den högra.

Exempel:

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));  } }>
Produktion 
a>b: sant a = b: sant a<= b: false a == c: false a != c: true>

5. Logiska operatörer

Dessa operatorer används för att utföra logiska OCH- och logiska ELLER-operationer, dvs. en funktion som liknar OCH-grind och ELLER-grind i digital elektronik. En sak att tänka på är att det andra tillståndet inte utvärderas om det första är falskt, dvs det har en kortslutningseffekt. Används flitigt för att testa för flera förutsättningar för att fatta ett beslut. Java har också Logical NOT, som returnerar sant när villkoret är falskt och vice versa

Villkorsoperatörer är:

  • &&, logiskt OCH: returnerar sant när båda villkoren är sanna.
  • ||, logiskt ELLER: returnerar sant om minst ett villkor är sant.
  • !, logiskt INTE: returnerar sant när ett villkor är falskt och vice versa

Exempel:

Java 
// Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>
Produktion 
x && y: false x || y: true !x: false>

6. Ternär operatör

Den ternära operatorn är en förkortad version av if-else-satsen. Den har tre operander och därav namnet Ternary.

Det allmänna formatet är:

condition   ?   if true   :   if false>

Ovanstående sats betyder att om villkoret utvärderas till sant, kör satserna efter '?' annars kör du satserna efter ':'.

Exempel:

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) ? före Kristus);  System.out.println('Max av tre siffror = ' + resultat);  } }>
Produktion 
Max of three numbers = 30>

7. Bitvisa operatörer

Dessa operatorer används för att utföra manipulering av enskilda bitar av ett nummer. De kan användas med alla heltalstyper. De används när du utför uppdaterings- och frågeoperationer för de binära indexerade träden.

  • &, Bitvis AND-operator: returnerar bit för bit OCH av ingångsvärden.
  • |, Bitvis OR-operator: returnerar bit för bit ELLER av ingångsvärden.
  • ^, Bitvis XOR-operator: returnerar bit-för-bit XOR av ingångsvärden.
  • ~, Bitwise Complement Operator: Detta är en unär operator som returnerar ettans komplementrepresentation av ingångsvärdet, d.v.s. med alla bitar inverterade.
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  }>
Produktion 
d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1: 6 och>>> 1: 6>>> 
    8. Växlingsoperatörer    
Dessa operatorer används för att flytta bitarna i ett tal åt vänster eller höger, och därigenom multiplicera eller dividera talet med två respektive. De kan användas när vi ska multiplicera eller dividera ett tal med två. Allmänt format-
     <<, Vänsterskiftsoperatör:    skiftar bitarna i numret åt vänster och fyller 0 på tomrum kvar som ett resultat. Liknande effekt som att multiplicera talet med någon potens av två.
  •     >>, Signerad högerväxlingsoperatör:    skiftar bitarna i numret åt höger och fyller 0 på tomrum till vänster som ett resultat. Biten längst till vänster beror på tecknet för det initiala talet. Liknande effekt som att dividera talet med någon potens av två.
  •     >>>, osignerad högerskiftsoperatör:    skiftar bitarna i numret åt höger och fyller 0 på tomrum till vänster som ett resultat. Biten längst till vänster är satt till 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));  } }>
           
      Produktion  
    a<<1 : 20 a>>1 : 5>>
     
        9. instans av operatör    
    Operatörsinstansen används för typkontroll. Den kan användas för att testa om ett objekt är en instans av en klass, en underklass eller ett gränssnitt. Allmänt format-
     
    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 { }>
           
      Produktion  
    obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
     
    Företräde och associativitet för Java-operatörer
    Precedens och associativa regler används när man hanterar hybridekvationer som involverar mer än en typ av operator. I sådana fall avgör dessa regler vilken del av ekvationen som ska beaktas först, eftersom det kan finnas många olika värderingar för samma ekvation. Tabellen nedan visar prioriteten för operatorer i fallande ordning som magnitud, där toppen representerar högsta prioritet och botten visar lägst prioritet.
     
     Företräde och associativitet för operatörer i Java
     
    Intressanta frågor om Java-operatörer
        1. Företräde och associativitet:    
    Det finns ofta förvirring när det gäller hybridekvationer som är ekvationer som har flera operatorer. Problemet är vilken del som ska lösas först. Det finns en gyllene regel att följa i dessa situationer. Om operatorerna har olika prioritet, lös den högre prioritet först. Om de har samma företräde, lös enligt associativitet, det vill säga antingen från höger till vänster eller från vänster till höger. Förklaringen till programmet nedan är välskriven i kommentarerna i själva programmet.
    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.  // (* = / = %)>(+ = -) // skriver ut a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // om samma prioritet följs associativa //-regler.  // 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));  } }>
           
      Produktion  
    a+b/d = 20 a+b*d-e/f = 219>
     
        2. Var en kompilator:    
    Kompilatorn i våra system använder ett lex-verktyg för att matcha den största matchningen när tokens genereras. Detta skapar lite av ett problem om det förbises. Tänk till exempel på uttalandet    a=b+++c    ; för många av läsarna kan tyckas skapa ett kompilatorfel. Men detta påstående är helt korrekt eftersom token som skapas av lex är a, =, b, ++, +, c. Därför har detta uttalande en liknande effekt av att först tilldela b+c till a och sedan öka b. På liknande sätt, a=b+++++c; skulle generera ett fel eftersom de tokens som genereras är a, =, b, ++, ++, +, c. vilket faktiskt är ett fel eftersom det inte finns någon operand efter den andra unära operanden.
    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);  } }>
           
      Produktion  
    Value of a(b+c), b(b+1), c = 10, 11, 0>
     
        3. Använd + över ():    
    När du använder +-operatorn inuti      system.out.println()      se till att göra addition med parentes. Om vi ​​skriver något innan vi gör addition, så sker strängaddition, det vill säga associativiteten för addition läggs från vänster till höger, och därför läggs heltal till en sträng som först producerar en sträng, och strängobjekt sammanlänkas när + används. Därför kan det skapa oönskade resultat.
    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));  } }>
           
      Produktion  
    Concatenation (x+y)= 58 Addition (x+y) = 13>
     
    Fördelar med operatörer i Java
    Fördelarna med att använda operatörer i Java nämns nedan:
     
    1.     Uttrycksförmåga    : Operatörer i Java ger ett kortfattat och läsbart sätt att utföra komplexa beräkningar och logiska operationer.
    2.     Tids sparande:    Operatörer i Java sparar tid genom att minska mängden kod som krävs för att utföra vissa uppgifter.
    3.     Förbättrad prestanda    : Användning av operatörer kan förbättra prestandan eftersom de ofta implementeras på hårdvarunivå, vilket gör dem snabbare än motsvarande Java-kod.
    Nackdelar med operatörer i Java
    Nackdelarna med Operatörer i Java nämns nedan:
     
    1.     Operatörsföreträde:    Operatörer i Java har en definierad prioritet, vilket kan leda till oväntade resultat om de inte används på rätt sätt.
    2.     Typ tvång    : Java utför implicita typkonverteringar när du använder operatorer, vilket kan leda till oväntade resultat eller fel om det inte används på rätt sätt.
    Vanliga frågor i Java Operators
    1. Vad är operatorer i Java med exempel?
    Operatörer är de speciella symboler som används för att utföra vissa operationer. Till exempel används '+' för addition där 5+4 returnerar värdet 9.