వ్యాసం
ప్రారంభించండి
నేర్చుకోవడం ప్రారంభించండి
CodeGym /జావా బ్లాగ్ /యాదృచ్ఛికంగా /జావా బూలియన్
John Squirrels
స్థాయి
San Francisco

జావా బూలియన్

సమూహంలో ప్రచురించబడింది
జావా భాష యొక్క సందర్భంలో "బూలియన్" అనే పదాన్ని చాలా సంబంధిత, అర్థాలతో విభిన్నంగా ఉపయోగించవచ్చు. అది కావచ్చు:
  • ఈ రకమైన బూలియన్ ఆదిమ రకం లేదా బూలియన్ వేరియబుల్
  • జావా బూలియన్ క్లాస్ లేదా బూలియన్ రేపర్ వస్తువు
  • బూలియన్ వ్యక్తీకరణ, బూలియన్ విలువ, కొంత షరతు
  • జావా బూలియన్ ఆపరేటర్లు
ఈ కథనంలో, మేము ఈ ఎంపికలన్నింటినీ కవర్ చేయబోతున్నాము మరియు బూలియన్ వ్యక్తీకరణలకి లోబడి ఉన్న భావనలను వివరిస్తాము. జావా బూలియన్ - 1

సాధారణ అర్థంలో బూలియన్ అంటే ఏమిటి

బూలియన్ వ్యక్తీకరణ యొక్క భావన గణితం నుండి వచ్చింది, లేదా గణిత తర్కం నుండి వచ్చింది. ప్రతిపాదిత బీజగణితంలో బూలియన్ వ్యక్తీకరణ అనేది నిజం లేదా తప్పు అని చెప్పగలిగే వ్యక్తీకరణ. ఉదాహరణకి:
“మంచు తెల్లగా ఉంది” “మొసళ్ళు ఎగరగలవు” “2 + 2 = 4” “1 + 1 = 21”
అదే సమయంలో, "2" లేదా "మంచు" బూలియన్ వ్యక్తీకరణలు కాదు.

జావా బూలియన్ ఆదిమ డేటా రకం మరియు బూలియన్ వేరియబుల్స్

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

boolean myBoolean; //boolean variable
myBoolean = false; 
boolean myBoolean1 = true; //another boolean variable
ఇక్కడ మనకు 2 బూలియన్ వేరియబుల్స్ ఉన్నాయి. బూలియన్ రకాన్ని ఉపయోగించే ఉదాహరణతో చిన్న ప్రోగ్రామ్‌ను వ్రాద్దాం : 

//boolean variable example
public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       System.out.println(myBoolean);
   }
}
ఈ ప్రోగ్రామ్ కన్సోల్‌కు "తప్పుడు" ముద్రిస్తుంది. మార్గం ద్వారా, బూలియన్ వేరియబుల్ డిఫాల్ట్‌గా తప్పుగా సెట్ చేయబడింది, కానీ జావా మిమ్మల్ని ప్రారంభించని స్థానిక వేరియబుల్‌లతో పని చేయడానికి అనుమతించదు.

జావాలో బూలియన్ వ్యక్తీకరణలు

బూలియన్ వేరియబుల్‌ను ట్రూ లేదా ఫాల్స్‌కు స్పష్టంగా ప్రారంభించడంతో పాటు , బూలియన్ డేటా రకం చాలా చోట్ల పరోక్షంగా ఉపయోగించబడుతుంది. సంఖ్యల జోడింపు ఫలితం సంఖ్య అయినట్లే, ఏదైనా పోలిక యొక్క ఫలితం నిజం లేదా తప్పుగా ఉంటుంది, అంటే అది బూలియన్ రకంగా ఉంటుంది . దీనర్థం, బూలియన్ వేరియబుల్ అసైన్‌మెంట్ స్టేట్‌మెంట్ ద్వారా నేరుగా బూలియన్ విలువను పేర్కొనడంతో పాటు , బూలియన్ విలువలు 5 > 2 వంటి వివిధ పోలికల నుండి ఉత్పన్నమవుతాయి మరియు ప్రాథమికంగా షరతులతో కూడిన మరియు లూప్ స్టేట్‌మెంట్‌లలో ఉపయోగించబడతాయి. బూలియన్ రకం యొక్క అటువంటి ఉపయోగం యొక్క ఉదాహరణ ఇక్కడ ఉంది :
Java webinar 

