కార్యకలాపాలను నిర్వహించడానికి ఉపయోగించే చిహ్నాన్ని ఆపరేటర్ అంటారు. జావాలో, ' != 'అనేది పోలిక ఆపరేటర్ని పోల్చడం ద్వారా రెండు ఒపెరాండ్‌లు సమానంగా ఉన్నాయా లేదా కాదా అని నిర్ణయించడానికి ఉపయోగించబడుతుంది, అయితే ' =! ” ఆపరేటర్ ఇద్దరు ఆపరేటర్లను కలుపుతుంది; మొదటిది ఒక అసైన్‌మెంట్ ఆపరేటర్ ' = ', మరియు రెండవది లాజికల్ నాట్ ఆపరేటర్' ! ”అది బూలియన్ విలువలపై పనిచేస్తుంది. ఇది బూలియన్ విలువల విలోమంలో కూడా ఉపయోగించబడుతుంది.
ఈ పోస్ట్ != మరియు =! మధ్య వ్యత్యాసాన్ని వివరిస్తుంది! జావాలో ఆపరేటర్లు.
!= మరియు =! మధ్య తేడా ఏమిటి! జావాలో ఆపరేటర్లు?
' != 'మరియు' =! ” అనేవి రెండు వేర్వేరు జావా ఆపరేటర్లు. ఈ రెండు ఆపరేటర్లు వేర్వేరు కార్యాచరణలను అందిస్తున్నందున పోల్చలేము. ది ' != 'ఆపరేటర్ రెండు ఆపరాండ్‌లను పోలుస్తుంది, అయితే ' =! ” ఆపరేటర్ బూలియన్ విలువల ఫలితాన్ని విలోమం చేస్తుంది. దీని ప్రాతినిధ్యం కేవలం లుక్-అలైక్ అనుభూతిని మాత్రమే ఇస్తుంది.
ఇప్పుడు, మేము రెండు పద్ధతులను మరియు వాటి వినియోగాన్ని ఒక్కొక్కటిగా చర్చిస్తాము!
జావాలో “!=” ఆపరేటర్ అంటే ఏమిటి?
ది ' != 'ఆపరేటర్' అని కూడా పిలుస్తారు సమానం కాదు ” జావా ఆపరేటర్. షరతులతో కూడిన స్టేట్‌మెంట్‌లను ఉపయోగిస్తున్నప్పుడు రెండు ఆపరాండ్‌లు సమానంగా ఉన్నాయో లేదో అంచనా వేయడానికి ఇది ఉపయోగించబడుతుంది. ఈ ఆపరేటర్ బూలియన్ విలువలను అందిస్తుంది, ఇక్కడ ' నిజం ” విలువలు పోల్చబడ్డాయి మరియు సమానంగా లేవని సూచిస్తుంది మరియు “ తప్పుడు ” రెండు విలువలు సమానంగా ఉన్నప్పుడు దాని వ్యతిరేక సందర్భాన్ని సూచిస్తుంది.
జావాలో “!=” ఆపరేటర్ని ఎలా ఉపయోగించాలి?
వేరియబుల్ విలువను సరిపోల్చడానికి దిగువ ఇవ్వబడిన వాక్యనిర్మాణాన్ని అనుసరించండి ' a 'తో' బి 'ఉపయోగించి' != ” (సమానం కాదు) ఆపరేటర్:
a ! = బి
ఉదాహరణ 1
ఈ ఉదాహరణలో, మేము రెండు పూర్ణాంకాల రకం వేరియబుల్స్ సృష్టిస్తాము, ' a 'మరియు' బి ” మరియు వాటిని ప్రారంభించండి:
int a = ఇరవై ;int b = 23 ;
వేరియబుల్స్ యొక్క అసలు విలువలను ప్రింట్ చేయండి ' a 'మరియు' బి ” సహాయంతో కన్సోల్‌లో System.out.println() 'పద్ధతి:
System.out.println ( 'బి విలువ =' +b ) ;
అప్పుడు, '' యొక్క విలువ ఉందో లేదో తనిఖీ చేస్తాము. a '' విలువకు సమానం బి 'ఉపయోగించి' != ” ఆపరేటర్. ఇది బూలియన్ విలువను అందిస్తుంది ' తప్పుడు 'రెండు విలువలు సమానంగా ఉంటే:
చివరగా, కన్సోల్‌లో ఫలిత విలువను ముద్రించండి:
అవుట్పుట్ బూలియన్ విలువను చూపుతుంది ' నిజం ', ఇది ' యొక్క విలువలను సూచిస్తుంది a 'మరియు' బి ” సమానం కాదు:
ఉదాహరణ 2
ఇప్పుడు, మేము ఈ క్రింది వాక్యనిర్మాణాన్ని ఉపయోగించి అదే ఆపరేషన్ చేస్తాము:
boolean output = ! ( a ==బి ) ;
ఇది మొదట సమానత్వాన్ని తనిఖీ చేస్తుంది ' a 'మరియు' బి 'పోలిక ఆపరేటర్ని ఉపయోగించి వేరియబుల్ విలువలు' == ” ఆపై ఫలితాన్ని తిరస్కరిస్తుంది.
చివరగా, కన్సోల్‌లో అవుట్‌పుట్‌ను ప్రింట్ చేయండి:
System.out.println ( అవుట్పుట్ ) ;
అవుట్పుట్
ఇప్పుడు, పేర్కొన్న పరిస్థితులలో సమానత్వాన్ని కనుగొనడంలో పేర్కొన్న ఆపరేటర్ ఎలా సహాయపడుతుందో చూద్దాం, మరొక ఉదాహరణకి వెళ్దాం.
ఉదాహరణ 3
ఇక్కడ, మేము అదే వేరియబుల్స్ను పరిశీలిస్తాము ' a 'మరియు' బి ” మునుపటి ఉదాహరణలలో వలె వాటి విలువలతో. మేము షరతులను ఉపయోగిస్తాము ' ఉంటే ” స్టేట్‌మెంట్ రెండు వేరియబుల్స్ యొక్క విలువలు సమానంగా ఉన్నాయో లేదో తనిఖీ చేయడానికి మరియు జోడించిన స్టేట్‌మెంట్‌లను ప్రింట్ అవుట్ చేయండి:
ఉంటే ( a ! = బి ) {System.out.println ( 'A' విలువ 'b' విలువకు సమానం కాదు' ) ;
} లేకపోతే {
System.out.println ( 'A' విలువ 'b' విలువకు సమానం' ) ;
}
అవుట్పుట్ ' యొక్క విలువలను చూపుతుంది a 'మరియు' బి ” సమానం కాదు:
ఇప్పుడు, '' యొక్క పని వైపు వెళ్ళండి =! ” జావాలో ఆపరేటర్.
'=!' అంటే ఏమిటి జావాలో ఆపరేటర్?
ది ' =! 'ఆపరేటర్ అనేది ఇద్దరు ఆపరేటర్ల కలయిక, అసైన్‌మెంట్ ఆపరేటర్' = 'మరియు తార్కికం కాదు' ! ” ఆపరేటర్. అసలు విలువను మార్చడానికి లాజికల్ నాట్ ఆపరేటర్ ఉపయోగించబడుతుంది, అయితే అసైన్‌మెంట్ ఆపరేటర్ విలువ యొక్క అసైన్‌మెంట్ కోసం ఉపయోగించబడుతుంది.
బూలియన్ విలువల అవుట్‌పుట్‌ని మార్చడానికి, మీరు ' =! ” ఆపరేటర్. ఇది బూలియన్ విలువను మారుస్తుంది మరియు దానిని రెండవ ఒపెరాండ్‌కు కేటాయిస్తుంది.
'=!' ఎలా ఉపయోగించాలి జావాలో ఆపరేటర్?
'ని ఉపయోగించడం కోసం సింటాక్స్ =! ” ఆపరేటర్ ఈ క్రింది విధంగా ఇవ్వబడింది:
x = ! వై
గమనిక: సరైన వ్యక్తీకరణ ' x= !y 'కాదు' x=!y ”; ఇది కొంచెం గందరగోళంగా ఉంది. వ్యక్తీకరణ ' x= !y '' యొక్క బూలియన్ విలువను చూపుతుంది వై 'మొదట విలోమం చేసి, ఆపై దానికి కేటాయించబడుతుంది' x ”.
ఉదాహరణ
ఈ ఉదాహరణలో, మనకు రెండు బూలియన్ టైప్ వేరియబుల్స్ ఉన్నాయి, “ x 'మరియు' వై ”, కింది విలువలతో:
బూలియన్ x = నిజం ;బూలియన్ y = నిజం ;
'ని ఉపయోగించి కన్సోల్‌లో సృష్టించబడిన వేరియబుల్స్ యొక్క విలువలను ప్రింట్ చేయండి System.out.println() 'పద్ధతి:
System.out.println ( 'y యొక్క బూలియన్ విలువ =' +y ) ;
ఇప్పుడు, మేము '' యొక్క బూలియన్ విలువను మారుస్తాము. x '' సహాయంతో =! 'ఆపరేటర్:
ది ' వై 'మొదట దాని విలువను ' నుండి విలోమం చేస్తుంది నిజం ' నుండి ' తప్పుడు ', ఆపై అది కేటాయించబడుతుంది' x ”. ' యొక్క నవీకరించబడిన విలువను ముద్రించండి x ” కన్సోల్‌లో:
అవుట్పుట్
మేము అన్ని ప్రాథమిక సమాచారాన్ని అందించాము ' != 'మరియు' =! ” జావాలో ఆపరేటర్లు.
ముగింపు
రెండు ' != 'మరియు' =! ”వివిధ కార్యాచరణలను నిర్వహించడానికి ఉపయోగించే జావా ఆపరేటర్లు. ది ' != 'ఆపరేటర్ అనేది ఒక కంపారిజన్ ఆపరేటర్, ఇది రెండు ఒపెరాండ్‌ల సమానత్వాన్ని పోల్చి, అవి సమానంగా ఉన్నాయా లేదా కాదా అని నిర్ణయించడానికి, అయితే ' =! ” అనేది ఇద్దరు ఆపరేటర్ల కలయిక, ఒక అసైన్‌మెంట్ ఆపరేటర్” = ', మరియు లాజికల్ కాదు ఆపరేటర్' ! ”అది బూలియన్ విలువలపై పనిచేస్తుంది. ఈ పోస్ట్‌లో, మేము != మరియు =! మధ్య వ్యత్యాసాన్ని చర్చించాము. జావాలో ఆపరేటర్లు మరియు వాటి వినియోగం.