OPERATØRER I JAVA - TECHCODEVIEW.COM - IT PROBLEMER OG LØSNINGER

Java tilbyder mange typer operatører, som kan bruges efter behov. De er klassificeret baseret på den funktionalitet, de leverer. I denne artikel lærer vi om Java-operatører og lærer alle deres typer.

Hvad er Java-operatørerne?

Operatører i Java er de symboler, der bruges til at udføre specifikke operationer i Java. Operatører laver opgaver som addition, multiplikation osv., som ser nemme ud, selvom implementeringen af disse opgaver er ret kompleks.

konverter dato til streng

Typer af operatører i Java

Der er flere typer operatører i Java, alle er nævnt nedenfor:

Aritmetiske operatorer
Unære operatører
Opdragsoperatør
Relationelle operatører
Logiske operatører
Ternær operatør
Bitwise operatører
Skift operatører
forekomst af operatør

1. Aritmetiske operatorer

De bruges til at udføre simple aritmetiske operationer på primitive datatyper.

*: Multiplikation
/ : Division
%: modul
+ : Tilføjelse
– : Subtraktion

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));    } }>

Produktion

a + b = 13 a - b = 7 a * b = 30 a / b = 3 a % b = 1>

2. Unære operatører

Unære operatorer behøver kun én operand. De bruges til at øge, formindske eller negere en værdi.

– : Unær minus , bruges til at negere værdierne.
+ : Unært plus angiver den positive værdi (tal er dog positive uden denne). Den udfører en automatisk konvertering til int, når typen af dens operand er byte, char eller short. Dette kaldes unær numerisk forfremmelse.
++: Increment operatør , bruges til at øge værdien med 1. Der er to varianter af inkrementoperatorer.
- Efter stigning: Værdien bruges først til at beregne resultatet og øges derefter.
- Forøgelse: Værdien øges først, og derefter beregnes resultatet.
– – : Reducer operatør , bruges til at dekrementere værdien med 1. Der er to varianter af dekrementeringsoperatorer.
- Efter nedsættelse: Værdien bruges først til at beregne resultatet og derefter dekrementeres.
- Pre-decrement: Værdien dekrementeres først, og derefter beregnes resultatet.
! : Logisk ikke operator , bruges til at invertere en boolesk værdi.

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));  } }>

Produktion

Postincrement : 10 Preincrement : 12 Postdecrement : 10 Predecrement : 8>

3. Opgaveoperatør

'=' Tildelingsoperator bruges til at tildele en værdi til enhver variabel. Det har højre-til-venstre associativitet, dvs. værdien givet på højre side af operatoren er tildelt variablen til venstre, og derfor skal højre side værdi erklæres, før du bruger den eller bør være en konstant.

Det generelle format for opgaveoperatøren er:

variable   =   value;>

I mange tilfælde kan tildelingsoperatøren kombineres med andre operatører for at bygge en kortere version af erklæringen kaldet en Sammensat erklæring . For eksempel i stedet for en = a+5, vi kan skrive a += 5.

+= , for at tilføje den venstre operand med den højre operand og derefter tildele den til variablen til venstre.
-= , for at trække den højre operand fra den venstre operand og derefter tildele den til variablen til venstre.
*= , for at gange den venstre operand med den højre operand og derefter tildele den til variablen til venstre.
/= , for at dividere den venstre operand med den højre operand og derefter tildele den til variablen til venstre.
%= , for at tildele modulo for den venstre operand med den højre operand og derefter tildele den til variablen 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  }>

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. Relationelle operatører

Disse operatorer bruges til at tjekke for relationer som lighed, større end og mindre end. De returnerer booleske resultater efter sammenligningen og bruges i vid udstrækning i looping-sætninger såvel som betingede if-else-sætninger. Det generelle format er,

variable   relation_operator   value>

Nogle af de relationelle operatorer er-

==, Lige til returnerer sandt, hvis venstre side er lig med højre side.
!=, Ikke lig med returnerer sandt, hvis venstre side ikke er lig med højre side.
<, mindre end: returnerer sandt, hvis venstre side er mindre end højre side.
<=, mindre end eller lig med returnerer sandt, hvis venstre side er mindre end eller lig med højre side.
>, større end: returnerer sandt, hvis venstre side er større end højre side.
>=, større end eller lig med returnerer sandt, hvis venstre side er større end eller lig med højre 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));  } }>

Produktion

a>b: sand a = b: sand a<= b: false a == c: false a != c: true>

5. Logiske operatører

Disse operatorer bruges til at udføre logiske OG- og logiske ELLER-operationer, dvs. en funktion, der ligner AND-port og OR-port i digital elektronik. En ting at huske på er, at den anden betingelse ikke evalueres, hvis den første er falsk, dvs. den har en kortslutningseffekt. Bruges i vid udstrækning til at teste for flere betingelser for at træffe en beslutning. Java har også Logical NOT, som returnerer sandt, når betingelsen er falsk og omvendt

Betingede operatører er:

&&, logisk OG: returnerer sand, når begge betingelser er sande.
||, logisk ELLER: returnerer sand, hvis mindst én betingelse er sand.
!, Logisk IKKE: returnerer sandt, når en betingelse er falsk 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)  }>

Produktion

x && y: false x || y: true !x: false>

6. Ternær operatør

Den ternære operator er en stenografisk version af if-else-sætningen. Den har tre operander og deraf navnet Ternary.

Det generelle format er:

condition   ?   if true   :   if false>

Ovenstående sætning betyder, at hvis betingelsen vurderes til at være sand, skal du udføre sætningerne efter '?', ellers udføre sætningerne efter ':'.

