java operators arithmetic
I den här handledningen lär du dig om olika Java-operatörer - Tilldelning, aritmetik, unary, jämlikhet och relation, villkorlig, typjämförelse och bitvis & bitväxlingsoperatörer:
Men innan vi börjar med det direkt, låt oss kort förstå termen 'operatörer'
Operatörer är bara speciella symboler. Syftet med dessa symboler är att utföra en specifik operation på en, två eller tre operander och sedan returnera ett resultat. Till exempel, symboler som =,<, & , ^ etc .
Vad du kommer att lära dig:
Java-operatörer
Låt oss nu se de operatörer som stöds på Java-språk.
Java stöder operatörer av följande kategorier:
- Uppdragsoperatörer
- Aritmetiska operatörer
- Unary operatörer
- Jämställdhets- och relationsoperatörer
- Villkorliga operatörer
- Skriv jämförelseoperatör
- Bitvis och Bit Shift-operatörer
# 1) Uppdragsoperatörer
Vi kommer att se en av de vanligaste operatörerna, dvs. enkel tilldelningsoperatör '='. Denna operatör tilldelar värdet till höger till operanden till vänster.
Låt oss titta på följande Java-exempel som illustrerar användningen av uppdragsoperatörer.
public class AssignmentOperatorDemo{ public static void main(String args()){ int x=300; //Assigns value on the left of ‘=’ i.e. 300 to it’s left i.e. variable x int y=700; //Assigns value on the left of ‘=’ i.e. 700 to it’s left i.e. variable y int z = 0; //Assigns value on the left of ‘=’ i.e. 0 to it’s left i.e. variable z z = x+y; //Assigns value on the left of ‘=’ i.e. (x+y) i.e. 300+700=1000 to it’s left i.e. variable z System.out.println(x); //This prints output as 300 System.out.println(y); //This prints output as 700 System.out.println(z); //This prints output as 1000 } } Detta program skriver ut följande utdata:
Denna operatör kan också användas på objekt för att tilldela objektreferenser.
Till exempel, Bilbil1 = ny bil (); // ‘=’ tilldelar ny Car () -objektinstans till objektreferens car1.
# 2) Aritmetiska operatörer
För att utföra aritmetiska operationer som addition, subtraktion, multiplikation och division är dessa identiska med grundläggande matematik. Den enda annorlunda symbolen är “%”, vilket är operatorn för modul eller rest och syftet med denna operand är att dela en operand med en annan och returnera resten som sitt resultat.
Följande är de aritmetiska operatörerna som stöds i Java:
| Operatör | Beskrivning |
|---|---|
| | | Bitvis inkluderande ELLER |
| + | Additive Operator (används också för strängkompatering) |
| - | Subtraktionsoperatör |
| * | Multiplikationsoperatör |
| / | Division Operatör |
| % | Modul- eller restenoperatör |
Nedan följer ett JAVA-exempel som illustrerar användningen av aritmetiska operatörer:
public class ArithmeticOperatorDemo { public static void main (String() args) { int x = 30; int y = 20; int result_value = x + y; System.out.println('30 + 20 = ' + result_value); // This prints o/p 50 result_value = x - y; System.out.println('30 - 20 = ' + result_value);// This prints o/p 10 result_value = x * y; System.out.println('30 * 20 = ' + result_value);// This prints o/p 600 result_value = x / y; System.out.println('30 / 20 = ' + result_value);// This prints o/p 1 result_value = x % y; // Returns remainder of division 30/20 i.e. 10 System.out.println('30 % 20 = ' + result_value);// This prints o/p 10 } } Detta program skriver ut följande utdata:
# 3) Unary Operators
Unary Operators är de operatörer som behöver en enda operand.
Till exempel, operationer som att öka / minska ett värde med ett, negera ett uttryck eller invertera ett booleskt värde.
Följande är Unary Operators som stöds i Java:
| Operatör | Beskrivning |
|---|---|
| + | Unary plus operatör; anger positivt värde (siffror är positiva utan detta, dock) |
| - | Unary minus operatör; förnekar ett uttryck |
| ++ | Inkrementoperatör; ökar ett värde med 1 |
| - | Minskningsoperatör; minskar ett värde med 1 |
| ! | Logiskt komplement Operatör; inverterar värdet på en boolean |
Nedan följer ett Java-exempel som illustrerar användningen av Unary Operators:
hur man öppnar en .jar fil
public class UnaryOperatorDemo { public static void main(String() args) { int result_value = +10;// indicated positive value 10 System.out.println(result_value); //o/p is 10 result_value --; // decrements the value of 10 by 1 System.out.println(result_value); //o/p is 9 result_value ++; // increaments the value of 9 by 1 System.out.println(result_value); //o/p is 10 result_value = - result_value;// this minus operator negates an expression System.out.println(result_value); //o/p is -10 booleanisPass = false; System.out.println(isPass); //o/p is false System.out.println(!isPass);//o/p is inverted isPass value i.e. true } } Detta program skriver ut följande utdata:
Öknings- / minskningsoperatorerna kan användas före (prefix) eller efter (postfix) operand. Trots att båda värdena returnerar det ursprungliga värdet som ökas / minskas med ett. Skillnaden är att prefixoperatören utvärderar operand till det ökade värdet, medan postfix-versionen utvärderar operand till det ursprungliga värdet.
Låt oss ta en titt på följande PreAndPostDemo som illustrerar prefix och postfix-funktionalitet .
public class PreAndPostDemo { public static void main(String() args){ int a = 5; System.out.println(a++); // output is 5 System.out.println(a); // output is 6 System.out.println(++a); // output is 7 System.out.println(a++); // output is 7 System.out.println(a); // output is 8 } } Detta program skriver ut följande utdata:
# 4) Jämställdhets- och relationsoperatörer
Likhets- och relationsoperatörerna är operatörerna för att jämföra och avgöra om en operand är större än, mindre än, lika med eller inte lika med en annan operand.
Följande är de jämställdhets- och relationsoperatörer som stöds i Java:
| Operatör | Beskrivning |
|---|---|
| == | Lika med |
| ! = | Inte lika med |
| > | Större än |
| > = | Större än eller lika med |
| < | Mindre än |
| <= | Mindre än eller lika med |
Se följande Java-exempel som illustrerar användningen av Relational Operators:
public class RelationalOperatorDemo { public static void main(String() args){ int a = 5; int b = 10; boolean resultFlag = (a == b); System.out.println('a == b :'+ resultFlag);//o/p is false as 5 is not equal to 10 resultFlag = (a != b); System.out.println('a != b :'+ resultFlag); //o/p is true as 5 is not equal to 10 resultFlag = (a > b); System.out.println('a >b :'+ resultFlag); //o/p is false as 5 is not greater than 10 resultFlag = (a = b); System.out.println('a >= b:'+ resultFlag); //o/p is false as 5 neither greater than 10 nor equal to 10 } } Detta program skriver ut följande utdata:
# 5) Villkorliga operatörer
Java stöder villkorliga operatörer, || och && för att utföra Conditional-OR och Conditional-AND-operationer på två booleska operander. Detta beteende kallas också som 'kortslutande' beteende. I detta beteende sker den andra operandutvärderingen endast om det behövs.
En annan villkorlig operatör som stöds är den ternära operatören '?:' Som kallas som stenografi för ett if-then-else-uttalande.
| Operatör | Beskrivning |
|---|---|
| && | Villkorligt-OCH |
| || | Villkorligt-ELLER |
| ?: | Ternary (stenografi för if-then-else uttalande) |
Nedan följer ett Java-exempel som illustrerar användningen av villkorliga operatörer:
public class ConditionalOperatorDemo { public static void main(String() args) int a = 5; int b = 10; boolean resultFlag = ((a == 5) && (b == 10)); //o/p is true as both conditions are evaluated true System.out.println('a is 5 AND b is 10 :'+resultFlag); resultFlag = ((a == 5) } Detta program skriver ut följande utdata:
# 6) Skriv jämförelseoperatör
| Operatör | Beskrivning |
|---|---|
| instans av | Jämför ett objekt med en specificerad typ |
Syftet med förekomsten av en operatör är att jämföra ett objekt med en specificerad typ. Detta kan användas för att testa om ett objekt är en förekomst av en klass, en underklass eller en klass som implementerar ett visst gränssnitt.
Låt oss titta på följande Java-exempel som illustrerar användningen av jämförelseoperatörer:
publicclass Shape {} public class Square extends Shape implements Area {} public interface Area {} publicclassInstanceofOperatorDemo { publicstaticvoidmain(String() args) { Shape shape1 = newShape(); Shape shape2 = newSquare(); System.out.println('shape1 instanceof Shape: ' + (shape1 instanceof Shape)); System.out.println('shape1 instanceof Square: ' + (shape1 instanceof Square)); System.out.println('shape1 instanceof Area:' + (shape1 instanceof Area)); System.out.println('shape2 instanceof Shape: ' + (shape2 instanceof Shape)); System.out.println('shape2 instanceof Square: ' + (shape2 instanceof Square)); System.out.println('shape2 instanceof Area: ' + (shape2 instanceof Area)); } } Detta program skriver ut följande utdata:
# 7) Bitvis och Bit Shift-operatörer
Java stöder också operatörer för att utföra Bitwise- och Bit Shift-operationer på någon av heltalstyperna, dvs. lång, int, kort, char och byte.
Följande stöds Bitvis- och Bitskiftoperatörer:
| Operatör | Beskrivning |
|---|---|
| ~ | Unary bitvis komplement |
| << | Signerad vänster skift |
| >> | Signerad höger skift |
| >>> | Osignerad höger skift |
| & | Bitvis OCH |
| ^ | Bitvis exklusivt ELLER |
Låt oss ta en titt på följande Java-exempel som illustrerar användningen av Bitwise-operatörer:
public class BitwiseOperatorDemo { public static void main(String() args) 0110 = 0111 = 7 System.out.println('x }Detta program skriver ut följande utdata:
Java Operator Precedence
Hittills har vi utforskat de operatörer som stöds i Java. Låt oss nu titta på dessa operatörers företräde. Operatörerna listas enligt deras företräde i fallande ordning i följande tabell. Postfix har högsta företräde och uppdrag är den lägsta prioritetsoperatören.
hur man tar bort element från array i java
Betydelse av företräde: Utvärdering av operatörer sker enligt operatörens företräde, dvs. utvärdering sker med början med operatörerna med högre prioritet och följs av operatörer som har relativt lägre företräde.
Alla binära operatörer utvärderas från vänster till höger och det enda undantaget är uppdragsoperatörer. När det gäller uppdragsoperatörer sker operatörens utvärdering från höger till vänster.
| Operatörens företräde | ||
|---|---|---|
| Relationellt | = instans av | Vänster till höger |
| Operatörer | Operatörernas företräde | Associativitet |
| Postfix | expr ++ expr-- | Vänster till höger |
| Unary | ++ expr --expr + expr -expr ~! | Höger till vänster |
| Multiplikativ | * /% | Vänster till höger |
| Tillsats | + - | Vänster till höger |
| Flytta | <>>>> | Vänster till höger |
| Jämlikhet | ==! = | Vänster till höger |
| Bitvis OCH | & | Vänster till höger |
| Bitvis exklusivt ELLER | ^ | Vänster till höger |
| Bitvis inkluderande ELLER | | | Vänster till höger |
| logisk OCH | && | Vänster till höger |
| logisk ELLER | || | Vänster till höger |
| Ternära | ? : | Höger till vänster |
| Uppdrag | = + = - = * = / =% = & = ^ = | =<>= >>> = | Höger till vänster |
Vanliga frågor och svar
F # 1) Vilka är de operatörer som används i Java?
Svar: Operatörer i Java är speciella symboler. Syftet med dessa symboler är att utföra specifika operationer på en, två eller tre operander och returnera ett resultat.
Till exempel, symboler som =,<, & , ^ etc .
F # 2) Vad är === Operatör i Java?
Svar: === operatör kallas en strikt likhetsoperatör i Javascript . Denna operatör returnerar true om båda variablerna är av samma typ och också innehåller samma värde.
Till exempel 1 === ”1 ″ // Detta kommer att återvända falsk . Detta beror på att båda operanderna inte är av samma typ.
== operatör i Javascript jämför två variabler av olika typer genom att automatiskt konvertera en typ till en annan.
Till exempel 1 == ”1 ″ Detta kommer att bli sant. Här omvandlas strängen till antal och jämförelse sker.
F # 3) Vad är Java Assignment Operator?
vad är en dat-fil mac
Svar: Java-tilldelningsoperatör, dvs operatören ‘=’ tilldelar värdet till höger till operanden till vänster.
Till exempel, int x = 300; Här ‘ = ’Tilldelar värde 300 till variabel x
F # 4) Vad är == i Java?
Svar: == operatör i Java används för att jämföra referens, dvs. denna operatör verifierar om båda objekten pekar på samma minnesplats
Detta skiljer sig åt i .equals () som jämför värdena i objekten.
Till exempel,
Sträng str1 = ny sträng (“God morgon”);
Sträng str2 = ny sträng (“God morgon”);
System.out.println (str1 == str2); // Detta returnerar falskt eftersom detta jämför adresser, dvs. minnesplatser för två objekt
System.out.println (str1.equals (str2)); // Detta returnerar true när det jämför värdet.
F # 5) Hur många typer av operatörer finns det i Java?
Svar: Nedan listas de olika typerna av operatörer i Java:
- Uppdragsoperatör
- Aritmetiska operatörer
- Unary operatörer
- Jämställdhets- och relationsoperatörer
- Villkorliga operatörer
- Skriv jämförelseoperatör
- Bitvis och Bit Shift-operatörer
F # 6) Vad är användningen av Dot Operator i Java?
Svar: Punktoperatören eller separatorn eller perioden i Java används för att separera en variabel, dvs metoden från en objektreferensvariabel.
Till exempel, Bilbil1 = ny bil ();
car1.name = “Audi”; // Här används '.' För att komma åt fältet 'namn' på bilobjektreferensen 'car1'
F # 7) Vilka är de tre logiska operatörerna?
Svar: Logiska operatörer arbetar på den booleska operanden.
Följande är de logiska operatörerna:
- &&: Logiskt OCH
- || : Logiskt ELLER
- ! : Logiskt Inte
F # 8) Vad är bitvisa operatörer i Java?
Svar: Java stöder operatörer för att utföra bitvis och bitförskjutningsoperationer på någon av heltalstyperna dvs lång, int, kort, char och byte.
Följande är de stödda Bitwise- och Bit Shift-operatörerna:
| Operatör | Beskrivning |
|---|---|
| | | Bitvis inkluderande ELLER |
| ~ | Unary bitvis komplement |
| << | Signerad vänster skift |
| >> | Signerad höger skift |
| >>> | Osignerad höger skift |
| & | Bitvis OCH |
| ^ | Bitvis exklusivt ELLER |
Slutsats
I denna handledning har vi utforskat de olika typerna av operatörer som stöds i Java tillsammans med deras syfte.
I ett nötskal inkluderar Java-operatörerna:
- Uppdragsoperatör
- Aritmetiska operatörer
- Unary operatörer
- Jämställdhets- och relationsoperatörer
- Villkorliga operatörer
- Skriv jämförelseoperatör
- Bitvis och Bit Shift-operatörer
Vi såg också hur dessa operatörer används i Java-koden med hjälp av några exempel som illustrerar användningen av dessa operatörer. Även om vi har sett alla typer av operatörer kan användningen av dessa operatörer i programmering för allmänt ändamål ibland variera.
En del av operatörerna förekommer oftare oftare än de andra, eftersom uppdragsoperatören '=' används mycket ofta i kod än den osignerade högerskiftoperatören '>>>
Vi kommer att se var och en av dessa operatörskategorier i detalj i våra kommande handledning.
Rekommenderad läsning
- Unix Shell Script Aritmetic och Boolean Operators Exempel
- Java-distribution: Skapande och utförande av Java JAR-fil
- Java Virtual Machine: Hur JVM hjälper till att köra Java-applikationen
- Python-operatörer
- Åtkomstmodifierare i Java - Handledning med exempel
- Java Reflection Tutorial med exempel
- Introduktion till Java-programmeringsspråk - Videohandledning
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning