జావా బిట్‌వైస్ ఆపరేటర్లు

నేటి పాఠంలో, మేము జావా బిట్‌వైస్ ఆపరేటర్‌లతో పరిచయం పొందుతాము మరియు వారితో ఎలా పని చేయాలో ఉదాహరణలను పరిశీలిస్తాము. మీకు బహుశా "బిట్" అనే పదం తెలిసి ఉండవచ్చు. కాకపోతే, దాని అర్థం ఏమిటో గుర్తుచేసుకుందాం :) కంప్యూటర్‌లోని సమాచారం యొక్క అతిచిన్న యూనిట్ బిట్. దీని పేరు బైనరీ అంకెల నుండి వచ్చింది . బిట్‌ను రెండు సంఖ్యలలో ఒకదానితో వ్యక్తీకరించవచ్చు: 1 లేదా 0. ఒకటి మరియు సున్నాల ఆధారంగా ప్రత్యేక బైనరీ సంఖ్య వ్యవస్థ ఉంది. మేము ఇక్కడ గణిత అడవిని పరిశోధించము. జావాలోని ఏదైనా సంఖ్య బైనరీ రూపంలోకి మార్చబడుతుందని మాత్రమే మేము గమనించవచ్చు. దీన్ని చేయడానికి, మీరు రేపర్ తరగతులను ఉపయోగించాలి. ఉదాహరణకు, మీరు పూర్ణాంకానికి దీన్ని ఎలా చేయగలరో ఇక్కడ ఉంది :

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(Integer.toBinaryString(x));
   }
}

కన్సోల్ అవుట్‌పుట్: 101010110 1010 10110 (చదవడాన్ని సులభతరం చేయడానికి నేను ఖాళీని జోడించాను) అనేది దశాంశ వ్యవస్థలో సంఖ్య 342. మేము వాస్తవానికి ఈ సంఖ్యను వ్యక్తిగత బిట్‌లుగా విభజించాము: సున్నాలు మరియు వాటిని. బిట్‌లపై చేసే కార్యకలాపాలను బిట్‌వైస్ అంటారు .

• ~ - బిట్‌వైస్ కాదు.

ఈ ఆపరేటర్ చాలా సులభం: ఇది మన సంఖ్య యొక్క ప్రతి బిట్‌ను దాటి, బిట్‌ను తిప్పుతుంది: సున్నాలు ఒకటిగా మారతాయి మరియు అవి సున్నాలుగా మారతాయి. మేము దానిని మా సంఖ్య 342కి వర్తింపజేస్తే, ఇక్కడ ఏమి జరుగుతుంది: 101010110 అనేది 342 బైనరీ సంఖ్యగా సూచించబడుతుంది 010101001 వ్యక్తీకరణ యొక్క విలువ ~342 దీన్ని ఆచరణలో పెట్టడానికి ప్రయత్నిద్దాం:

public class Main {

   public static void main(String[] args) {

       int x = 342;
       System.out.println(~x);
   }
}

కన్సోల్ అవుట్‌పుట్: 169 169 అనేది సుపరిచితమైన, దశాంశ వ్యవస్థలో మా ఫలితం ( 010101001 ) :)

• & - బిట్‌వైస్ మరియు