public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       int a = 5;
       int b = 7;
       System.out.println(a < b);
       System.out.println(0 > 7);
       System.out.println(myBoolean == false);
   }
}
అవుట్‌పుట్:
నిజం తప్పు నిజం
ఒక <b విషయంలో , < ఆపరేటర్ ఎడమ వైపున ఉన్న వ్యక్తీకరణను కుడి వైపున ఉన్న వ్యక్తీకరణతో పోల్చారు. మేము స్క్రీన్‌పై పోలిక ఫలితాన్ని ప్రదర్శించాము. 5 < 7 (స్టేట్‌మెంట్ నిజం) నుండి కన్సోల్‌కు నిజమైన విలువ ముద్రించబడుతుంది. రెండవ సందర్భంలో, మేము సున్నా మరియు ఏడు యొక్క ప్రత్యక్ష పోలికను ప్రదర్శిస్తాము మరియు మూడవది, వేరియబుల్ myBoolean విలువ తప్పు కాదా అని అడుగుతాము. ఇది సందర్భం కాబట్టి, మేము విలువను నిజమైన అవుట్‌పుట్ చేస్తాము . నిజానికి, జావాలో బూలియన్ ఎక్స్‌ప్రెషన్‌లను రూపొందించడానికి, మనం ఏదైనా పోలిక ఆపరేటర్‌లను ఉపయోగించవచ్చు:
పోలిక ఆపరేటర్లు జావా ఆపరేటర్ ఆపరేషన్ ఉదాహరణ ఆపరేషన్ ఫలితం
తక్కువ < ఎ < బి a b కంటే తక్కువగా ఉంటే నిజం లేకపోతే తప్పు
గ్రేటర్ > a > b a b కంటే ఎక్కువ అయితే నిజం , లేకపోతే తప్పు
కంటే తక్కువ లేదా సమానం <= ఒక <= బి a b కంటే తక్కువగా ఉంటే లేదా అవి సమానంగా ఉంటే నిజం , లేకపోతే తప్పు
ఎక్కువ లేదా సమానం >= a >= బి నిజం , ఒకవేళ b కి ఎక్కువ లేదా సమానం అయితే , తప్పు
సమానం == a == b నిజం , ఒకవేళ a b కి సమానం అయితే , తప్పు
సమానము కాదు != a != b నిజం , ఒకవేళ b కి సమానం కాకపోతే , తప్పు

ఇక్కడ బూలియన్ విలువలు ఉపయోగించబడతాయి

బూలియన్ విలువలు మరియు షరతులతో కూడిన వ్యక్తీకరణలు చాలా తరచుగా బ్రాంచ్ స్టేట్‌మెంట్‌లు, టెర్నరీ ఆపరేటర్లు మరియు లూప్‌ల పరిస్థితులలో ఉపయోగించబడతాయి. వాస్తవానికి, వాటి ఉపయోగం నిర్దిష్ట బూలియన్ వ్యక్తీకరణలను తనిఖీ చేయడంపై ఆధారపడి ఉంటుంది. ఉదాహరణకి: 

public class BoolTest2 {
       public static void main(String[] args) {
           int i = 0;
           while (i <= 10)
           {
               System.out.println(i);
               i++;
           }         
      }
}
ఈ ప్రోగ్రామ్ పూర్ణాంకాల క్రమాన్ని ప్రింట్ చేస్తుంది మరియు బ్రాకెట్‌లలోని షరతును కలుసుకున్నంత వరకు వాటిని ఒకటిగా పెంచుతుంది. అంటే, i <=10 అనే వ్యక్తీకరణ నిజం అయితే.

జావా బూలియన్ ఆపరేటర్లు. బూలియన్ ఆపరేటర్లతో బూలియన్ వ్యక్తీకరణలను రూపొందించడం

కింది తార్కిక (లేదా బూలియన్) కార్యకలాపాలు జావాలో అందుబాటులో ఉన్నాయి:

  • తార్కిక నిరాకరణ, ఇది కూడా కాదు లేదా విలోమం. జావాలో, గుర్తుతో సూచించబడుతుంది ! వ్యక్తీకరణకు ముందు.

  • లాజికల్ మరియు, ఇది కూడా AND లేదా సంయోగం. ఇది వర్తింపజేయబడిన రెండు వ్యక్తీకరణల మధ్య & చిహ్నం ద్వారా సూచించబడుతుంది .

  • లాజికల్ లేదా జావాలో, ఇది కూడా OR, ఇది డిస్జంక్షన్ కూడా. జావాలో, గుర్తుచే సూచించబడుతుంది | రెండు వ్యక్తీకరణల మధ్య.

  • ప్రత్యేకమైన లేదా, XOR, కఠినమైన డిస్జంక్షన్. జావాలో, ఇది రెండు వ్యక్తీకరణల మధ్య చిహ్నం ^ ద్వారా సూచించబడుతుంది.

  • జావాలో, లాజికల్ ఆపరేటర్లు షరతులతో కూడిన లేదా, || , అలాగే షరతులతో కూడిన మరియు, && .

