OPERATOREN IN JAVA - TECHCODEVIEW.COM - IT-PROBLEME UND LÖSUNGEN

Java bietet viele Arten von Operatoren, die je nach Bedarf verwendet werden können. Sie werden nach der von ihnen bereitgestellten Funktionalität klassifiziert. In diesem Artikel lernen wir Java-Operatoren und alle ihre Typen kennen.

Was sind die Java-Operatoren?

Operatoren in Java sind die Symbole, die zum Ausführen bestimmter Operationen in Java verwendet werden. Operatoren führen Aufgaben wie Addition, Multiplikation usw. aus, die einfach aussehen, obwohl die Implementierung dieser Aufgaben recht komplex ist.

Arten von Operatoren in Java

In Java gibt es mehrere Arten von Operatoren, die alle im Folgenden aufgeführt sind:

Rechenzeichen
Unäre Operatoren
Aufgabenverwalter
Vergleichsoperatoren
Logische Operatoren
Ternärer Operator
Bitweise Operatoren
Schichtoperatoren
Instanz des Operators

1. Arithmetische Operatoren

Sie werden verwendet, um einfache arithmetische Operationen an primitiven Datentypen durchzuführen.

* : Multiplikation
/ : Aufteilung
%: Modul
+ : Zusatz
– : Subtraktion

Beispiel:

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

Ausgabe

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

2. Unäre Operatoren

Unäre Operatoren benötigen nur einen Operanden. Sie werden verwendet, um einen Wert zu erhöhen, zu verringern oder zu negieren.

– : Unäres Minus , wird zum Negieren der Werte verwendet.
+ : Unäres Plus gibt den positiven Wert an (Zahlen sind jedoch auch ohne diesen positiv). Es führt eine automatische Konvertierung in int durch, wenn der Typ seines Operanden byte, char oder short ist. Dies wird als unäre numerische Förderung bezeichnet.
++: Inkrementoperator , wird zum Erhöhen des Werts um 1 verwendet. Es gibt zwei Arten von Inkrementoperatoren.
- Post-Inkrement: Der Wert wird zunächst zur Berechnung des Ergebnisses verwendet und dann erhöht.
- Vorinkrement: Der Wert wird zuerst erhöht und dann das Ergebnis berechnet.
– – : Dekrementoperator , wird zum Dekrementieren des Werts um 1 verwendet. Es gibt zwei Arten von Dekrementierungsoperatoren.
- Post-Dekrement: Der Wert wird zunächst zur Berechnung des Ergebnisses verwendet und dann dekrementiert.
- Vordekrement: Der Wert wird zuerst dekrementiert und dann das Ergebnis berechnet.
! : Logischer Nicht-Operator , wird zum Invertieren eines booleschen Werts verwendet.

Beispiel:

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

Ausgabe

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

3. Zuweisungsbetreiber

'=' Der Zuweisungsoperator wird verwendet, um einer Variablen einen Wert zuzuweisen. Es verfügt über eine Assoziativität von rechts nach links, d. h. der auf der rechten Seite des Operators angegebene Wert wird der Variablen auf der linken Seite zugewiesen. Daher muss der Wert auf der rechten Seite vor seiner Verwendung deklariert werden oder sollte eine Konstante sein.

Java-Schalter

Das allgemeine Format des Zuweisungsoperators ist:

variable   =   value;>

In vielen Fällen kann der Zuweisungsoperator mit anderen Operatoren kombiniert werden, um eine kürzere Version der Anweisung namens a zu erstellen Zusammengesetzte Aussage . Zum Beispiel anstelle von a = a+5, wir können a schreiben += 5.

+= , um den linken Operanden mit dem rechten Operanden zu addieren und ihn dann der Variablen auf der linken Seite zuzuweisen.
-= , um den rechten Operanden vom linken Operanden zu subtrahieren und ihn dann der Variablen auf der linken Seite zuzuweisen.
*= , um den linken Operanden mit dem rechten Operanden zu multiplizieren und ihn dann der Variablen auf der linken Seite zuzuweisen.
/= , um den linken Operanden durch den rechten Operanden zu dividieren und ihn dann der Variablen auf der linken Seite zuzuweisen.
%= , um das Modulo des linken Operanden dem rechten Operanden zuzuweisen und es dann der Variablen auf der linken Seite zuzuweisen.

Beispiel:

Java

 // Java Program to implement // Assignment Operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  = 0b1100: ' + (f  }>

Ausgabe

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. Vergleichsoperatoren

Diese Operatoren werden verwendet, um Beziehungen wie Gleichheit, Größer als und Kleiner als zu prüfen. Sie geben nach dem Vergleich boolesche Ergebnisse zurück und werden häufig in Schleifenanweisungen sowie bedingten if-else-Anweisungen verwendet. Das allgemeine Format ist:

variable   relation_operator   value>

Einige der Vergleichsoperatoren sind:

Python speichert JSON in einer Datei

