logo

TechCodeview

Operatory w Javie

Java udostępnia wiele typów operatorów, których można używać w zależności od potrzeb. Są one klasyfikowane na podstawie funkcjonalności, jaką zapewniają. W tym artykule poznamy operatory Java i poznamy wszystkie ich typy.

Jakie są operatory Java?

Operatory w Javie to symbole używane do wykonywania określonych operacji w Javie. Operatorzy sprawiają, że zadania takie jak dodawanie, mnożenie itp. wyglądają na łatwe, chociaż realizacja tych zadań jest dość złożona.

Rodzaje operatorów w Javie

W Javie istnieje wiele typów operatorów, wszystkie są wymienione poniżej:



  1. Operatory arytmetyczne
  2. Operatory jednoargumentowe
  3. Operator przypisania
  4. Operatorzy relacyjni
  5. Operatory logiczne
  6. Operator trójskładnikowy
  7. Operatory bitowe
  8. Operatorzy zmian
  9. instancja operatora

1. Operatory arytmetyczne

Służą do wykonywania prostych operacji arytmetycznych na prymitywnych typach danych.

  • * : Mnożenie
  • / : Dział
  • %: Moduł
  • + : Dodatek
  • – : Odejmowanie

Przykład:

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

2. Operatory jednoargumentowe

Operatory jednoargumentowe potrzebują tylko jednego operandu. Służą do zwiększania, zmniejszania lub negowania wartości.

przekonwertować datę na ciąg znaków
  • – : Jednoargumentowy minus , używany do negacji wartości.
  • + : Jednoargumentowy plus wskazuje wartość dodatnią (jednak bez niej liczby są dodatnie). Wykonuje automatyczną konwersję na int, gdy typem argumentu jest bajt, znak lub krótki. Nazywa się to jednoargumentową promocją liczbową.
  • ++: Operator inkrementacji , używany do zwiększania wartości o 1. Istnieją dwie odmiany operatorów inkrementacji.
    • Post-inkrementacja: Wartość jest najpierw używana do obliczenia wyniku, a następnie zwiększana.
    • Wstępny przyrost: Najpierw zwiększana jest wartość, a następnie obliczany jest wynik.
  • – – : Operator zmniejszania , używany do zmniejszania wartości o 1. Istnieją dwie odmiany operatorów zmniejszania.
    • Po zmniejszeniu: Wartość jest najpierw używana do obliczenia wyniku, a następnie zmniejszana.
    • Zmniejszanie wstępne: wartość jest najpierw zmniejszana, a następnie obliczany jest wynik.
  • ! : Logiczne, a nie operatorowe , używany do odwracania wartości logicznej.

Przykład:

sortuj tablicę w Javie
Jawa 
// 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));  } }>
Wyjście 
Postincrement : 10 Preincrement : 12 Postdecrement : 10 Predecrement : 8>

3. Operator przypisania

„=” Operator przypisania służy do przypisania wartości dowolnej zmiennej. Ma asocjatywność od prawej do lewej, czyli wartość podana po prawej stronie operatora jest przypisana do zmiennej po lewej stronie, dlatego przed jej użyciem należy zadeklarować wartość po prawej stronie lub powinna ona być stała.

Ogólny format operatora przypisania to:

variable   =   value;>

W wielu przypadkach operator przypisania można połączyć z innymi operatorami, aby zbudować krótszą wersję instrukcji zwaną a Oświadczenie złożone . Na przykład zamiast A = a+5, możemy zapisać a += 5.

  • += , aby dodać lewy operand do prawego operandu, a następnie przypisać go do zmiennej po lewej stronie.
  • -= , aby odjąć prawy operand od lewego operandu i następnie przypisać go do zmiennej po lewej stronie.
  • *= , do pomnożenia lewego operandu przez prawy operand, a następnie przypisania go do zmiennej po lewej stronie.
  • /= , do dzielenia lewego operandu przez prawy operand i następnie przypisania go do zmiennej po lewej stronie.
  • %= , do przypisania modulo lewego operandu przez prawy operand, a następnie przypisania go do zmiennej po lewej stronie.

Przykład:

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

Operatory te służą do sprawdzania relacji takich jak równość, większy niż i mniejszy niż. Po porównaniu zwracają wyniki logiczne i są szeroko stosowane w instrukcjach zapętlających, a także w instrukcjach warunkowych if-else. Ogólny format to:

variable   relation_operator   value>

Niektóre z operatorów relacji to:

  • ==, Równe zwraca wartość true, jeśli lewa strona jest równa prawej stronie.
  • !=, Nierówny zwraca wartość true, jeśli lewa strona nie jest równa prawej stronie.
  • <, mniej niż: zwraca wartość true, jeśli lewa strona jest mniejsza niż prawa strona.
  • <=, mniejszy lub równy zwraca wartość true, jeśli lewa strona jest mniejsza lub równa prawej stronie.
  • >, Większe niż: zwraca wartość true, jeśli lewa strona jest większa niż prawa strona.
  • >=, Większe lub równe zwraca wartość true, jeśli lewa strona jest większa lub równa prawej stronie.