ప్రతి జావా బూలియన్ ఆపరేటర్ల యొక్క సంక్షిప్త వివరణతో పట్టికను చూద్దాం మరియు క్రింద మేము వాటిని మరింత వివరంగా వివరిస్తాము మరియు కోడ్ ఉదాహరణలను ఇస్తాము. టేబుల్‌లోని “ఒపెరాండ్‌లు” అంటే, ఆపరేటర్ వర్తించే లాజికల్ ఎక్స్‌ప్రెషన్ లేదా వేరియబుల్స్ అని మేము అర్థం. 

a | b == true
బూలియన్ జావా ఆపరేటర్ పేరు టైప్ చేయండి వివరణ ఉదాహరణ
! తార్కిక “కాదు” (నిరాకరణ) అపరిమితమైన !x అంటే "x కాదు". x తప్పు అయితే ఒప్పు అని చూపుతుంది . x నిజమైతే తప్పు అని చూపుతుంది . _ 

boolean x = true;

అప్పుడు


// !x == false
& తార్కిక "మరియు" (మరియు, తార్కిక గుణకారం) బైనరీ (a & b) a మరియు b రెండూ నిజమైతే నిజాన్ని అందిస్తుంది . 

a = true;
b = false;

అప్పుడు


a & b == false
| లాజికల్ OR (తార్కిక జోడింపు) బైనరీ (a | b ) a లేదా b లేదా రెండూ నిజమైతే నిజాన్ని చూపుతుంది 

a = true;
b = false;

అప్పుడు
^ లాజికల్ ఎక్స్‌క్లూజివ్ OR (XOR) బైనరీ (a ^ b) ఒపెరాండ్‌లలో ఒకటి (a లేదా b) మాత్రమే నిజమైతే నిజం . a మరియు b రెండూ ఏకకాలంలో ఒప్పు లేదా తప్పు అయితే తప్పు అని చూపుతుంది . నిజానికి a b కి సమానం కానట్లయితే అది నిజమని చూపుతుంది . 

a = true;
b = false;

అప్పుడు


a ^ b == true
&& షరతులతో కూడిన AND (సంక్షిప్త లాజికల్ AND) బైనరీ a && b ఇది a & b లాగానే ఉంటుంది , కానీ a తప్పు అయితే , ఆపరేటర్ b ని తనిఖీ చేయకుండా తప్పుని తిరిగి పంపుతారు .
|| షరతులతో కూడిన OR (సంక్షిప్త లాజికల్ OR) బైనరీ ఒక || b అంటే a | b , కానీ a ఒప్పు అయితే , ఆపరేటర్ b ని తనిఖీ చేయకుండానే కేవలం నిజమైనదిగా చూపుతుంది .
Javaలో, ఆపరేటర్లు & , | మరియు ^ పూర్ణాంకాలకు కూడా వర్తిస్తాయి. ఈ సందర్భంలో, వారు కొద్దిగా భిన్నంగా పని చేస్తారు మరియు బిట్‌వైస్ (లేదా బిట్‌వైస్) లాజికల్ ఆపరేటర్లు అని పిలుస్తారు. ఒక ఉదాహరణ తీసుకుని, లాజికల్ ఆపరేటర్లను ఉపయోగించి కంపోజ్ చేయబడిన అనేక లాజికల్ ఎక్స్‌ప్రెషన్‌లను ప్రదర్శిస్తాము. 

