स्वच्छ ऐप अपडेट कोड 2 बूलियनों को 1 इंट Android में स्टोर करके

हर ऐप डेवलपर को इस स्थिति का सामना करना पड़ा होगा जहां वे एक ही प्रकार के दो मूल्यों को संग्रहीत करना चाहते हैं। विशिष्ट उदाहरण ऐप अपडेट को प्रबंधित कर रहा है जहां आप जांचना चाहते हैं कि अपडेट उपलब्ध है या नहीं और यदि उपलब्ध है तो क्या यह एक अनिवार्य अपडेट है? इन मूल्यों के आधार पर हम अक्सर तय करते हैं कि उपयोगकर्ता को ऐप का उपयोग जारी रखने की अनुमति दें या उपयोगकर्ताओं को अपडेट करने के लिए मजबूर करें। सरल समाधान दो बूलियन घोषित करना है, एक isUpdateAvailable के साथ और दूसरा isMandatoryUpdate के साथ। क्या होगा अगर हम इन दो बुलियन वेरिएबल्स को एक इंटेगर में मर्ज कर सकते हैं। हम पूर्णांक के प्रत्येक बिट मान को बूलियन के रूप में उपयोग करके ऐसा कर सकते हैं और ऐसा करने के लिए हमें निम्नलिखित चीज़ों को जानना होगा:

Pic क्रेडिट: anysoftwaretools.com

इंट में विशिष्ट स्थिति पर थोड़ा कैसे सेट करें?

सेट द्वारा, मेरा मतलब है कि थोड़ा सा मूल्य 1। हम इसे बिटसेट क्लास का उपयोग करके प्राप्त कर सकते हैं, लेकिन यह बहुत सारी नई जानकारी होगी इसलिए हम सरल बिटवाइज़ लॉजिकल ऑपरेशंस के साथ आगे बढ़ेंगे।
मान लीजिए कि हमारे पास int myOriginalValue = 0b0010 है; हम 3 बिट को 1 पर सेट करना चाहते हैं

कदम :

  1. 1 के लिए थोड़ा मान सेट करने के लिए हम 1 का बाइनरी मान लेंगे और इसे पोज़िशन टाइम से शिफ्ट कर देंगे जिसका मतलब है कि हम 1 बाय 3 बार शिफ्ट छोड़ देंगे।
    0b0001 << 3 = 0b1000
  2. अब हम myOriginalValue के खिलाफ उत्पादन करेंगे।

संदर्भ:

  1. बाइट में एक विशिष्ट बिट कैसे सेट करें
  2. जावा में Bitwise Shifting कैसे काम करता है
  3. जावा बिटसेट उदाहरण

अब हम अपने उपयोग के मामले में इसका उपयोग कैसे कर सकते हैं, इसे जाने दें।

बूलियन फ़ील्ड के रूप में प्रत्येक इंट का उपयोग करना:

आइडिया एक इंट के बिट्स का उपयोग करना है और हर बिट को किसी उद्देश्य के लिए असाइन करना है। हमारे उपर्युक्त अपडेट ऐप उदाहरण में हम 2 बिट्स का उपयोग करेंगे, 1 isUpdateAvailable के लिए और दूसरा isMandatoryUpdate के लिए। आइए क्रमशः उनके लिए 1 और 2 को थोड़ा स्थान दें। अब मान लें कि ऐप शुरू हो गया है और स्पलैश वेबसेवा कहा जाता है और अनुरोध निकाय में ऐप का वर्तमान संस्करण भेजना है, सर्वर प्रतिक्रिया कहती है कि एक अपडेट उपलब्ध है इसलिए हमें ट्रू को isUpdateAvailable सेट करने की आवश्यकता है। यह निम्न प्रकार से इंट चर पर किया जा सकता है:

उपरोक्त कोड को निष्पादित करने के बाद हमने mUpdateValue की बिट स्थिति 1 को सही पर सेट किया है। निम्नलिखित स्निपेट को देखें कि हम बिट स्थिति 1 (UPDATE_AVAILABLE) के मूल्य की जांच कैसे कर सकते हैं।

  • चरण 1: 1 UPDATE_AVAILABLE समय पर BitwiseLeftShift प्रदर्शन करेगा। जो 1 << 1. बाइनरी 1 = 0001 में होगा इसलिए प्रदर्शन करने के बाद << 1 समय 0001 0010 हो जाएगा।
  • चरण 2: बिटवाइज और mUpdateValue और STEP 1 के आउटपुट पर करेंगे।
    0010 और 0010 का परिणाम 0010 होगा।
  • परिणाम: STEP 2 का आउटपुट 0 के बराबर नहीं है, इसलिए बिट स्थिति 1 (UPDATE_AVAILABLE) का मान सत्य है।

नीचे दोनों बिट कविताओं को सच करने और उनके मूल्यों को वापस जाँचने का पूरा उदाहरण है:

निष्कर्ष:

कल्पना कीजिए कि आप उस स्वास्थ्य ऐप पर काम कर रहे हैं जहाँ आप किसी मरीज के मेडिकल इतिहास को स्टोर करना चाहते हैं जैसे कि मौसम के रोगी को कभी मलेरिया, अस्थमा, टायरोइड और ब्ला ब्ला ब्ला था। इसके परिणामस्वरूप हर बीमारी के लिए डेटाबेस में एक कॉलम जोड़ा जाएगा और आप इसमें 0 या 1 स्टोर करेंगे क्योंकि SQLite बूलियन मूल्यों का समर्थन नहीं करता है। इस दृष्टिकोण के साथ आप 32 रोगों को एक पूर्णांक कॉलम में संग्रहीत कर सकते हैं और प्रति बीमारी कॉलम बनाने से बच सकते हैं।

पेशेवरों:

  • कई क्षेत्रों को जोड़ती है।
  • Db उपज में db में से कोई भी कॉलम नहीं पढ़ता है और प्रदर्शन को लिखता है।
  • सही या गलत की जाँच के लिए सरल एक लाइन कोड।

विपक्ष:

  • प्रत्येक क्षेत्र को स्थैतिक बिट स्थिति के साथ सौंपा जाना है इसलिए स्थैतिक क्षेत्रों की घोषणा में वृद्धि हुई है।

मैंने उपर्युक्त परिदृश्य स्रोत कोड के साथ एक सरल डेमो हेल्थ ऐप बनाया है जो यहां पाया जा सकता है:

क्रेडिट:

यह विचार मूल रूप से मेरे सहयोगी शीन सिंह द्वारा लागू किया गया था। मैंने बस इसे शब्दों में ढालने की कोशिश की है। और तकनीकी संपादन में मदद करने के लिए धर्मेश सोजित्रा को धन्यवाद।

आगे की पढाई :

32 से अधिक क्षेत्र क्यों नहीं?

क्योंकि हम int का उपयोग कर रहे हैं, जिसका आकार 32 बिट्स का मतलब है 32 possbile 1 और 0s। इसलिए जब आप 1 << 33 बार करने का प्रयास करते हैं तो आपको 0b0010 मिलता है जो कि 1 << 1 समय के समान है।

यदि हमारे पास 32 से अधिक क्षेत्र हैं तो क्या होगा?

यहां तक ​​कि अगर हम 32 के इंट के आकार तक सीमित हैं, तो हम डेटा प्रकार इंट तक ही सीमित नहीं हैं, हम इसे लंबे समय तक बदल सकते हैं और इसे 64 क्षेत्रों में सक्षम बना सकते हैं। 1 लंबे = 64 बिट्स के बाद से।

यदि हमारे पास 64 से अधिक क्षेत्र हैं तो क्या होगा?

अब अगर हम इसे बड़ा करने जा रहे हैं तो लंबी सरणी का उपयोग करने पर विचार करना बेहतर है। हम वांछित आकार के साथ एक लंबा [] बना सकते हैं और फिर 0 [63] को लंबे [0], 64 से 127 क्षेत्रों को लंबे [1] और इतने पर स्टोर कर सकते हैं।

चर्चा, आलोचना और साझा करने के लिए स्वतंत्र महसूस करें।

मेरा लिंक्डइन, ट्विटर। कनेक्ट करते हैं। :)

Blog.mindorks.com पर सभी शीर्ष लेख देखें