Eksempel:

hvad er uri

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 af tre tal = ' + resultat);  } }>

Produktion

Max of three numbers = 30>

7. Bitvise operatører

Disse operatorer bruges til at udføre manipulation af individuelle bits af et tal. De kan bruges med enhver af heltaltyperne. De bruges, når der udføres opdaterings- og forespørgselsoperationer af de binære indekserede træer.

&, Bitwise AND operator: returnerer bit for bit OG af inputværdier.
|, Bitwise OR operator: returnerer bit for bit ELLER af inputværdier.
^, Bitwise XOR-operator: returnerer bit-for-bit XOR af inputværdier.
~, Bitwise Supplement Operator: Dette er en unær operator, som returnerer ens komplementrepræsentation af inputværdien, dvs. med alle bits inverteret.

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 og>>> 1: 6>>>     8. Skifteoperatører    
Disse operatorer bruges til at flytte bits af et tal til venstre eller højre, hvorved tallet henholdsvis ganges eller divideres med to. De kan bruges, når vi skal gange eller dividere et tal med to. Generelt format-
     <<, venstreskiftsoperatør:    flytter bits af tallet til venstre og udfylder 0 på tomrum tilbage som et resultat. Lignende effekt som at gange tallet med en eller anden potens af to.    >>, Signeret højreskifteoperatør:    flytter bits af tallet til højre og udfylder 0 på tomrum til venstre som et resultat. Bitten længst til venstre afhænger af fortegnet for det indledende tal. Svarende effekt til at dividere tallet med en vis potens af to.
    >>>, usigneret højreskiftsoperatør:    flytter bits af tallet til højre og udfylder 0 på tomrum til venstre som et resultat. Bit længst til venstre er sat 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));  } }>
   
  Produktion  a<<1 : 20 a>>1 : 5>>
     9. forekomst af operatør    
Operatørens instans bruges til typekontrol. Det kan bruges til at teste, om et objekt er en forekomst af en klasse, en underklasse eller en grænseflade. 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 { }>
   
  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>
 Forrang og associativitet for Java-operatører
Forrang og associative regler bruges, når der er tale om hybride ligninger, der involverer mere end én type operator. I sådanne tilfælde bestemmer disse regler, hvilken del af ligningen der skal overvejes først, da der kan være mange forskellige værdiansættelser for den samme ligning. Tabellen nedenfor viser operatørernes forrang i faldende rækkefølge som størrelse, hvor toppen repræsenterer den højeste prioritet, og den nederste viser den laveste prioritet.
  
 Interessante spørgsmål om Java-operatører
    1. Forrang og associativitet:    
Der er ofte forvirring, når det kommer til hybride ligninger, som er ligninger med flere operatorer. Problemet er, hvilken del der skal løses først. Der er en gylden regel at følge i disse situationer. Hvis operatørerne har forskellig prioritet, løses den højere prioritet først. Hvis de har samme forrang, løs efter associativitet, det vil sige enten fra højre mod venstre eller fra venstre mod højre. Forklaringen af nedenstående program er velskrevet 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.  // (* = / = %)>(+ = -) // udskriver a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // hvis samme forrang, så følges associative // 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. Vær en compiler:    
Compileren i vores systemer bruger et lex-værktøj til at matche det største match, når der genereres tokens. Dette skaber lidt af et problem, hvis det overses. Overvej for eksempel udsagnet    a=b+++c    ; for mange af læserne kan synes at skabe en kompileringsfejl. Men dette udsagn er helt korrekt, da tokenet skabt af lex er a, =, b, ++, +, c. Derfor har denne sætning en lignende effekt ved først at tildele b+c til a og derefter øge b. Tilsvarende er a=b+++++c; ville generere en fejl, da de tokens, der genereres, er a, =, b, ++, ++, +, c. hvilket faktisk er en fejl, da der ikke er nogen operand efter den anden unære operand.
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. Brug + over ():    
Når du bruger +-operatoren indeni      system.out.println()      sørg for at lave addition ved hjælp af parentes. Hvis vi skriver noget, før vi laver addition, finder strengaddition sted, det vil sige, at tilføjelsesassociativitet er venstre mod højre, og derfor tilføjes heltal til en streng, der først producerer en streng, og strengobjekter sammenkædes, når du bruger +. Derfor kan det skabe 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));  } }>
   
  Produktion  Concatenation (x+y)= 58 Addition (x+y) = 13>
 Fordele ved operatører i Java
Fordelene ved at bruge operatører i Java er nævnt nedenfor:
     Udtryksevne    : Operatører i Java giver en kortfattet og læsbar måde at udføre komplekse beregninger og logiske operationer på.
    Tidsbesparende:    Operatører i Java sparer tid ved at reducere mængden af kode, der kræves for at udføre visse opgaver.
    Forbedret ydeevne    : Brug af operatører kan forbedre ydeevnen, fordi de ofte implementeres på hardwareniveau, hvilket gør dem hurtigere end tilsvarende Java-kode.
Ulemper ved operatører i Java
Ulemperne ved operatører i Java er nævnt nedenfor:
     Operatør forrang:    Operatører i Java har en defineret forrang, som kan føre til uventede resultater, hvis de ikke bruges korrekt.
    Type tvang    : Java udfører implicitte typekonverteringer ved brug af operatører, hvilket kan føre til uventede resultater eller fejl, hvis det ikke bruges korrekt.
Ofte stillede spørgsmål i Java-operatører
1. Hvad er operatører i Java med eksempel?
Operatører er de specielle symboler, der bruges til at udføre visse operationer. For eksempel bruges '+' til addition, hvor 5+4 returnerer værdien 9.