మీరు చూడగలిగినట్లుగా, ఇది లాజికల్ AND ( && )కి చాలా పోలి ఉంటుంది. && ఆపరేటర్ , మీరు గుర్తుకు తెచ్చుకుంటారు, రెండు ఆపరాండ్‌లు నిజమైతే మాత్రమే నిజం అని తిరిగి వస్తుంది. బిట్‌వైస్ & ఇదే విధంగా పని చేస్తుంది: ఇది రెండు సంఖ్యలను బిట్‌బైట్‌గా పోలుస్తుంది. పోలిక మూడవ సంఖ్యను ఉత్పత్తి చేస్తుంది. ఉదాహరణకు, 277 మరియు 432 సంఖ్యలను తీసుకుందాం: 110110000 అనేది 277 బైనరీ సంఖ్యగా ప్రాతినిధ్యం వహిస్తుంది 1000101011 432 బైనరీ సంఖ్యగా సూచించబడుతుంది తర్వాత, ఆపరేటర్ & ఎగువ సంఖ్య యొక్క మొదటి బిట్‌ను దిగువ సంఖ్యలోని మొదటి బిట్‌తో పోల్చారు. ఇది AND ఆపరేటర్ అయినందున, రెండు బిట్‌లు 1 అయితే మాత్రమే ఫలితం 1 అవుతుంది. ఏదైనా ఇతర సందర్భంలో, ఫలితం 0. 100010101 && ఆపరేటర్ మొదట, మేము రెండు సంఖ్యల మొదటి బిట్‌లను, తర్వాత రెండవ బిట్‌లను, ఆపై మూడవ బిట్‌లను పోల్చి చూస్తాము. మీరు చూడగలిగినట్లుగా, రెండు సందర్భాల్లో మాత్రమే 1 (మొదటి మరియు ఐదవ బిట్‌లు)కి సమానమైన సంఖ్యలలో సంబంధిత బిట్‌లు రెండూ ఉంటాయి. అన్ని ఇతర పోలికలు 0 సె. కాబట్టి చివరికి మనకు 10001000 సంఖ్య వచ్చింది. దశాంశ వ్యవస్థలో, ఇది 272 సంఖ్యకు అనుగుణంగా ఉంటుంది. తనిఖీ చేద్దాం:

public class Main {

   public static void main(String[] args) {
       System.out.println(277&432);
   }
}

కన్సోల్ అవుట్‌పుట్: 272

• | - బిట్‌వైస్ లేదా.

ఈ ఆపరేటర్ అదే విధంగా పని చేస్తుంది: రెండు సంఖ్యలను బిట్ బై బిట్ పోల్చడం. ఇప్పుడు మాత్రమే బిట్‌లలో కనీసం ఒకటి 1 అయితే, ఫలితం 1. అదే సంఖ్యలను చూద్దాం (277 మరియు 432): 100010101 | 110110000 _______________ 110110101 - ఫలితం | ఆపరేటర్ ఇక్కడ మేము వేరొక ఫలితాన్ని పొందుతాము: రెండు సంఖ్యలలో సున్నాలుగా ఉన్న బిట్‌లు సున్నాలుగా మిగిలిపోతాయి. ఫలితం 110110101. దశాంశ వ్యవస్థలో, ఇది 437 సంఖ్యకు అనుగుణంగా ఉంటుంది.

public class Main {

   public static void main(String[] args) {
       System.out.println(277|432);
   }
}

కన్సోల్ అవుట్‌పుట్: 437 మేము ప్రతిదీ సరిగ్గా లెక్కించాము! :)

• ^ - బిట్‌వైస్ XOR (ప్రత్యేకమైన OR)

మేము ఇంకా ఈ ఆపరేటర్‌ని ఎదుర్కోలేదు. కానీ దాని గురించి సంక్లిష్టంగా ఏమీ లేదు. ఇది సాధారణ OR ఆపరేటర్‌ని పోలి ఉంటుంది. ఒక తేడా ఉంది: కనీసం ఒక ఒపెరాండ్ నిజమైతే సాధారణ OR నిజమని చూపుతుంది. కానీ అది ఒకటి కానవసరం లేదు: రెండు ఒపెరాండ్‌లు నిజమైతే, ఫలితం నిజం. కానీ ప్రత్యేకమైన OR రిటర్న్‌లు సరిగ్గా ఒపెరాండ్‌లలో ఒకటి నిజమైతే మాత్రమే. రెండు ఒపెరాండ్‌లు నిజమైతే, సాధారణ OR నిజం ("కనీసం ఒక నిజం")ని అందిస్తుంది, కానీ XOR తప్పుని అందిస్తుంది. అందుకే దీనిని ప్రత్యేకమైన OR అని పిలుస్తారు. మునుపటి బిట్‌వైస్ ఆపరేటర్‌లు ఎలా పని చేస్తారో తెలుసుకోవడం ద్వారా, మీరు బహుశా 277 ^ 432 ని సులభంగా లెక్కించవచ్చు. అయితే దాన్ని మరొకసారి కలిసి చూద్దాం :) 100010101 ^ 110110000 _______________ 010100101 - ఫలితం ^ఆపరేటర్ అది మా ఫలితం. రెండు సంఖ్యలలో ఒకేలా ఉండే బిట్‌లు 0ని ఉత్పత్తి చేస్తాయి (అంటే "ఒకే ఒక్క" పరీక్ష విఫలమైంది). కానీ 0-1 లేదా 1-0 జంటగా ఏర్పడిన బిట్‌లు ఒకటిగా మారాయి. మా ఫలితం 010100101. దశాంశ వ్యవస్థలో, ఇది 165 సంఖ్యకు అనుగుణంగా ఉంటుంది. మన లెక్కలు సరిగ్గా ఉన్నాయో లేదో చూద్దాం:

public class Main {

   public static void main(String[] args) {
       System.out.println(277^432);
   }
}

కన్సోల్ అవుట్‌పుట్: 165 సూపర్! అంతా మనం అనుకున్నట్లే :) ఇప్పుడు బిట్ షిఫ్టుల ఆపరేటర్లతో పరిచయం పొందడానికి సమయం ఆసన్నమైంది. పేరు దాని కోసం మాట్లాడుతుంది. మేము కొంత సంఖ్యను తీసుకుంటాము మరియు దాని బిట్‌లను ఎడమ లేదా కుడికి తరలించాము :) అది ఎలా ఉందో చూద్దాం:

షిఫ్ట్ ఎడమ

బిట్‌లను ఎడమవైపుకి మార్చడం << ఇక్కడ ఒక ఉదాహరణ:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(Integer.toBinaryString(x));
       System.out.println(Integer.toBinaryString(z));
   }
}

ఈ ఉదాహరణలో, x = 64 సంఖ్యను విలువ అంటారు. ఇది మేము మారే విలువ యొక్క బిట్స్. మేము బిట్‌లను ఎడమ వైపుకు మారుస్తాము ( << ఆపరేటర్ యొక్క దిశ ద్వారా మీరు దీనిని ఊహించవచ్చు ) బైనరీ సిస్టమ్‌లో, సంఖ్య 64 = 1000000 సంఖ్య y = 3 ని షిఫ్ట్ దూరం అంటారు. x సంఖ్య యొక్క బిట్‌లను మీరు ఎన్ని బిట్‌లను కుడి/ఎడమ వైపుకు మార్చాలనుకుంటున్నారో షిఫ్ట్ దూరం సూచిస్తుంది, మా ఉదాహరణలో, మేము వాటిని 3 బిట్‌లను ఎడమ వైపుకు మారుస్తాము. షిఫ్ట్ ప్రక్రియను మరింత స్పష్టంగా చూడటానికి, చిత్రాన్ని చూడండి. ఈ ఉదాహరణలో, మేము int s ఉపయోగిస్తాము. కంప్యూటర్ మెమరీలో Ints 32 బిట్‌లను ఆక్రమిస్తాయి. మా అసలు సంఖ్య 64 ఇలా కనిపిస్తుంది: ఇప్పుడు మేము మా ప్రతి బిట్‌లను తీసుకుంటాము మరియు వాటిని అక్షరాలా 3 స్థలాల ద్వారా ఎడమ వైపుకు మారుస్తాము: మనకు లభించిన వాటిని పరిశీలించండి. మీరు చూడగలిగినట్లుగా, మా అన్ని బిట్‌లు మారాయి మరియు పరిధి అంచు నుండి మరో 3 సున్నాలు జోడించబడ్డాయి. మూడు, మనం 3 ద్వారా మారినందున. మనం 10 ద్వారా మారినట్లయితే, 10 సున్నాలు జోడించబడతాయి. కాబట్టి, x << y అనే వ్యక్తీకరణకు అర్థం " x సంఖ్య యొక్క బిట్‌లను y స్థలాల ద్వారా ఎడమవైపుకు మార్చడం". మా వ్యక్తీకరణ యొక్క ఫలితం 1000000000 సంఖ్య, ఇది దశాంశ వ్యవస్థలో 512. తనిఖీ చేద్దాం:

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 3;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