public class BoolTest2 {
   public static void main(String[] args) {
   int a = 5;
   int b = 7;
   boolean myBool1 = true;
   boolean myBool2 = false;
       System.out.println(myBool1&myBool2);
       System.out.println(myBool1|myBool2);
       System.out.println(!myBool1);
       System.out.println((a > b) & !myBool1 | myBool2);
   }
}
ఇక్కడ అవుట్‌పుట్ ఉంది:
తప్పుడు నిజం అబద్ధం
వాస్తవానికి, మీరు లాజికల్ ఆపరేటర్లను ఉపయోగించి చాలా క్లిష్టమైన తార్కిక నిర్మాణాలను చేయవచ్చు. ఉదాహరణకి
(a<!b)&(q+1 == 12)^(!a | c & b > 1 + b)|(q ^ a > !b)
అన్ని వేరియబుల్స్ ప్రారంభించబడితే, అటువంటి నిర్మాణాలు పని చేస్తాయి. అయితే, మీరు వాటిని దుర్వినియోగం చేయకూడదు, అవి కోడ్‌ను చదవడం కష్టతరం చేస్తాయి. అయినప్పటికీ, అటువంటి తార్కిక నిర్మాణాలతో వ్యవహరించడం చాలా ఉపయోగకరంగా ఉంటుంది. పట్టికలో ఇవ్వబడిన ఇతర తార్కిక ఆపరేటర్లతో తార్కిక వ్యక్తీకరణలను చేయడానికి ప్రయత్నించండి.
Java university

తార్కిక కార్యకలాపాల ప్రాధాన్యత

గణితశాస్త్రంలో వలె, ప్రోగ్రామింగ్‌లో, ఆపరేటర్‌లు ఒకే వ్యక్తీకరణలో సంభవించినట్లయితే నిర్దిష్ట అమలు క్రమాన్ని కలిగి ఉంటారు. యునరీ ఆపరేటర్‌లు బైనరీ వాటి కంటే ప్రయోజనాలను కలిగి ఉంటాయి మరియు అదనంగా కంటే గుణకారం (తార్కికంగా కూడా) ఉంటాయి. టాపిక్‌ల లిస్ట్‌లో లాజికల్ ఆపరేటర్లు ఎక్కువగా ఉన్నారు, వారి ప్రాధాన్యత ఎక్కువ:

  • !

  • &

  • ^

  • |

  • &&

  • ||

జావా బూలియన్ రేపర్

జావాలో, ప్రతి ఆదిమ రకానికి "సోదరుడు", ఒక రేపర్ క్లాస్ ( ర్యాపర్ ) ఉంటుంది. రేపర్ అనేది ఒక ప్రత్యేక తరగతి, ఇది లోపల ఆదిమ విలువను నిల్వ చేస్తుంది. అయితే ఇది ఒక తరగతి, కాబట్టి మీరు దాని యొక్క ఉదాహరణలను (వస్తువులు) సృష్టించవచ్చు. ఈ ఆబ్జెక్ట్‌లు ఆదిమానవుల అవసరమైన విలువలను లోపల నిల్వ చేస్తాయి, అయితే అవి నిజమైన వస్తువులు. జావా బూలియన్ ఆదిమ రకం రేపర్ జావా బూలియన్ (మూలధనం Bతో) తరగతిని కలిగి ఉంది. బూలియన్ క్లాస్ వస్తువులు ఇతర వాటిలాగే సృష్టించబడతాయి: 

Boolean b = new Boolean(false);
జావా బూలియన్ క్లాస్ ఉపయోగకరమైన పద్ధతులను కలిగి ఉంది. వీటిలో అత్యంత ఆసక్తికరమైనది పార్స్‌బూలియన్ పద్ధతి. స్టాటిక్ బూలియన్ పార్స్‌బూలియన్(స్ట్రింగ్ లు) పద్ధతి స్ట్రింగ్ ఆర్గ్యుమెంట్‌ను బూలియన్‌గా అన్వయిస్తుంది. స్ట్రింగ్ ఆర్గ్యుమెంట్ శూన్యం కానట్లయితే మరియు కేస్ విస్మరిస్తూ "ట్రూ" అనే స్ట్రింగ్‌కు సమానంగా ఉంటే బూలియన్ రిటర్న్ చేయబడిన విలువ నిజమైన విలువను సూచిస్తుంది. లేకపోతే అది తప్పుగా తిరిగి వస్తుంది .

పార్స్‌బూలియన్ పద్ధతి ఉదాహరణ


public class BoolTest2 {

        public static void main(String[] args)
        {
            System.out.println(Boolean.parseBoolean("True"));
            System.out.println(Boolean.parseBoolean("TRuE"));
            System.out.println(Boolean.parseBoolean("False"));
            System.out.println(Boolean.parseBoolean("here"));

        }
    }
అవుట్‌పుట్:
నిజం నిజం అబద్ధం
మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము
వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION