logo

TechCodeview

Operatører i Java

Java tilbyr mange typer operatører som kan brukes etter behov. De er klassifisert basert på funksjonaliteten de tilbyr. I denne artikkelen vil vi lære om Java-operatører og lære alle deres typer.

Hva er Java-operatørene?

Operatører i Java er symbolene som brukes for å utføre spesifikke operasjoner i Java. Operatører lager oppgaver som addisjon, multiplikasjon osv. som ser enkle ut, selv om implementeringen av disse oppgavene er ganske komplisert.

indeks over listen

Typer operatører i Java

Det er flere typer operatører i Java, alle er nevnt nedenfor:



  1. Aritmetiske operatorer
  2. Unære operatører
  3. Oppdragsoperatør
  4. Relasjonelle operatører
  5. Logiske operatører
  6. Ternær operatør
  7. Bitvise operatører
  8. Skiftoperatører
  9. forekomst av operatør

1. Aritmetiske operatorer

De brukes til å utføre enkle aritmetiske operasjoner på primitive datatyper.

  • *: Multiplikasjon
  • / : Inndeling
  • %: Modul
  • + : Addisjon
  • – : Subtraksjon

Eksempel:

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

2. Unære operatører

Unære operatører trenger bare én operand. De brukes til å øke, redusere eller negere en verdi.

  • – : Unært minus , brukes til å negere verdiene.
  • + : Unært pluss indikerer den positive verdien (tall er imidlertid positive uten dette). Den utfører en automatisk konvertering til int når typen av operanden er byte, char eller short. Dette kalles unær numerisk forfremmelse.
  • ++: Inkrementoperatør , brukes for å øke verdien med 1. Det finnes to varianter av inkrementoperatorer.
    • Etterøkning: Verdien brukes først for å beregne resultatet og økes deretter.
    • Forøkning: Verdien økes først, og deretter beregnes resultatet.
  • – – : Reduser operatør , brukes for å redusere verdien med 1. Det finnes to varianter av dekrementeringsoperatorer.
    • Etter dekrementering: Verdien brukes først for å beregne resultatet og deretter dekrementeres.
    • Pre-dekrement: Verdien dekrementeres først, og deretter beregnes resultatet.
  • ! : Logisk ikke operatør , brukes til å invertere en boolsk verdi.

Eksempel:

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

3. Oppdragsoperatør

'=' Tilordningsoperator brukes til å tilordne en verdi til en hvilken som helst variabel. Den har assosiativitet fra høyre til venstre, det vil si at verdien gitt på høyre side av operatøren er tilordnet variabelen til venstre, og derfor må verdien på høyre side deklareres før du bruker den eller bør være en konstant.

Det generelle formatet til oppdragsoperatøren er:

variable   =   value;>

I mange tilfeller kan oppdragsoperatøren kombineres med andre operatører for å bygge en kortere versjon av setningen kalt en Sammensatt erklæring . For eksempel, i stedet for en = a+5, vi kan skrive a += 5.

  • += , for å legge til venstre operand med høyre operand og deretter tilordne den til variabelen til venstre.
  • -= , for å trekke den høyre operanden fra den venstre operanden og deretter tilordne den til variabelen til venstre.
  • *= , for å multiplisere den venstre operanden med den høyre operanden og deretter tilordne den til variabelen til venstre.
  • /= , for å dele den venstre operanden med den høyre operanden og deretter tilordne den til variabelen til venstre.
  • %= , for å tilordne modulo til venstre operand med høyre operand og deretter tilordne den til variabelen til venstre.

Eksempel:

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

Disse operatørene brukes til å se etter relasjoner som likhet, større enn og mindre enn. De returnerer boolske resultater etter sammenligningen og brukes mye i looping-setninger så vel som betingede if-else-setninger. Det generelle formatet er,

variable   relation_operator   value>

Noen av relasjonsoperatørene er-

  • ==, lik returnerer sant hvis venstre side er lik høyre side.
  • !=, Ikke lik returnerer sant hvis venstre side ikke er lik høyre side.
  • <, mindre enn: returnerer sant hvis venstre side er mindre enn høyre side.
  • <=, mindre enn eller lik returnerer sant hvis venstre side er mindre enn eller lik høyre side.
  • >, større enn: returnerer sant hvis venstre side er større enn høyre side.
  • >=, Større enn eller lik returnerer sant hvis venstre side er større enn eller lik høyre side.

Eksempel:

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

5. Logiske operatører

Disse operatørene brukes til å utføre logiske OG- og logiske ELLER-operasjoner, dvs. en funksjon som ligner på OG-port og ELLER-port i digital elektronikk. En ting å huske på er at den andre tilstanden ikke blir evaluert hvis den første er falsk, dvs. den har en kortslutningseffekt. Brukes mye for å teste for flere forhold for å ta en beslutning. Java har også Logical NOT, som returnerer sant når betingelsen er usann og omvendt

Betingede operatører er:

  • &&, logisk OG: returnerer sant når begge betingelsene er sanne.
  • ||, logisk ELLER: returnerer sant hvis minst én betingelse er sann.
  • !, Logisk IKKE: returnerer sant når en betingelse er usann og omvendt

Eksempel:

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

6. Ternær operatør

Den ternære operatoren er en stenografi av if-else-setningen. Den har tre operander og derav navnet Ternary.

Det generelle formatet er:

condition   ?   if true   :   if false>

Utsagnet ovenfor betyr at hvis betingelsen evalueres til sann, så utfør utsagnene etter '?' ellers utfør utsagnene etter ':'.

Eksempel:

hva er rom
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('Maks av tre tall = ' + resultat);  } }>
Produksjon 
Max of three numbers = 30>

7. Bitvise operatører

Disse operatørene brukes til å utføre manipulering av individuelle biter av et tall. De kan brukes med alle heltallstypene. De brukes når du utfører oppdaterings- og spørringsoperasjoner av de binære indekserte trærne.

  • &, Bitvis OG-operator: returnerer bit for bit OG av inngangsverdier.
  • |, Bitvis OR-operator: returnerer bit for bit ELLER av inngangsverdier.
  • ^, Bitvis XOR-operator: returnerer bit-for-bit XOR av inngangsverdier.
  • ~, Bitwise Complement Operator: Dette er en unær operator som returnerer ens komplementrepresentasjon av inngangsverdien, dvs. med alle biter invertert.
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  }>
Produksjon 
d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1: 6 og>>> 1: 6>>> 
    8. Skiftoperatører    
Disse operatorene brukes til å flytte bitene til et tall til venstre eller høyre, og dermed multiplisere eller dele tallet med to, henholdsvis. De kan brukes når vi skal gange eller dele et tall med to. Generelt format-
     <<, venstreskiftoperatør:    flytter bitene av tallet til venstre og fyller 0 på tomrom igjen som et resultat. Lignende effekt som å multiplisere tallet med en potens av to.
  •     >>, Signert høyre skiftoperatør:    flytter bitene av tallet til høyre og fyller 0 på tomrom til venstre som et resultat. Biten lengst til venstre avhenger av tegnet til det første tallet. Liknende effekt som å dele tallet med en potens av to.
  •     >>>, usignert høyreskiftoperatør:    flytter bitene av tallet til høyre og fyller 0 på tomrom til venstre som et resultat. Biten lengst til venstre er satt til 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));  } }>
           
      Produksjon  
    a<<1 : 20 a>>1 : 5>>
     
        9. forekomst av operatør    
    Forekomsten til operatøren brukes til typekontroll. Den kan brukes til å teste om et objekt er en forekomst av en klasse, en underklasse eller et grensesnitt. Generelt 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 { }>
           
      Produksjon  
    obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
     
    Forrang og assosiativitet for Java-operatører
    Forrang og assosiative regler brukes når man arbeider med hybride ligninger som involverer mer enn én type operator. I slike tilfeller bestemmer disse reglene hvilken del av ligningen som skal vurderes først, da det kan være mange forskjellige verdivurderinger for samme ligning. Tabellen nedenfor viser prioriteten til operatører i synkende rekkefølge som størrelse, der toppen representerer høyeste prioritet og bunnen viser laveste prioritet.
     
     Forrang og assosiativitet for operatører i Java
     
    Interessante spørsmål om Java-operatører
        1. Forrang og assosiativitet:    
    Det er ofte forvirring når det kommer til hybride ligninger som er ligninger som har flere operatorer. Problemet er hvilken del som skal løses først. Det er en gylden regel å følge i disse situasjonene. Hvis operatørene har forskjellig prioritet, løs den høyere prioritet først. Hvis de har samme forrang, løs i henhold til assosiativitet, det vil si enten fra høyre til venstre eller fra venstre til høyre. Forklaringen til programmet nedenfor er godt skrevet i kommentarer i selve 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));  // hvis samme prioritet, følges assosiative //-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));  } }>
           
      Produksjon  
    a+b/d = 20 a+b*d-e/f = 219>
     
        2. Vær en kompilator:    
    Kompilatoren i systemene våre bruker et lex-verktøy for å matche den største matchen når den genererer tokens. Dette skaper litt av et problem hvis det overses. Tenk for eksempel på uttalelsen    a=b+++c    ; for mange av leserne kan se ut til å lage en kompilatorfeil. Men dette utsagnet er helt korrekt, siden tokenet som er opprettet av lex er a, =, b, ++, +, c. Derfor har denne setningen en lignende effekt ved å først tilordne b+c til a og deretter øke b. På samme måte, a=b+++++c; vil generere en feil ettersom symbolene som genereres er a, =, b, ++, ++, +, c. som faktisk er en feil siden det ikke er noen operand etter den andre unære 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);  } }>
           
      Produksjon  
    Value of a(b+c), b(b+1), c = 10, 11, 0>
     
        3. Bruk + over ():    
    Når du bruker +-operatøren inne      system.out.println()      sørg for å legge til ved hjelp av parentes. Hvis vi skriver noe før vi legger til, vil strengaddisjon finne sted, det vil si at assosiativiteten til addisjonen er venstre mot høyre, og derfor legges heltall til en streng som først produserer en streng, og strengobjekter samles når du bruker +. Derfor kan det skape uønskede resultater.
    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));  } }>
           
      Produksjon  
    Concatenation (x+y)= 58 Addition (x+y) = 13>
     
    Fordeler med operatører i Java
    Fordelene ved å bruke operatører i Java er nevnt nedenfor:
     
    1.     Uttrykksevne    : Operatører i Java gir en kortfattet og lesbar måte å utføre komplekse beregninger og logiske operasjoner på.
    2.     Tidssparende:    Operatører i Java sparer tid ved å redusere mengden kode som kreves for å utføre visse oppgaver.
    3.     Forbedret ytelse    : Bruk av operatører kan forbedre ytelsen fordi de ofte implementeres på maskinvarenivå, noe som gjør dem raskere enn tilsvarende Java-kode.
    Ulemper med operatører i Java
    Ulempene med operatører i Java er nevnt nedenfor:
     
    1.     Operatørprioritet:    Operatører i Java har en definert forrang, noe som kan føre til uventede resultater hvis de ikke brukes riktig.
    2.     Type tvang    : Java utfører implisitte typekonverteringer ved bruk av operatører, noe som kan føre til uventede resultater eller feil hvis den ikke brukes riktig.
    Vanlige spørsmål i Java Operators
    1. Hva er operatører i Java med eksempel?
    Operatører er de spesielle symbolene som brukes til å utføre visse operasjoner. For eksempel brukes '+' for addisjon der 5+4 vil returnere verdien 9.