కన్సోల్ అవుట్‌పుట్: 512 స్పాట్ ఆన్! సిద్ధాంతపరంగా, బిట్‌లను అనంతంగా మార్చవచ్చు, కానీ మన సంఖ్య పూర్ణాంకం అయినందున , మనకు 32 బైనరీ అంకెలు మాత్రమే అందుబాటులో ఉన్నాయి. వీటిలో, 7 ఇప్పటికే 64 (1000000) ఆక్రమించబడ్డాయి. కాబట్టి, మేము 27 స్థలాలను ఎడమవైపుకు మార్చినట్లయితే, మాది ఒక్కటే డేటా రకం పరిధిని దాటి పోతుంది. సున్నాలు మాత్రమే మిగిలి ఉంటాయి!

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 26;// Shift distance

       int z = (x << y);
       System.out.println(z);
   }
}

కన్సోల్ అవుట్‌పుట్: 0 ఊహించినట్లుగానే, అందుబాటులో ఉన్న 32 బిట్‌ల కంటే ఒకటి కదులుతుంది మరియు అదృశ్యమైంది. మేము సున్నాలను మాత్రమే కలిగి ఉన్న 32-బిట్ సంఖ్యతో ముగించాము. సహజంగా, ఇది దశాంశ వ్యవస్థలో 0కి అనుగుణంగా ఉంటుంది. ఇక్కడ ఎడమవైపు షిఫ్ట్‌లను గుర్తుంచుకోవడానికి ఒక సాధారణ నియమం ఉంది: ఎడమవైపు ఉన్న ప్రతి షిఫ్ట్‌కు, సంఖ్య 2తో గుణించబడుతుంది. బిట్స్ 111111111 << 3 చిత్రాలు లేకుండా క్రింది వ్యక్తీకరణను లెక్కించడానికి ప్రయత్నిద్దాం . ఫలితంగా, మనకు 888888888 వస్తుంది. కొంత కోడ్ వ్రాసి తనిఖీ చేద్దాం:

public class Main {

   public static void main(String[] args) {
       System.out.println(111111111 << 3);
   }
}

కన్సోల్ అవుట్‌పుట్: 888888888

కుడివైపుకి మారండి

ఈ ఆపరేషన్ >> ద్వారా సూచించబడుతుంది . ఇది అదే పని చేస్తుంది, కానీ ఇతర దిశలో! :) మేము చక్రాన్ని తిరిగి ఆవిష్కరించము. అదే Int 64 తో ప్రయత్నిద్దాం .

public class Main {

   public static void main(String[] args) {
       int x = 64;//value
       int y = 2;// Shift distance

       int z = (x >> y);
       System.out.println(z);
   }
}

2 ద్వారా కుడివైపుకి మారిన ఫలితంగా, మన సంఖ్యలో ఉన్న రెండు తీవ్ర సున్నాలు పరిధి నుండి బయటకు వెళ్లి పోతాయి. మేము 10000ని పొందుతాము, ఇది దశాంశ సిస్టమ్ కన్సోల్ అవుట్‌పుట్‌లోని సంఖ్య 16కి అనుగుణంగా ఉంటుంది: 16 కుడి వైపున ఉన్న షిఫ్ట్‌లను గుర్తుంచుకోవడానికి ఇక్కడ ఒక సాధారణ నియమం ఉంది: కుడి వైపున ఉన్న ప్రతి షిఫ్ట్‌ని రెండుగా విభజించి, మిగిలిన ఏదైనా విస్మరిస్తుంది. ఉదాహరణకు, 35 >> 2 అంటే మనం 35ని 2తో రెండుసార్లు విభజించాలి, మిగిలిన 35/2 = 17 (శేషం 1 విస్మరించండి) 17/2 = 8 (శేషం 1ని విస్మరించండి) చివరికి, 35 >> 2 చేయాలి 8కి సమానం. తనిఖీ చేద్దాం:

public class Main {

   public static void main(String[] args) {
       System.out.println(35 >> 2);
   }
}

కన్సోల్ అవుట్‌పుట్: 8

జావాలో ఆపరేటర్ ప్రాధాన్యత

కోడ్‌ను వ్రాసేటప్పుడు మరియు చదివేటప్పుడు, మీరు తరచుగా అనేక కార్యకలాపాలను మిళితం చేసే వ్యక్తీకరణలను కనుగొంటారు. అవి అమలు చేయబడే క్రమాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం (లేకపోతే, ఫలితం చూసి మీరు ఆశ్చర్యపోవచ్చు) ఎందుకంటే జావా చాలా కార్యకలాపాలను కలిగి ఉంది, వాటిలో ప్రతి ఒక్కటి ప్రత్యేక పట్టికలో ఒక స్థానం కేటాయించబడింది:

ఆపరేటర్ ప్రాధాన్యత

అన్ని కార్యకలాపాలు వారి ప్రాధాన్యతను పరిగణనలోకి తీసుకొని ఎడమ నుండి కుడికి నిర్వహించబడతాయి. ఉదాహరణకు, మనం వ్రాస్తే

int x  = 6 - 4/2;

అప్పుడు విభజన ఆపరేషన్ ( 4/2 ) మొదట నిర్వహించబడుతుంది. ఇది రెండవ స్థానంలో ఉన్నప్పటికీ, దీనికి అధిక ప్రాధాన్యత ఉంది. కుండలీకరణాలు మరియు బ్రాకెట్లు గరిష్ట ప్రాధాన్యతను సూచిస్తాయి. మీరు బహుశా పాఠశాల నుండి గుర్తుంచుకోవాలి. ఉదాహరణకు, మీరు వాటిని వ్యక్తీకరణకు జోడిస్తే

int x  = (6 - 4)/2;

అప్పుడు వ్యవకలనం ముందుగా నిర్వహించబడుతుంది, ఎందుకంటే ఇది కుండలీకరణాల్లో జతచేయబడుతుంది. లాజికల్ && ఆపరేటర్ యొక్క ప్రాధాన్యత చాలా తక్కువగా ఉంది (టేబుల్ చూడండి), కాబట్టి ఇది సాధారణంగా చివరిగా ఉంటుంది. ఉదాహరణకి:

boolean x = 6 - 4/2 > 3 && 12*12 <= 119;

ఈ వ్యక్తీకరణ క్రింది విధంగా అమలు చేయబడుతుంది:

• 4/2 = 2

boolean x = 6 - 2 > 3 && 12*12 <= 119;

• 12*12 = 144

boolean x = 6 - 2 > 3 && 144 <= 119;

• 6-2 = 4

boolean x = 4 > 3 && 144 <= 119;

తరువాత, పోలిక ఆపరేటర్లు అమలు చేయబడతారు:

• 4 > 3 = నిజం

boolean x = true && 144 <= 119;

• 144 <= 119 = తప్పు

boolean x = true && false;

మరియు, చివరకు, AND ఆపరేటర్ ( && ) చివరిగా అమలు చేయబడుతుంది.

boolean x = true && false;
boolean x = false;

ఉదాహరణకు, != (సమానం కాదు) పోలిక ఆపరేటర్ కంటే అదనంగా( + ) ఆపరేటర్‌కు అధిక ప్రాధాన్యత ఉంది ; అందువలన, వ్యక్తీకరణలో

boolean x = 7 != 6+1;

6+1 ఆపరేషన్ మొదట నిర్వహించబడుతుంది, తర్వాత 7 != 7 చెక్ (ఇది తప్పుగా అంచనా వేస్తుంది), చివరకు ఫలితం (తప్పు) వేరియబుల్ x కి అప్పగించడం (అసైన్‌మెంట్ సాధారణంగా అన్ని ఆపరేటర్‌లలో అతి తక్కువ ప్రాధాన్యతను కలిగి ఉంటుంది; చూడండి పట్టిక). అయ్యో! ఇది గొప్ప పాఠం, కానీ మీరు చేసారు! మీరు వీటిలో కొన్ని లేదా మునుపటి పాఠాలను పూర్తిగా అర్థం చేసుకోలేకపోతే, చింతించకండి. మేము భవిష్యత్తులో ఒకటి కంటే ఎక్కువసార్లు ఈ అంశాలపై టచ్ చేస్తాము. లాజికల్ మరియు న్యూమరికల్ ఆపరేషన్‌ల గురించి కొన్ని కోడ్‌జిమ్ పాఠాలు. మేము వీటిని త్వరలో పొందలేము, కానీ మీరు ఇప్పుడు వాటిని చదవడం వల్ల ఎటువంటి హాని లేదు.