జావాలో బిట్‌సెట్: జావాలోని బిట్‌సెట్ పద్ధతుల గురించి మీరు తెలుసుకోవలసినది

ప్రోగ్రామర్‌ల కోసం ధృవీకరణను ఎక్కువగా చూసుకునే వాటిలో ఒకటి. దీనికి ప్రధాన కారణం జావా వివిధ పనులను సరళీకృతం చేయడానికి గొప్ప మొత్తంలో వశ్యతను మరియు విభిన్న లక్షణాలను అందిస్తుంది. ఈ వ్యాసం మీకు అలాంటి ఒక లక్షణాన్ని పరిచయం చేస్తుంది ‘ జావాలో బిట్‌సెట్‌లు ‘. ఈ వ్యాసం దృష్టి సారించే పాయింటర్లు ఇవి:

• జావాలో బిట్‌సెట్‌లు అంటే ఏమిటి?
• బిట్‌సెట్ జావా పద్ధతులు

కాబట్టి చర్చ యొక్క మొదటి అంశంతో ప్రారంభిద్దాం,

జావాలో బిట్‌సెట్‌లు అంటే ఏమిటి?

బిట్‌సెట్‌లు సున్నా లేదా ఒకటి విలువలను కలిగి ఉన్న N బిట్‌ల స్థిర పరిమాణ క్రమాన్ని సూచిస్తాయి. జీరో అంటే విలువ తప్పు లేదా సెట్ చేయబడలేదు. ఒకటి విలువ విలువ లేదా సెట్ అని అర్థం. కంపైల్ సమయంలో బిట్‌సెట్ పరిమాణం పరిష్కరించబడింది.బిట్‌సెట్ అనేది java.util ప్యాకేజీలో నిర్వచించబడిన తరగతి. ఇది బిట్ విలువలను కలిగి ఉన్న ఒక ప్రత్యేక రకం శ్రేణి. ఇది బిట్స్ యొక్క వెక్టర్ను అమలు చేస్తుంది. ఎక్కువ బిట్స్ అవసరమవుతున్నందున దాని పరిమాణం స్వయంచాలకంగా పెరుగుతుంది.

పూర్ణాంకాల నుండి మరియు తీగల నుండి బిట్‌సెట్‌ను రూపొందించడానికి ఈ తరగతి మాకు రెండు రకాల కన్స్ట్రక్టర్లను అందిస్తుంది. ఆ రెండు:

• బిట్‌సెట్ (): డిఫాల్ట్ వస్తువును సృష్టించడానికి ఇది నో-ఆర్గ్యుమెంట్ కన్స్ట్రక్టర్.
• బిట్‌సెట్ (పూర్ణాంక పరిమాణం): సంఖ్యను సూచించే పూర్ణాంక వాదన యొక్క ప్రారంభ పరిమాణంతో బిట్‌సెట్ క్లాస్ యొక్క ఉదాహరణను రూపొందించడానికి ఇది పూర్ణాంక వాదనలు కలిగిన ఒక-కన్స్ట్రక్టర్. బిట్స్.

ఉదాహరణకి:

java.util.BitSet పబ్లిక్ క్లాస్ BitSetJavaExample {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {int n = 8 BitSet p = కొత్త బిట్‌సెట్ (n) కోసం (int i = 0i
 
 
ఇప్పుడు మనం మరింత ముందుకు వెళ్లి, జావాలోని బిట్స్ పై ఈ వ్యాసంలో చర్చించబోయే తదుపరి అంశాన్ని పరిశీలిద్దాం,
 బిట్సెట్ జావా పద్ధతులు మరియు వివరణలు 
 బిట్‌సెట్ మరియు () పద్ధతి  
పేర్కొన్న ఆర్గ్యుమెంట్‌తో టార్గెట్ బిట్‌సెట్ యొక్క తార్కిక మరియు ఆపరేషన్ చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. సెట్ యొక్క విలువ నిజమవుతుంది మరియు ప్రారంభంలో బిట్‌సెట్ మరియు సంబంధిత బిట్ సెట్ రెండూ నిజమైన విలువను కలిగి ఉంటేనే.
 సింటాక్స్: పబ్లిక్ శూన్యత మరియు (బిట్‌సెట్ సెట్)
 ఉదాహరణ: 
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetAndExample2 {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {// 2 బిట్‌సెట్‌లను సృష్టించండి BitSet bitset1 = new BitSet () BitSet bitset2 = new BitSet () // విలువలను bitset1 bitset1.set ( 1) బిట్‌సెట్ 1.సెట్ (2) బిట్‌సెట్ 1.సెట్ (3) బిట్‌సెట్ 1.సెట్ (6) బిట్‌సెట్ 1.సెట్ (7) // విలువలను బిట్‌సెట్ 2 బిట్‌సెట్ 2.సెట్ (10) బిట్‌సెట్ 2.సెట్ (20) బిట్‌సెట్ 2.సెట్ (30) bitset2.set (40) bitset2.set (60) // సెట్స్‌ని ప్రింట్ చేయండి System.out.println ('bitset1:' + bitset1) System.out.println ('bitset2:' + bitset2) // రెండు మధ్య పనితీరు మరియు ఆపరేషన్ bitsets bitset1.and (bitset2) // కొత్త bitset1 System.out.println ('result bitset:' + bitset1) print print
 అవుట్పుట్: 
  
 బిట్‌సెట్ మరియు నోట్ () విధానం 
పేర్కొన్న బిట్‌సెట్‌లో ఇప్పటికే సంబంధిత బిట్‌లు సెట్ చేయబడిన బిట్‌సెట్‌లోని మొత్తం బిట్‌ను క్లియర్ చేయడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది.
 సింటాక్స్- పబ్లిక్ శూన్యత మరియు నోట్ (బిట్‌సెట్ సెట్)
 ఉదాహరణ: 
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetAndNotExample2 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {బిట్‌సెట్ బిట్‌సెట్ 1 = కొత్త బిట్‌సెట్ () బిట్‌సెట్ 1.సెట్ (60) బిట్‌సెట్ 1.సెట్ (61) బిట్‌సెట్ 1.సెట్ (62) బిట్‌సెట్ 1.సెట్ (62) 63) బిట్‌సెట్ 1.సెట్ (64) // సెట్స్‌ని ప్రింట్ చేయండి System.out.println ('బిట్‌సెట్ 1:' + బిట్‌సెట్ 1) // బిట్‌సెట్ మరియు శూన్య త్రో మినహాయింపు బిట్‌సెట్ 1. మరియు నోట్ (శూన్య) మధ్య ఆపరేషన్ చేయవద్దు మరియు కొత్త బిట్‌సెట్ 1 సిస్టమ్‌ను ప్రింట్ చేయండి .out.println ('మరియు ఫలితం తర్వాత బిట్‌సెట్:' + బిట్‌సెట్ 1)}}
 అవుట్పుట్: - 
  
 బిట్‌సెట్ కార్డినాలిటీ () విధానం  
ఈ పద్ధతి బిట్‌సెట్‌లో నిజం అయిన no.of బిట్‌లను మాత్రమే తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది.
 సింటాక్స్- పబ్లిక్ ఇంటెంట్ కార్డినాలిటీ ()
 ఉదాహరణ 
జావాలోని వస్తువుల శ్రేణి
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetCardinalityExample1 {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {// ఒక బిట్‌సెట్‌ను సృష్టించండి బిట్‌సెట్ బిట్‌సెట్ = కొత్త బిట్‌సెట్ () // బిట్‌సెట్‌కు విలువలను కేటాయించండి బిట్‌సెట్.సెట్ (10) బిట్‌సెట్.సెట్ (11) ) bitset.set (12) bitset.set (15) bitset.set (16) // సెట్స్‌ని ప్రింట్ చేయండి System.out.println ('bitset:' + bitset) int trueBits = bitset.cardinality () // ప్రింట్ బిట్‌సెట్ కార్డినాలిటీ System.out.println ('నిజమైన బిట్ల సంఖ్య:' + trueBits) bitset.clear (2) System.out.println ('స్పష్టమైన సూచిక 2 తర్వాత బిట్‌సెట్:' + బిట్‌సెట్) trueBits = bitset.cardinality () // ప్రింట్ బిట్‌సెట్ స్పష్టమైన సూచిక 2 తర్వాత కార్డినాలిటీ System.out.println ('స్పష్టమైన సూచిక 2 తర్వాత నిజమైన బిట్ల సంఖ్య:' + ట్రూబిట్స్)}}
 అవుట్పుట్- 
  
 బిట్‌సెట్ క్లోన్ () విధానం 
ఈ పద్ధతి బిట్‌సెట్ యొక్క క్లోన్‌ను కొత్త బిట్‌సెట్‌గా చేయడానికి ఉపయోగించబడుతుంది. ఈ బిట్‌సెట్ ప్రస్తుత అసలు బిట్‌సెట్‌కు సమానం. క్లోన్ బిట్‌సెట్ అసలు బిట్‌సెట్ కలిగి ఉన్న అదే నిజమైన విలువలను కలిగి ఉంటుంది.
 సింటాక్స్- పబ్లిక్ ఆబ్జెక్ట్ క్లోన్ ()
 ఉదాహరణ  - 
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetCloneExample1 {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {బిట్‌సెట్ బిట్‌సెట్ఆరిజినల్ = కొత్త బిట్‌సెట్ (15) బిట్‌సెట్ఆరిజినల్.సెట్ (12) బిట్‌సెట్ఆరిజినల్.సెట్ (13) బిట్‌సెట్ఆరిజినల్.సెట్ (15) (16) bitsetOriginal.set (18) // ప్రింట్ కరెంట్ బిట్‌సెట్ System.out.println ('ప్రస్తుత బిట్‌సెట్:' + బిట్‌సెట్ఆరిజినల్) // ప్రస్తుత బిట్‌సెట్ యొక్క క్లోన్‌ను తయారు చేస్తుంది ఆబ్జెక్ట్ బిట్‌సెట్క్లోన్ = బిట్‌సెట్ఆరిజినల్.క్లోన్ () // ప్రింట్ క్లోన్ బిట్‌సెట్ సిస్టమ్. out.println ('క్లోన్ బిట్‌సెట్:' + బిట్‌సెట్క్లోన్)}}
 అవుట్పుట్ 
   
 బిట్‌సెట్ సమానం () విధానం  
జావా బిట్‌సెట్ యొక్క ఈ పద్ధతి ప్రస్తుత బిట్‌సెట్ ఆబ్జెక్ట్‌ను పేర్కొన్న బిట్‌సెట్ ఆబ్జెక్ట్‌తో పోల్చడానికి ఉపయోగించబడుతుంది.
పేర్కొన్న బిట్‌సెట్ ఆబ్జెక్ట్ శూన్యంగా లేనట్లయితే మరియు బిట్‌సెట్ ఆబ్జెక్ట్ యొక్క సమితి ఈ బిట్‌సెట్ వలె నిజమైన విలువకు సమానమైన బిట్‌సెట్‌ను కలిగి ఉంటే మాత్రమే బిట్‌సెట్‌ను పోల్చిన ఫలితం నిజం అవుతుంది.
 సింటాక్స్- పబ్లిక్ బూలియన్ సమానం (ఆబ్జెక్ట్ ఆబ్జెక్ట్)
 ఉదాహరణ  - 
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetEqualsExample1 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {// బిట్‌సెట్‌ను సృష్టించడం బిట్‌సెట్ బిట్‌సెట్ = కొత్త బిట్‌సెట్ (15) ఆబ్జెక్ట్ ఆబ్జెక్ట్ = కొత్త బిట్‌సెట్ (15) బిట్‌సెట్.సెట్ (10) బిట్‌సెట్.సెట్ (11) bitset.set (12) bitset.set (13) bitset.set (14) ((BitSet) obj) .సెట్ (10) ((BitSet) obj) .సెట్ (11) ((BitSet) obj). సెట్ (12) ((బిట్‌సెట్) ఆబ్జెక్ట్) .సెట్ (13) ((బిట్‌సెట్) ఆబ్జెక్ట్) .సెట్ (14) // ప్రింట్ కరెంట్ బిట్‌సెట్‌లు System.out.println ('బిట్‌సెట్:' + బిట్‌సెట్) System.out.println ( 'object:' + obj) బూలియన్ bol = bitset.equals (obj) if (bol == true) {System.out.println ('BitSet పేర్కొన్న వస్తువుకు సమానం')} else {System.out.println ('BitSet పేర్కొన్న వస్తువుకు సమానం కాదు ')}}}
 
 అవుట్పుట్ 
  
 BitSet isEmpty Method  
ఈ బిట్‌సెట్‌లో ఒప్పుకు సెట్ చేయబడిన బిట్‌లు లేకపోతే ఈ పద్ధతి నిజం అవుతుంది.   
 సింటాక్స్- పబ్లిక్ బూలియన్ isEmpty ()
 ఉదాహరణ 
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetIsEmptyExample1 {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {BitSet bitset1 = new BitSet (15) BitSet bitset2 = new BitSet (15) bitset1.set (11) bitset1.set (12) bitset1 .set (13) bitset1.set (14) System.out.println ('bitset1:' + bitset1) System.out.println ('bitset2:' + bitset2) // బిట్‌సెట్ 1 ఖాళీగా లేనందున తప్పుడు తిరిగి వస్తుంది బూలియన్ b1 = బిట్‌సెట్ 1 .isEmpty () // బిట్‌సెట్ 2 ఖాళీగా ఉన్నందున నిజం అవుతుంది బూలియన్ b2 = bitset2.isEmpty () System.out.println ('bitset1 isEmpty:' + b1) System.out.println ('bitset2 isEmpty:' + b2)}}
 అవుట్పుట్ 
   
 బిట్‌సెట్ పొడవు () విధానం  
ఈ పద్ధతి ఈ బిట్‌సెట్ యొక్క తార్కిక పరిమాణాన్ని అందిస్తుంది. పొడవు అత్యధిక సెట్ బిట్ ప్లస్ వన్ యొక్క సూచిక వరకు వెళుతుంది.బిట్ సెట్‌లో బిట్ ఉండకపోతే అది సున్నా అవుతుంది.
 సింటాక్స్- పబ్లిక్ పూర్ణాంక పొడవు ()
 ఉదాహరణ- 
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetLengthExample1 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {బిట్‌సెట్ బిట్‌సెట్ 1 = కొత్త బిట్‌సెట్ (15) బిట్‌సెట్ బిట్‌సెట్ 2 = కొత్త బిట్‌సెట్ (15) బిట్‌సెట్ బిట్‌సెట్ 3 = కొత్త బిట్‌సెట్ (15) బిట్‌సెట్ 2.సెట్ ) bitset2.set (12) bitset2.set (13) bitset2.set (14) bitset3.set (12) bitset3.set (14) bitset3.set (16) bitset3.set (18) bitset3.set (0) bitset3 .set (2) System.out.println ('bitset1:' + bitset1) System.out.println ('bitset2:' + bitset2) System.out.println ('bitset3:' + bitset3) int length1 = bitset1.length () int length2 = bitset2.length () int length3 = bitset3.length () System.out.println ('బిట్‌సెట్ 1 యొక్క పొడవు:' + length1) System.out.println ('బిట్‌సెట్ 2 యొక్క పొడవు:' + length2) సిస్టమ్. out.println ('బిట్‌సెట్ 3 యొక్క పొడవు:' + పొడవు 3)}}
 అవుట్పుట్- 
జావాలో ఇటరేటర్ ఏమి చేస్తుంది
  
 బిట్‌సెట్ కలుస్తుంది () పద్ధతి 
పారామితి బిట్‌సెట్ బిట్‌సెట్‌తో కలుస్తుందా లేదా అనే ప్రాతిపదికన ఈ పద్ధతి బూలియన్ విలువను నిజం లేదా తప్పు అని అందిస్తుంది.ఈ బిట్‌సెట్‌లో బిట్‌సెట్ సెట్ కూడా నిజమైతే ఇది నిజం అవుతుంది.
 సింటాక్స్- పబ్లిక్ బూలియన్ ఖండన (బిట్‌సెట్ సెట్)
 ఉదాహరణ 
దిగుమతి java.util.BitSet పబ్లిక్ క్లాస్ BitSetEntersectsExample2 {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {బిట్‌సెట్ బిట్‌సెట్ = కొత్త బిట్‌సెట్ (15) బిట్‌సెట్.సెట్ (11) బిట్‌సెట్.సెట్ (12) బిట్‌సెట్.సెట్ (13) బిట్‌సెట్.సెట్ (14) System.out.println ('బిట్‌సెట్:' + బిట్‌సెట్) // బిట్‌సెట్ మరియు శూన్య త్రో మినహాయింపుల మధ్య ఆపరేషన్ చేయవద్దు బూలియన్ b = bitset.intersects (శూన్య) System.out.println ('బిట్‌సెట్ మరియు శూన్య మధ్య ఖండన ఫలితం: '+ బి)}}
 అవుట్పుట్- 
బిట్‌వైస్ ఆపరేటర్ల సహాయంతో, మేము AND, OR, NOT, XOR వంటి వివిధ కార్యకలాపాలను అమలు చేయవచ్చు. అవి చిన్న స్థాయిలో పనిచేస్తాయి. వాటిని ఏదైనా పూర్ణాంక రకానికి అన్వయించవచ్చు. బిట్‌వైస్ ఆపరేటర్లు బిట్ స్థాయిలో పనిచేస్తారు. అవి వేగంగా ఉంటాయి మరియు తక్కువ మెమరీ అవసరం. చాలా క్రిప్టోగ్రఫీ అల్గోరిథంలు బిట్ స్థాయిలో కూడా పనిచేస్తాయి.
ఇది అబ్బాయిలు. ఇది బిట్స్ ఇన్ జావాలో ఈ వ్యాసం చివరకి మనలను తీసుకువస్తుంది. మీరు ఈ సమాచారాన్ని ఆస్వాదించారని నేను నమ్ముతున్నాను. చూడండి  విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.