==, Gleich gibt true zurück, wenn die linke Seite gleich der rechten Seite ist.
!=, ungleich gibt true zurück, wenn die linke Seite nicht mit der rechten Seite übereinstimmt.
<, kleiner als: gibt true zurück, wenn die linke Seite kleiner ist als die rechte Seite.
<=, kleiner oder gleich gibt true zurück, wenn die linke Seite kleiner oder gleich der rechten Seite ist.
>, Größer als: gibt true zurück, wenn die linke Seite größer als die rechte Seite ist.
>=, Größer als oder gleich gibt true zurück, wenn die linke Seite größer oder gleich der rechten Seite ist.

Beispiel:

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

Ausgabe

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

5. Logische Operatoren

Diese Operatoren werden verwendet, um logische UND- und logische ODER-Operationen durchzuführen, d. h. eine Funktion, die dem UND-Gatter und dem ODER-Gatter in der digitalen Elektronik ähnelt. Zu beachten ist, dass die zweite Bedingung nicht ausgewertet wird, wenn die erste falsch ist, also eine kurzschließende Wirkung hat. Wird häufig verwendet, um verschiedene Bedingungen für die Entscheidungsfindung zu testen. Java verfügt außerdem über ein logisches NOT, das „true“ zurückgibt, wenn die Bedingung falsch ist und umgekehrt

Bedingungsoperatoren sind:

&&, Logisches UND: gibt true zurück, wenn beide Bedingungen wahr sind.
||, Logisches ODER: gibt true zurück, wenn mindestens eine Bedingung wahr ist.
!, Logisches NICHT: gibt true zurück, wenn eine Bedingung falsch ist und umgekehrt

Beispiel:

Java

 // Java Program to implemenet // Logical operators import java.io.*; // Driver Class class GFG {  // Main Function  public static void main (String[] args)  }>

Ausgabe

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

6. Ternärer Operator

Der ternäre Operator ist eine Kurzversion der if-else-Anweisung. Es hat drei Operanden und daher der Name Ternary.

Das allgemeine Format ist:

condition   ?   if true   :   if false>

Die obige Anweisung bedeutet, dass, wenn die Bedingung wahr ist, die Anweisungen nach dem „?“ ausgeführt werden, andernfalls die Anweisungen nach dem „:“ ausgeführt werden.

Beispiel:

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('Maximal drei Zahlen = ' + Ergebnis);  } }>

Ausgabe

Max of three numbers = 30>

7. Bitweise Operatoren

Mit diesen Operatoren werden einzelne Bits einer Zahl manipuliert. Sie können mit jedem Integer-Typ verwendet werden. Sie werden bei der Durchführung von Aktualisierungs- und Abfragevorgängen der binär indizierten Bäume verwendet.

&, bitweiser UND-Operator: Gibt bitweise UND von Eingabewerten zurück.
|, Bitweiser ODER-Operator: Gibt eine bitweise ODER-Verknüpfung der Eingabewerte zurück.
^, Bitweiser XOR-Operator: Gibt eine bitweise XOR-Verknüpfung von Eingabewerten zurück.
~, Bitweiser Komplementoperator: Dies ist ein unärer Operator, der die Einserkomplementdarstellung des Eingabewerts zurückgibt, d. h. mit allen Bits invertiert.

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

Ausgabe

d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1:6 und>>> 1:6>>>     8. Schichtoperatoren    
Diese Operatoren werden verwendet, um die Bits einer Zahl nach links oder rechts zu verschieben und so die Zahl jeweils durch zwei zu multiplizieren oder zu dividieren. Sie können verwendet werden, wenn wir eine Zahl mit zwei multiplizieren oder dividieren müssen. Allgemeines Format
     <<, Linksverschiebungsoperator:    verschiebt die Bits der Zahl nach links und füllt die dadurch verbleibenden Lücken mit 0 auf. Ähnlicher Effekt wie die Multiplikation der Zahl mit einer Zweierpotenz.    >>, Signierter Rechtsverschiebungsoperator:    verschiebt die Bits der Zahl nach rechts und füllt dadurch die Lücken links mit 0 auf. Das Bit ganz links hängt vom Vorzeichen der Anfangszahl ab. Ähnlicher Effekt wie bei der Division einer Zahl durch eine Zweierpotenz.
    >>>, Vorzeichenloser Rechtsverschiebungsoperator:    verschiebt die Bits der Zahl nach rechts und füllt dadurch die Lücken links mit 0 auf. Das Bit ganz links ist auf 0 gesetzt.
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));  } }>
   
  Ausgabe  a<<1 : 20 a>>1 : 5>>
     9. Instanz des Operators    
Die Instanz des Operators wird zur Typprüfung verwendet. Es kann verwendet werden, um zu testen, ob ein Objekt eine Instanz einer Klasse, einer Unterklasse oder einer Schnittstelle ist. Allgemeines Format
wie man str in int umwandelt
 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 { }>
   
  Ausgabe  obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
 Vorrang und Assoziativität von Java-Operatoren
Beim Umgang mit Hybridgleichungen mit mehr als einem Operatortyp werden Vorrang- und Assoziationsregeln verwendet. In solchen Fällen bestimmen diese Regeln, welcher Teil der Gleichung zuerst berücksichtigt wird, da es viele verschiedene Bewertungen für dieselbe Gleichung geben kann. Die folgende Tabelle zeigt die Rangfolge der Operatoren in absteigender Reihenfolge als Größe, wobei oben die höchste Rangfolge und unten die niedrigste Rangfolge dargestellt ist.
  
 Interessante Fragen zu Java-Operatoren
    1. Vorrang und Assoziativität:    
Es kommt oft zu Verwirrung, wenn es um Hybridgleichungen geht, bei denen es sich um Gleichungen mit mehreren Operatoren handelt. Das Problem besteht darin, welcher Teil zuerst gelöst werden muss. In solchen Situationen gilt es eine goldene Regel zu befolgen. Wenn die Operatoren unterschiedliche Prioritäten haben, lösen Sie zuerst die höhere Priorität. Wenn sie die gleiche Priorität haben, lösen Sie sie nach der Assoziativität, also entweder von rechts nach links oder von links nach rechts. Die Erklärung des folgenden Programms ist gut in Kommentaren innerhalb des Programms selbst geschrieben.
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.  // (* = / = %)>(+ = -) // druckt a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // bei gleicher Priorität werden assoziative // Regeln befolgt.  // 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));  } }>
   
  Ausgabe  a+b/d = 20 a+b*d-e/f = 219>
     2. Seien Sie ein Compiler:    
Der Compiler in unseren Systemen verwendet ein Lex-Tool, um beim Generieren von Token die größte Übereinstimmung zu erzielen. Dies stellt ein kleines Problem dar, wenn es übersehen wird. Betrachten Sie zum Beispiel die Aussage    a=b+++c    ; Zu viele Leser scheinen einen Compilerfehler zu verursachen. Aber diese Aussage ist absolut richtig, da das von lex erstellte Token a, =, b, ++, +, c ist. Daher hat diese Anweisung einen ähnlichen Effekt, indem zuerst b+c a zugewiesen und dann b erhöht wird. Ebenso gilt a=b+++++c; würde einen Fehler erzeugen, da die generierten Token a, =, b, ++, ++, +, c sind. was eigentlich ein Fehler ist, da nach dem zweiten unären Operanden kein Operand steht.
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);  } }>
   
  Ausgabe  Value of a(b+c), b(b+1), c = 10, 11, 0>
     3. Verwendung von + über ():    
Bei Verwendung des +-Operators im Inneren      system.out.println()      Stellen Sie sicher, dass Sie die Addition in Klammern vornehmen. Wenn wir vor der Addition etwas schreiben, findet eine String-Addition statt, d. h. die Assoziativität der Addition erfolgt von links nach rechts, und daher werden zuerst ganze Zahlen zu einem String hinzugefügt, wodurch ein String entsteht, und String-Objekte werden bei Verwendung von + verkettet. Daher kann es zu unerwünschten Ergebnissen kommen.
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));  } }>
   
  Ausgabe  Concatenation (x+y)= 58 Addition (x+y) = 13>
 Vorteile von Operatoren in Java
Die Vorteile der Verwendung von Operatoren in Java sind nachstehend aufgeführt:
     Ausdruckskraft    : Operatoren in Java bieten eine übersichtliche und lesbare Möglichkeit, komplexe Berechnungen und logische Operationen durchzuführen.
    Zeitersparnis:    Operatoren in Java sparen Zeit, indem sie die für die Ausführung bestimmter Aufgaben erforderliche Codemenge reduzieren.
    Verbesserte Leistung    : Die Verwendung von Operatoren kann die Leistung verbessern, da sie häufig auf Hardwareebene implementiert werden und dadurch schneller als gleichwertiger Java-Code sind.
Nachteile von Operatoren in Java
Die Nachteile von Operatoren in Java werden im Folgenden aufgeführt:
     Vorrang des Operators:    Operatoren in Java haben eine definierte Priorität, die bei unsachgemäßer Verwendung zu unerwarteten Ergebnissen führen kann.
    Geben Sie Zwang ein    : Java führt bei der Verwendung von Operatoren implizite Typkonvertierungen durch, was bei unsachgemäßer Verwendung zu unerwarteten Ergebnissen oder Fehlern führen kann.
FAQs zu Java-Operatoren
1. Was sind Operatoren in Java am Beispiel?
Operatoren sind spezielle Symbole, die zum Ausführen bestimmter Operationen verwendet werden. Beispielsweise wird „+“ für die Addition verwendet, wobei 5+4 den Wert 9 zurückgibt.
Gewerkschaft vs. Gewerkschaft alle