Ang simbolo na ginagamit upang magsagawa ng mga operasyon ay tinatawag na operator. Sa Java, ang ' != ' ay isang Comparison Operator na ginagamit upang matukoy kung ang dalawang operand ay pantay o hindi sa pamamagitan ng paghahambing sa mga ito, habang ang ' =! ” pinagsasama ng operator ang dalawang operator; ang una ay isang Assignment operator ' = ”, at ang pangalawa ay isang lohikal na Hindi operator “ ! ” na gumagana sa mga boolean na halaga. Ginagamit din ito sa pagbabaligtad ng mga halaga ng boolean.
Ipapaliwanag ng post na ito ang pagkakaiba ng != at =! Mga operator sa Java.
Ano ang Pagkakaiba sa pagitan ng != at =! Mga operator sa Java?
“ != 'at' =! ” ay dalawang magkahiwalay na operator ng Java. Ang dalawang operator na ito ay hindi maihahambing dahil nagsisilbi ang mga ito ng magkaibang mga pag-andar. Ang ' != Ang operator ay naghahambing ng dalawang operand, samantalang ang ' =! ” inverse ng operator ang resulta ng mga boolean value. Ang representasyon nito ay nagbibigay lamang ng kamukhang-kamukha.
Ngayon, tatalakayin natin ang parehong mga pamamaraan at ang kanilang paggamit nang paisa-isa!
Ano ang '!=' Operator sa Java?
Ang ' != Ang operator ay tinatawag ding ' hindi kapareho ng ” operator ng Java. Ito ay ginagamit upang suriin kung ang dalawang operand ay pantay o hindi habang gumagamit ng mga conditional na pahayag. Ang operator na ito ay nagbabalik ng mga halaga ng boolean, kung saan ' totoo ” ay nagpapahiwatig na ang mga halaga ay inihambing at hindi pantay, at “ mali ” ay tumutukoy sa kabaligtaran nitong kaso kapag ang parehong mga halaga ay pantay.
Paano Gamitin ang '!=' Operator sa Java?
Sundin ang ibinigay na syntax sa ibaba para sa paghahambing ng variable na halaga ' a 'may' b ' gamit ang ' != ” (hindi katumbas) operator:
a ! =b
Halimbawa 1
Sa halimbawang ito, gagawa kami ng dalawang variable na uri ng integer, ' a 'at' b ” at simulan ang mga ito:
int a = dalawampu ;int b = 23 ;
I-print ang orihinal na mga halaga ng mga variable ' a 'at' b ” sa console sa tulong ng “ System.out.println() 'paraan:
System.out.println ( 'Ang halaga ng b =' +b ) ;
Pagkatapos, susuriin natin kung ang halaga ng ' a ' ay katumbas ng halaga ng ' b ' gamit ang ' != ” operator. Magbabalik ito ng boolean value ' mali ” kung ang parehong mga halaga ay pantay:
Panghuli, i-print ang resultang halaga sa console:
Ang output ay nagpapakita ng boolean na halaga ' totoo ”, na nagsasaad na ang mga halaga ng “ a 'at' b 'ay hindi pantay:
Halimbawa 2
Ngayon, gagawin namin ang parehong operasyon gamit ang sumusunod na syntax:
boolean output = ! ( a ==b ) ;
Sinusuri muna nito ang pagkakapantay-pantay ng “ a 'at' b ' mga variable na halaga gamit ang operator ng paghahambing ' == ” at saka tinanggihan ang resulta.
Panghuli, i-print ang output sa console:
System.out.println ( output ) ;
Output
Ngayon, lumipat tayo sa isa pang halimbawa kung saan makikita natin kung paano nakakatulong ang nabanggit na operator na makahanap ng pagkakapantay-pantay sa ilalim ng mga tinukoy na kundisyon.
Halimbawa 3
Dito, isasaalang-alang natin ang parehong mga variable ' a 'at' b ” sa kanilang mga halaga tulad ng sa mga naunang halimbawa. Gagamitin namin ang kondisyong ' kung ” pahayag upang suriin kung ang mga halaga ng parehong mga variable ay pantay o hindi at i-print ang mga idinagdag na pahayag:
kung ( a ! =b ) {System.out.println ( 'Ang halaga ng 'a' ay hindi katumbas ng halaga ng 'b'' ) ;
} iba pa {
System.out.println ( 'Ang halaga ng 'a' ay katumbas ng halaga ng 'b'' ) ;
}
Ipinapakita ng output na ang mga halaga ng ' a 'at' b 'ay hindi pantay:
Ngayon, tumungo sa pagtatrabaho ng ' =! ” operator sa Java.
Ano ang “=!” Operator sa Java?
Ang ' =! Ang operator ay ang kumbinasyon ng dalawang operator, ang Assignment operator = 'at ang lohikal na hindi' ! ” operator. Ginagamit ang logical not operator para i-convert ang orihinal na value, habang ginagamit ang assignment operator para sa pagtatalaga ng value.
Upang ma-convert ang output ng mga boolean value, maaari mong gamitin ang “ =! ” operator. Kino-convert nito ang boolean value at pagkatapos ay itinalaga ito sa pangalawang operand.
Paano Gamitin ang “=!” Operator sa Java?
Ang syntax para sa paggamit ng “ =! ” operator ay ibinigay bilang sumusunod:
x = ! Y
Tandaan: Ang tamang expression ay ' x= !y 'hindi' x=!y ”; medyo nakakalito. Ang ekspresyong ' x= !y ” ay nagpapakita na ang boolean na halaga ng “ Y ' ay unang binabaligtad, at pagkatapos ay itinalaga ito sa ' x ”.
Halimbawa
Sa halimbawang ito, mayroon kaming dalawang variable na uri ng boolean, ' x 'at' Y ”, na may mga sumusunod na halaga:
boolean x = totoo ;boolean y = totoo ;
I-print ang mga halaga ng mga nilikhang variable sa console gamit ang “ System.out.println() 'paraan:
System.out.println ( 'Ang boolean na halaga ng y =' +y ) ;
Ngayon, iko-convert natin ang boolean value ng “ x 'sa tulong ng' =! ” operator:
Ang ' Y Ibabaligtad muna ng ” ang halaga nito mula sa “ totoo 'sa' mali ”, at pagkatapos ay itinalaga ito sa “ x ”. I-print ang na-update na halaga ng ' x ” sa console:
Output
Ibinigay namin ang lahat ng pangunahing impormasyon tungkol sa ' != 'at' =! ” mga operator sa Java.
Konklusyon
pareho' != 'at' =! ” ay mga Java operator na ginagamit upang magsagawa ng iba't ibang mga pag-andar. Ang ' != Ang operator ay isang paghahambing na operator na naghahambing ng pagkakapantay-pantay ng dalawang operand upang matukoy kung sila ay pantay o hindi, samantalang ang ' =! ' ay ang kumbinasyon ng dalawang operator, isang Assignment operator ' = ”, at ang lohikal na hindi operator “ ! ” na gumagana sa mga boolean na halaga. Sa post na ito, tinalakay namin ang pagkakaiba sa pagitan ng != at =! mga operator sa Java at ang kanilang paggamit.