Przykład:

Jawa 
// 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));  } }>
Wyjście 
a>b: prawda a = b: prawda a<= b: false a == c: false a != c: true>

5. Operatory logiczne

Operatory te służą do wykonywania operacji logicznych AND i logicznych OR, czyli funkcji podobnej do bramki AND i OR w elektronice cyfrowej. Należy pamiętać, że drugi warunek nie jest oceniany, jeśli pierwszy jest fałszywy, tj. powoduje zwarcie. Szeroko stosowany do testowania kilku warunków podejmowania decyzji. Java ma również funkcję logicznego NOT, która zwraca wartość true, gdy warunek jest fałszywy i odwrotnie

ciąg w c

Operatory warunkowe to:

  • &&, logiczne AND: zwraca wartość true, gdy oba warunki są spełnione.
  • ||, logiczne LUB: zwraca wartość true, jeśli przynajmniej jeden warunek jest prawdziwy.
  • !, Logiczne NIE: zwraca wartość true, gdy warunek jest fałszywy i odwrotnie

Przykład:

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

6. Operator trójskładnikowy

Operator trójskładnikowy jest skróconą wersją instrukcji if-else. Ma trzy operandy i stąd nazwa Ternary.

Ogólny format to:

condition   ?   if true   :   if false>

Powyższa instrukcja oznacza, że ​​jeśli warunek ma wartość true, wykonaj instrukcje po znaku „?”, w przeciwnym razie wykonaj instrukcje po znaku „:”.

Java długo na ciąg

Przykład:

Jawa 
// 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)? pne);  System.out.println('Maks. trzy liczby = ' + wynik);  } }>
Wyjście 
Max of three numbers = 30>

7. Operatory bitowe

Operatory te służą do manipulacji pojedynczymi bitami liczby. Można ich używać z dowolnymi typami całkowitymi. Są one używane podczas wykonywania operacji aktualizacji i zapytań na drzewach indeksowanych binarnie.

  • &, Bitowy operator AND: zwraca bit po bicie ORAZ wartości wejściowych.
  • |, Bitowy operator OR: zwraca bit po bicie LUB wartości wejściowych.
  • ^, Bitowy operator XOR: zwraca bit po bicie XOR wartości wejściowych.
  • ~, Operator dopełnienia bitowego: Jest to operator jednoargumentowy, który zwraca reprezentację wartości wejściowej z uzupełnieniem jednostkowym, tj. z odwróconymi wszystkimi bitami.
Jawa 
// 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  }>
Wyjście 
d & e: 8 d | e: 14 d ^ e: 6 ~d: -11 d <>1:6 i>>> 1:6>>> 
    8. Operatorzy zmian    
Operatory te służą do przesuwania bitów liczby w lewo lub w prawo, odpowiednio mnożąc lub dzieląc liczbę przez dwa. Można ich użyć, gdy musimy pomnożyć lub podzielić liczbę przez dwa. Ogólny format-
     <<, Operator przesunięcia w lewo:    przesuwa bity liczby w lewo i wypełnia 0 w pozostawionych w rezultacie pustych przestrzeniach. Podobny efekt, jak pomnożenie liczby przez pewną potęgę dwójki.
  •     >>, Podpisano Operator przesunięcia w prawo:    przesuwa bity liczby w prawo i w rezultacie wypełnia 0 w pozostawionych pustych przestrzeniach. Bit skrajnie lewy zależy od znaku liczby początkowej. Podobny efekt do dzielenia liczby przez pewną potęgę dwójki.
  •     >>>, Operator przesunięcia bez znaku w prawo:    przesuwa bity liczby w prawo i w rezultacie wypełnia 0 w pozostawionych pustych przestrzeniach. Najbardziej lewy bit jest ustawiony na 0.
    • Jawa 
    // 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));  } }>
           
      Wyjście  
    a<<1 : 20 a>>1:5>>
     
        9. instancja operatora    
    Instancja operatora służy do sprawdzania typu. Można go użyć do sprawdzenia, czy obiekt jest instancją klasy, podklasy lub interfejsu. Ogólny format-
     
    object   instance of   class/subclass/interface>
    Jawa 
    // 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 { }>
           
      Wyjście  
    obj1 instanceof Person: true obj1 instanceof Boy: false obj1 instanceof MyInterface: false obj2 instanceof Person: true obj2 instanceof Boy: true obj2 instanceof MyInterface: true>
     
    Pierwszeństwo i łączność operatorów Java
    Reguły pierwszeństwa i asocjacji są stosowane w przypadku równań hybrydowych obejmujących więcej niż jeden typ operatora. W takich przypadkach zasady te określają, którą część równania należy uwzględnić w pierwszej kolejności, ponieważ to samo równanie może mieć wiele różnych wartości. Poniższa tabela przedstawia pierwszeństwo operatorów w kolejności malejącej jako wielkość, przy czym górna część reprezentuje najwyższy priorytet, a dolna pokazuje najniższy priorytet.
     
     Pierwszeństwo i łączenie operatorów w Javie
     
    Ciekawe pytania dotyczące operatorów Java
        1. Pierwszeństwo i łączność:    
    Często pojawia się zamieszanie, jeśli chodzi o równania hybrydowe, które są równaniami mającymi wiele operatorów. Problem polega na tym, którą część rozwiązać najpierw. W takich sytuacjach obowiązuje złota zasada. Jeśli operatory mają różne priorytety, najpierw rozwiąż wyższy priorytet. Jeżeli mają one ten sam priorytet, należy rozwiązać je według skojarzeń, czyli od prawej do lewej lub od lewej do prawej. Wyjaśnienie poniższego programu jest dobrze napisane w komentarzach w samym programie.
    Jawa 
    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.  // (* = / = %)>(+ = -) // drukuje a+(b/d) System.out.println('a+b/d = ' + (a + b / d));  // jeśli to samo pierwszeństwo, wówczas stosowane są // reguły asocjacyjne.  // 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));  } }>
           
      Wyjście  
    a+b/d = 20 a+b*d-e/f = 219>
     
        2. Bądź kompilatorem:    
    Kompilator w naszych systemach używa narzędzia Lex w celu dopasowania największego dopasowania podczas generowania tokenów. Stwarza to pewien problem, jeśli zostanie przeoczony. Rozważmy na przykład oświadczenie    a=b+++c    ; może się wydawać, że zbyt wielu czytelników powoduje błąd kompilatora. Ale to stwierdzenie jest całkowicie poprawne, ponieważ token stworzony przez Lexa to a, =, b, ++, +, c. Dlatego ta instrukcja ma podobny efekt, polega na pierwszym przypisaniu b+c do a, a następnie zwiększeniu b. Podobnie a=b+++++c; wygenerowałoby błąd, ponieważ wygenerowane tokeny to a, =, b, ++, ++, +, c. co w rzeczywistości jest błędem, ponieważ po drugim jednoargumentowym operandie nie ma operandu.
    model referencyjny osi w sieciach

    Jawa 
    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);  } }>
           
      Wyjście  
    Value of a(b+c), b(b+1), c = 10, 11, 0>
     
        3. Używanie + over ():    
    Podczas używania operatora + wewnątrz      system.out.println()      pamiętaj o dodaniu w nawiasach. Jeśli napiszemy coś przed wykonaniem dodawania, wówczas nastąpi dodawanie łańcucha, to znaczy łączenie dodawania odbywa się od lewej do prawej, a zatem liczby całkowite są dodawane do łańcucha najpierw, tworząc ciąg, a obiekty łańcuchowe łączą się przy użyciu +. Dlatego może powodować niepożądane skutki.
    Jawa 
    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));  } }>
           
      Wyjście  
    Concatenation (x+y)= 58 Addition (x+y) = 13>
     
    Zalety operatorów w Javie
    Poniżej wymieniono zalety stosowania operatorów w Javie:
     
    1.     Wyrazistość    : Operatory w Javie zapewniają zwięzły i czytelny sposób wykonywania złożonych obliczeń i operacji logicznych.
    2.     Oszczędność czasu:    Operatorzy w Javie oszczędzają czas, zmniejszając ilość kodu potrzebnego do wykonania określonych zadań.
    3.     Poprawiona wydajność    : Używanie operatorów może poprawić wydajność, ponieważ często są one implementowane na poziomie sprzętowym, dzięki czemu są szybsze niż równoważny kod Java.
    Wady operatorów w Javie
    Wady operatorów w Javie są wymienione poniżej:
     
    1.     Pierwszeństwo operatora:    Operatory w Javie mają zdefiniowany priorytet, który może prowadzić do nieoczekiwanych wyników, jeśli nie zostanie prawidłowo użyty.
    2.     Wpisz przymus    : Java wykonuje niejawne konwersje typów podczas używania operatorów, co może prowadzić do nieoczekiwanych wyników lub błędów, jeśli nie zostanie użyte prawidłowo.
    Często zadawane pytania dotyczące operatorów Java
    1. Jakie są operatory w Javie na przykładzie?
    Operatory to specjalne symbole używane do wykonywania określonych operacji. Na przykład „+” służy do dodawania, gdzie 5 + 4 zwróci wartość 9.