Relasjonsoperatører i Java | Forklart
Hvordan relasjonelle operatører jobber i Java
De relasjonelle operatørene som brukes i Java er like til noe annet programmeringsspråk. Hver av de relasjonelle operatørene er definert her, og ytterligere bruk vil bli gitt i den kommende delen.
Lik (==): Denne operatøren sjekker likestillingsforholdet mellom verdier/variabler i Java. Operatørens symbol er "==”Og praktiseres ved å følge syntaksen nedenfor:
a == b;Ikke lik (!=): Dette er det motsatte av lik operatøren, da det sjekker for ulikheten til to variabler/verdier. Symbolet for å bruke denne operatøren er “!(=) ”Og følgende syntaks kan følges for denne operatøren:
en!= b;Større enn (>). Jo større enn operatøren sjekker om operanden på venstre side er større enn den andre eller ikke. Syntaksen ved å bruke den større enn operatøren er vist nedenfor:
A> B;Større enn eller lik (> =): Det viser om en variabel er høyere eller lik en annen. "Større enn eller lik" utøves ved hjelp av symbolet "> =", og det følger syntaksen nedenfor.
a> = b;Mindre enn (<): Denne operatøren sjekker om den første variabelen/verdien er mindre enn andre verdi/variabel eller ikke. Du kan henvise til følgende uttalelse for å bruke denne operatøren.
enHvordan bruke relasjonelle operatører i Java
Denne delen gir bruk av relasjonelle operatører i Java. Senere i denne delen vil du også bli kjent.
Lik (==): Følgende Java -kode benytter seg av "lik" -operatøren mellom to variabler og returnerer det falske resultatet, da variabelen x = 2 ikke er lik y = 4.
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int x = 2, y = 4;
System.ute.println (x == y);
Utgangen fra koden er gitt nedenfor:
Ikke lik(!=): Følgende Java -program, A = 7 er ikke lik B = 9, men den ikke like store operatøren returnerte ekte i utgangen.
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int a = 7, b = 9;
System.ute.println (a!= b);
Utgangen til koden vises nedenfor:
Mindre enn (<): Koden gitt nedenfor sammenligner variablene C og D ved å bruke "mindre enn" relasjonsoperatør. Som verdien av variabel C = 10 er mindre enn d = 15, Så utgangen ville være sant:
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int c = 10, d = 15;
System.ute.Println (c
Utgangen til koden vises nedenfor:
Større enn (>): Java -koden gitt nedenfor benytter seg av den større enn operatøren på to variabler (E og F). Heltallet 18 er lagret i variabel E, mens 12 er tilordnet variabel f: som viser verdien av f er større enn e Men vi har sjekket om f> e eller ikke.
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int e = 18, f = 12;
System.ute.println (f> e);
Utgangen fra ovennevnte kode er falsk fordi f
Større enn eller lik (> =): Koden som er gitt nedenfor utøver, desto større enn eller lik operatøren på to variabler. Tilstanden (x> = y) definert i koden er sann, og dermed er utgangen også sant:
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int x = 13, y = 13;
System.ute.println (x> = y);
Utgangen til koden vises nedenfor:
Mindre enn eller lik (<=): Denne operatøren praktiseres på to variabler en og b. Verdiene som er tilordnet en og b er 5 og 8 henholdsvis. Tilstandssettet er B<=a which is false thus the return would also be false.
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int a = 5, b = 8;
System.ute.Println (b<=a);
Utgangen fra koden kan sees på bildet nedenfor:
Bruke relasjonelle operatører i løkker og if-ests-uttalelser i Java
Den vanligste praksisen med relasjonelle operatører er å bruke dem inne i løkkene og if-els betingede uttalelser for å bygge en tilstand.
For sløyfe: The For Loop er en mye brukt type sløyfe, og koden skrevet nedenfor viser bruken av for løkker med relasjonelle operatører.
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int z = 2, i;
// Bruker for loop og <=
for (i = 0; i<=z; i++)
System.ute.println ("tilstand er sann");
Koden er beskrevet som:
- erklærer z og jeg variabler
- bruker for loop og relasjonsoperatør (mindre enn eller lik)
- Skrive ut en uttalelse
Utgangen til koden vises nedenfor:
If-Else og relasjonelle operatører: Følgende kode viser bruken av IF-Else og relasjonsoperatør (>).
pakke newpack;offentlig klasse Relop
public static void main (String [] args)
// erklære variabler
int a = 4, b = 3;
// Bruke IF-Else og relasjonsoperatør
if (a> b)
System.ute.Println ("Tilstanden er sann");
ellers
System.ute.Println ("False!");
Koden er beskrevet her:
- erklære variabler
- Bruker (a> b) som en tilstand i IF -uttalelse
- Skrive ut i IF- og ellers uttalelsene
Utgangen til koden vises nedenfor:
Konklusjon
De relasjonelle operatørene i Java har det viktigste ansvaret for å sjekke tilstanden og returnere resultatet basert på den tilstandskontrollen. Java relasjonelle operatører praktiseres i betingede uttalelser og løkker for å ta beslutninger i programmer. Denne artikkelen demonstrerer arbeidet med relasjonelle operatører. I tillegg er det gitt flere eksempler som illustrerer bruken av betingede operatører individuelt så vel som i betingede uttalelser og løkker.