java बिटवे और(और) जावा में कैसे काम करता है?




bit-manipulation bit (5)

एक पूर्णांक स्मृति में बिट्स के अनुक्रम के रूप में दर्शाया गया है। मनुष्यों के साथ बातचीत के लिए, कंप्यूटर को इसे दशमलव अंक के रूप में प्रदर्शित करना होगा, लेकिन सभी गणना बाइनरी के रूप में की जाती है। दशमलव में 123 स्मृति में 1111011 रूप में संग्रहीत किया जाता है।

& ऑपरेटर थोड़ा सा "और" है। नतीजा यह है कि बिट्स जो दोनों संख्याओं में चालू हैं। 1001 & 1100 = 1000 , क्योंकि केवल पहले बिट दोनों में चालू है।

द ऑपरेटर थोड़ा सा "या" है। नतीजा यह है कि बिट्स जो किसी भी संख्या में चालू हैं। 1001 | 1100 = 1101 1001 | 1100 = 1101 , चूंकि दाएं से दूसरी बिट केवल दोनों में शून्य है।

^ और ~ ऑपरेटरों भी हैं, जो क्रमशः बिटोर "एक्सोर" और बिटवाई "नहीं" हैं। अंत में << , >> और >>> शिफ्ट ऑपरेटर हैं।

हुड के तहत, सिस्टम को सिस्टम के आधार पर 01111011 00000000 00000000 00000000 या 00000000 00000000 00000000 01111011 रूप में संग्रहीत किया जाता है। बिटवाई ऑपरेटरों का उपयोग करना, जो प्रतिनिधित्व का उपयोग किया जाता है इससे कोई फर्क नहीं पड़ता, क्योंकि दोनों प्रस्तुतियों को तार्किक संख्या 00000000000000000000000001111011 रूप में माना जाता है। अग्रणी शून्य पत्तियों को दूर करना 1111011 छोड़ देता है।

मैं कुछ कोड उदाहरणों के माध्यम से पढ़ रहा था और ओटकल की वेबसाइट पर उनके बिटवाइ और बिट शिफ्ट ऑपरेटर पेज पर आया था। मेरी राय में यह बिटवाई & समझाते हुए नौकरी के बहुत अच्छा नहीं था। मैं समझता हूं कि यह सीधे थोड़ा सा ऑपरेशन करता है, लेकिन मुझे यकीन नहीं है कि किस प्रकार का ऑपरेशन है, और मैं सोच रहा हूं कि वह ऑपरेशन क्या है। ओरेकल की वेबसाइट से मुझे एक नमूना कार्यक्रम मिला है: http://docs.oracle.com/javase/tutorial/displayCode.html?code=http://docs.oracle.com/javase/tutorial/java/nutsandbolts/examples/BitDemo.java


यदि आप अपने हेक्स कोड के अनुसार दो चर का विस्तार करते हैं, तो ये हैं:

bitmask : 0000 0000 0000 1111
val:      0010 0010 0010 0010

अब, 0000 0000 0000 0010 में एक साधारण बिटवाई और ऑपरेशन परिणाम, जो दशमलव इकाइयों में 2 है। मुझे लगता है कि आप मौलिक बुलीयन संचालन और संख्या प्रणाली के बारे में जानते हैं।


import.java.io.*;
import.java.util.*;

public class Test {
    public static void main(String[] args) {
        int rmv,rmv1;

        //this R.M.VIVEK complete bitwise program for java
        Scanner vivek=new Scanner();
        System.out.println("ENTER THE X value");
        rmv = vivek.nextInt();
        System.out.println("ENTER THE y value");
        rmv1 = vivek.nextInt();

        System.out.println("AND table based\t(&)rmv=%d,vivek=%d=%d\n",rmv,rmv1,rmv&rmv1);//11=1,10=0
        System.out.println("OR table based\t(&)rmv=%d,vivek=%d=%d\n",rmv,rmv1,rmv|rmv1);//10=1,00=0
        System.out.println("xOR table based\t(&)rmv=%d,vivek=%d=%d\n",rmv,rmv1,rmv^rmv1);
        System.out.println("LEFT SWITH based to %d>>4=%d\n",rmv<<4);
        System.out.println("RIGTH SWITH based to %d>>2=%d\n",rmv>>2);

        for(int v=1;v<=10;v++)
            System.out.println("LIFT SWITH based to (-NAGATIVE VALUE) -1<<%d=%p\n",i,-1<<1+i);
    }
}

यह इनपुट मूल्यों पर एक तार्किक ऑपरेशन है। मूल्यों को बाइनरी रूप में रूपांतरित करने के लिए समझें और जहां स्थिति में बॉट बिट्स में 1 है, परिणाम में 1 है। अंत में वापस कनवर्ट करें।

उदाहरण के लिए उन उदाहरण मानों के साथ:

0x2222 =  10001000100010
0x000F =  00000000001111
result =  00000000000010   => 0x0002 or just 2

यह एक बाइनरी और ऑपरेटर है। यह एक एंड ऑपरेशन करता है जो बूलियन लॉजिक का हिस्सा है जिसका प्रयोग आमतौर पर गणना में बाइनरी संख्याओं पर किया जाता है।

उदाहरण के लिए:

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

आप इसे एकाधिक-बिट संख्याओं पर भी कर सकते हैं:

01 & 00 = 00
11 & 00 = 00
11 & 01 = 01
1111 & 0101 = 0101
11111111 & 01101101 = 01101101
...




bit