पूर्णांक जावा में एक छोटे स्तर पर आंतरिक रूप से कैसे प्रस्तुत किए जाते हैं?

Question 1

मैं यह समझने की कोशिश कर रहा हूं कि जावा आंतरिक रूप से पूर्णांक कैसे संग्रहीत करता है। मुझे पता है कि सभी जावा आदिम पूर्णांक पर हस्ताक्षर किए गए हैं, (संक्षेप को छोड़कर?)। इसका मतलब है कि संख्या के लिए बाइट में एक कम बिट उपलब्ध है।

मेरा प्रश्न यह है कि क्या सभी पूर्णांक (धनात्मक और ऋणात्मक) दो के पूरक के रूप में संग्रहीत हैं या केवल दो के पूरक में ऋणात्मक संख्याएँ हैं?

मैं देखता हूं कि चश्मा कहता है x bit two's complement number। लेकिन मैं अक्सर भ्रमित हो जाता हूं।

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

  int x = 15; // Stored as binary as is?  00000000 00000000 00000000 00001111?
  int y = -22; // Stored as two complemented value? 11111111 11111111 11111111 11101010

संपादित करें

स्पष्ट होना, x = 15

   In binary as is: `00000000 00000000 00000000 00001111'
  Two's complement: `11111111 11111111 11111111 11110001`

इसलिए यदि आपका उत्तर allसंख्या दो के पूरक के रूप में संग्रहीत है तो:

  int x = 15; // 11111111 11111111 11111111 11110001
  int y = -22 // 11111111 11111111 11111111 11101010

यहां भ्रम फिर से संकेत है, दोनों नकारात्मक संख्याएं हैं। क्या मैं इसे गलत समझ रहा हूं / गलत समझ रहा हूं?

संपादित करें सुनिश्चित नहीं हैं कि मेरा प्रश्न भ्रामक है। प्रश्न को अलग करने के लिए मजबूर:

मेरा प्रश्न ठीक है: क्या सकारात्मक संख्याएं संग्रहीत हैं binary as isजबकि नकारात्मक संख्याएं संग्रहीत हैं two's complement?

कुछ ने कहा कि सभी को दो के पूरक में संग्रहीत किया जाता है और एक उत्तर कहता है कि केवल नकारात्मक संख्या को दो के पूरक के रूप में संग्रहीत किया जाता है।

Question 2

आइए जावा आदिम डेटा प्रकारों को संक्षेप में शुरू करते हैं:

बाइट : बाइट डेटा प्रकार एक 8-बिट हस्ताक्षरित दो के पूरक पूर्णांक है ।

लघु : लघु डेटा प्रकार एक 16-बिट हस्ताक्षरित दो के पूरक पूर्णांक है ।

int: इंट डेटा प्रकार एक 32-बिट हस्ताक्षरित दो के पूरक पूर्णांक है ।

लंबा: लंबा डेटा प्रकार एक 64-बिट हस्ताक्षरित दो के पूरक पूर्णांक है ।

फ्लोट: फ्लोट डेटा प्रकार एक एकल-सटीक 32-बिट IEEE 754 फ़्लोटिंग पॉइंट है ।

डबल : डबल डेटा प्रकार एक डबल-सटीक 64-बिट IEEE 754 फ़्लोटिंग पॉइंट है ।

बूलियन: बूलियन डेटा प्रकार एक बिट जानकारी का प्रतिनिधित्व करता है ।

char: char डेटा प्रकार एक एकल 16-बिट यूनिकोड वर्ण है ।

स्रोत

दो का अनुपूरण

"अच्छा उदाहरण विकी से है कि दो के पूरक का संबंध 256 = 255 + 1 को देखते हुए महसूस किया जाता है, और (255 - x) x का पूरक है।

0000 0111 = 7 दो का पूरक 1111 1001 = -7 है

जिस तरह से यह काम करता है वह एमएसबी (सबसे महत्वपूर्ण बिट) है इसलिए उपरोक्त मामले में नकारात्मक मूल्य प्राप्त होता है

-7 = 1001 = -8 + 0+ 0+ 1

सकारात्मक पूर्णांक आमतौर पर सरल बाइनरी संख्याओं के रूप में संग्रहीत होते हैं (1 है 1, 10 2 है, 11 3 और इसी तरह)।

ऋणात्मक पूर्णांकों को उनके पूर्ण मूल्य के पूरक के रूप में संग्रहीत किया जाता है। एक सकारात्मक संख्या का पूरक दो है जब यह अंकन एक ऋणात्मक संख्या का उपयोग करता है।

स्रोत

चूंकि मुझे इस उत्तर के लिए कुछ अंक मिले, इसलिए मैंने इसमें और जानकारी जोड़ने का फैसला किया।

एक अधिक विस्तृत जवाब:

बाइनरी में सकारात्मक और नकारात्मक संख्याओं का प्रतिनिधित्व करने के लिए अन्य चार मुख्य दृष्टिकोण हैं:

हस्ताक्षरित परिमाण
एक के पूरक
दो का अनुपूरण
पक्षपात

1. हस्ताक्षरित परिमाण

संकेत का प्रतिनिधित्व करने के लिए सबसे महत्वपूर्ण बिट का उपयोग करता है, शेष बिट्स का उपयोग निरपेक्ष मूल्य का प्रतिनिधित्व करने के लिए किया जाता है। जहां 0 एक सकारात्मक संख्या का प्रतिनिधित्व करता है और 1 नकारात्मक संख्या का प्रतिनिधित्व करता है , उदाहरण:

1011 = -3
0011 = +3

यह प्रतिनिधित्व सरल है। हालाँकि, आप बाइनरी संख्याओं को उसी तरह नहीं जोड़ सकते हैं जैसे आप दशमलव संख्याओं को जोड़ते हैं, जिससे हार्डवेयर स्तर पर इसे लागू करना कठिन हो जाता है। इसके अलावा, यह दृष्टिकोण 0, 100 ... 0 और 0 .... 0 का प्रतिनिधित्व करने के लिए दो बाइनरी पैटर्न का उपयोग करता है।

2. एक का पूरक

इस निरूपण में, हम दिए गए संख्या के सभी बिट्स को इसके पूरक का पता लगाने के लिए उल्टा करते हैं। उदाहरण के लिए:

010 = 2, so -2 = 101 (inverting all bits).

इस प्रतिनिधित्व की समस्या यह है कि अभी भी 0 (00..0 और 11..1) का प्रतिनिधित्व करने के लिए दो बिट पैटर्न मौजूद हैं

3. दो का पूरक

एक संख्या का नकारात्मक पता लगाने के लिए, इस प्रतिनिधित्व में, हम सभी बिट्स को उल्टा करते हैं और फिर एक बिट जोड़ते हैं। एक बिट जोड़ने से दो बिट्स पैटर्न का प्रतिनिधित्व करने की समस्या हल होती है। इस प्रतिनिधित्व में, हमारे पास केवल एक (00 ... 0) है।

उदाहरण के लिए, हम 4 बिट्स का उपयोग करके 4 (दशमलव) के द्विआधारी ऋणात्मक प्रतिनिधित्व को खोजना चाहते हैं। सबसे पहले, हम 4 को बाइनरी में बदलते हैं:

4 = 0100

तो हम सभी बिट्स पलटना

0100 -> 1011

अंत में, हम एक बिट जोड़ते हैं

1011 + 1 = 1100.

तो 1100 दशमलव में -4 के बराबर है अगर हम 4 बिट्स के साथ दो के पूरक बाइनरी प्रतिनिधित्व का उपयोग कर रहे हैं।

पूरक को खोजने का एक तेज़ तरीका पहला बिट को ठीक करना है जो मान 1 के रूप में है और शेष बिट्स को निकालना है। उपरोक्त उदाहरण में यह कुछ इस तरह होगा:

0100 -> 1100
^^ 
||-(fixing this value)
|--(inverting this one)

दो के पूरक प्रतिनिधित्व, 0 के लिए केवल एक प्रतिनिधित्व होने के अलावा, यह दो द्विआधारी मूल्यों को भी उसी तरह जोड़ता है जैसे दशमलव में, यहां तक कि विभिन्न संकेतों के लिए भी संख्या। फिर भी, अतिप्रवाह मामलों की जांच करना आवश्यक है।

4. बायस

इस प्रतिनिधित्व का उपयोग अस्थायी बिंदुओं के लिए IEEE 754 मानदंड में प्रतिपादक का प्रतिनिधित्व करने के लिए किया जाता है। इसका यह लाभ है कि सभी बिट्स के साथ बाइनरी मान शून्य तक का प्रतिनिधित्व करता है। और 1 से सभी बिट्स के साथ द्विआधारी मूल्य सबसे बड़े मूल्य का प्रतिनिधित्व करता है। जैसा कि नाम से संकेत मिलता है, मान द्विआधारी (सकारात्मक या नकारात्मक) में एक बिट्स के साथ बायस (सामान्य रूप से 2 ^ (एन -1) या 2 ^ (एन -1) -1) के साथ होता है।

इसलिए अगर हम 8 बिट्स का उपयोग कर रहे हैं, तो दशमलव में मान 1 को द्विआधारी में 2 ^ (n-1) का उपयोग करके दर्शाया जाता है, मान द्वारा:

+1 + bias = +1 + 2^(8-1) = 1 + 128 = 129
converting to binary
1000 0001

Question 3

जावा पूर्णांक 32 बिट्स के हैं, और हमेशा हस्ताक्षरित होते हैं। इसका मतलब है, सबसे महत्वपूर्ण बिट (MSB) साइन बिट के रूप में काम करता है। पूर्णांक जो कि प्रतिनिधित्व करता है int, वह बिट्स के भारित योग के अलावा और कुछ नहीं है। भार इस प्रकार हैं:

Bit#    Weight
31      -2^31
30       2^30
29       2^29
...      ...
2        2^2
1        2^1
0        2^0

ध्यान दें कि MSB का वजन ऋणात्मक (वास्तव में सबसे बड़ा संभव ऋणात्मक) है, इसलिए जब यह बिट होता है, तो पूरी संख्या (भारित राशि) ऋणात्मक हो जाती है।

आइए इसे 4-बिट संख्याओं के साथ अनुकरण करें:

Binary    Weighted sum            Integer value
0000       0 + 0 + 0 + 0           0
0001       0 + 0 + 0 + 2^0         1
0010       0 + 0 + 2^1 + 0         2
0011       0 + 0 + 2^1 + 2^0       3
0100       0 + 2^2 + 0 + 0         4
0101       0 + 2^2 + 0 + 2^0       5
0110       0 + 2^2 + 2^1 + 0       6
0111       0 + 2^2 + 2^1 + 2^0     7 -> the most positive value
1000      -2^3 + 0 + 0 + 0        -8 -> the most negative value
1001      -2^3 + 0 + 0 + 2^0      -7
1010      -2^3 + 0 + 2^1 + 0      -6
1011      -2^3 + 0 + 2^1 + 2^0    -5
1100      -2^3 + 2^2 + 0 + 0      -4
1101      -2^3 + 2^2 + 0 + 2^0    -3
1110      -2^3 + 2^2 + 2^1 + 0    -2
1111      -2^3 + 2^2 + 2^1 + 2^0  -1

इसलिए, नकारात्मक पूर्णांकों का प्रतिनिधित्व करने के लिए दोनों की पूरक चीज कोई विशेष योजना नहीं है, बल्कि हम यह कह सकते हैं कि पूर्णांक के द्विआधारी प्रतिनिधित्व हमेशा समान होते हैं, हम सिर्फ सबसे महत्वपूर्ण बिट के वजन को नकारते हैं। और वह बिट पूर्णांक के संकेत को निर्धारित करता है।

सी में, एक कीवर्ड है unsigned(जावा में उपलब्ध नहीं है), जिसे घोषित करने के लिए उपयोग किया जा सकता है unsigned int x;। अहस्ताक्षरित पूर्णांकों में, MSB का वजन 2^31ऋणात्मक होने के बजाय सकारात्मक ( ) है। उस मामले में एक की सीमा unsigned intहै 0करने के लिए 2^32 - 1, जबकि एक intश्रृंखला है -2^31करने के लिए 2^31 - 1।

एक अन्य दृष्टिकोण से, यदि आप दो के पूरक के xरूप में मानते हैं ~x + 1(नहीं x प्लस एक), यहाँ स्पष्टीकरण है:

किसी के लिए x, ~xका सिर्फ बिटवाइज़ उल्टा होता है x, इसलिए जहां भी xएक है 1-बिट, ~xएक होगा 0वहाँ -बिट (और इसके विपरीत)। इसलिए, यदि आप इन्हें जोड़ते हैं, तो इसके अतिरिक्त कोई वहन नहीं होगा और योग बस एक पूर्णांक होगा जिसमें से प्रत्येक बिट है 1।

32-बिट पूर्णांक के लिए:

x + ~x = 1111 1111 1111 1111 1111 1111 1111 1111
x + ~x + 1 =   1111 1111 1111 1111 1111 1111 1111 1111 + 1
           = 1 0000 0000 0000 0000 0000 0000 0000 0000

सबसे बाईं ओर 1की बस को छोड़ दिया जाएगा, क्योंकि यह 32-बिट्स (पूर्णांक अतिप्रवाह) में फिट नहीं होती है। इसलिए,

x + ~x + 1 = 0
-x = ~x + 1

तो आप देख सकते हैं कि ऋणात्मक xका प्रतिनिधित्व किया जा सकता है ~x + 1, जिसे हम दो के पूरक कहते हैं x।

Question 4

मैंने इसे जानने के लिए निम्नलिखित कार्यक्रम चलाया है

public class Negative {
    public static void main(String[] args) {
        int i =10;
        int j = -10;

        System.out.println(Integer.toBinaryString(i));
        System.out.println(Integer.toBinaryString(j));
    }
}

आउटपुट है

1010
11111111111111111111111111110110

आउटपुट से ऐसा लगता है कि यह दो के पूरक का उपयोग कर रहा है।

Question 5

ओरेकल जावा डेटाटिप्स के बारे में कुछ दस्तावेज प्रदान करता है जो आपको दिलचस्प लग सकते हैं। विशेष रूप से:

int: इंट डेटा प्रकार एक 32-बिट हस्ताक्षरित दो के पूरक पूर्णांक है। इसका न्यूनतम मान -2,147,483,648 और अधिकतम मूल्य 2,147,483,647 (समावेशी) है।

Btw, शॉर्ट को दो के पूरक के रूप में भी संग्रहीत किया जाता है।

Question 6

इस दस्तावेज़ के अनुसार , सभी पूर्णांक पर हस्ताक्षर किए गए हैं और जावा के लिए दो पूरक प्रारूप में संग्रहीत किए गए हैं। इसकी विश्वसनीयता के बारे में कुछ भी नहीं ..

Question 7

पॉजिटिव नंबर को स्टोर / रिट्रीव किया जाता है।

e.g) For +ve number 10; byte representation will be like 0-000 0010 
                                               (0 - MSB will represent that it is +ve).
So while retrieving based on MSB; it says it is +ve, 
so the value will be taken as it is.

लेकिन नकारात्मक संख्याओं को 2 के पूरक (MSB बिट के अलावा) के बाद संग्रहीत किया जाएगा, और MSB बिट को 1 पर सेट किया जाएगा।

जैसे) जब भंडारण -10 तब

  0-000 0010  -> (1's complement) -> 0-111 1101 
              -> (2's complement) 0-111 1101 + 1 -> 0-111 1110
  Now MSB will be set to one, since it is negative no -> 1-111 1110

पुनर्प्राप्त करते समय, यह पाया गया कि MSB 1 पर सेट है। इसलिए यह ऋणात्मक नहीं है। और 2 का पूरक एमएसबी के अलावा अन्य प्रदर्शन किया जाएगा।

  1-111 1110  --> 1-000 0001 + 1 --> 1-000 0010
  Since MSB representing this is negative 10 --> hence  -10 will be retrived.

ढलाई

यह भी ध्यान दें कि जब आप बाइट के लिए इंट / शॉर्ट कास्टिंग कर रहे हैं, तो केवल अंतिम बाइट को अंतिम बाइट एमएसबी के साथ माना जाएगा,

उदाहरण "-130" को छोटा लें, यह नीचे की तरह संग्रहीत किया जा सकता है

(MSB)1-(2's complement of)130(1000 0010) --> 1-111 1111 0111 1110

अब बाइट कास्टिंग ने अंतिम बाइट ली जो कि 0111 1110 है। (0-MSB) चूंकि MSB कहता है कि यह + ve वैल्यू है, इसलिए इसे वैसे ही लिया जाएगा। जो 126 है। (+ ve)।

एक और उदाहरण "130" छोटा लें, यह नीचे की तरह संग्रहीत किया जा सकता है

  0-000 000 1000 0010     (MSB = 0)

अब बाइट कास्टिंग अंतिम बाइट हुई जो 1000 0010 है। (1 = MSB) चूंकि MSB कहता है कि यह -ve मान है, 2 का पूरक प्रदर्शन किया जाएगा और ऋणात्मक संख्या वापस आ जाएगी। तो इस मामले में -126 वापस कर दिया जाएगा।

 1-000 0010  -> (1's complement) -> 1-111 1101 
             -> (2's complement) 1-111 1101 + 1 -> 1-111 1110 -> (-)111 1110
               = -126

(इंट) (चार) (बाइट) -1 और (इंट) (शॉर्ट) (बाइट) -1 के बीच का अंतर

(byte)-1       -> 0-000 0001 (2's Comp) -> 0-111 1111 (add sign) -> 1-111 1111
(char)(byte)-1 -> 1-111 1111 1111 1111  (sign bit is carry forwarded on left)

उसी प्रकार

(short)(byte)-1-> 1-111 1111 1111 1111  (sign bit is carry forwarded on left)

परंतु

(int)(char)(byte)-1 -> 0-0000000 00000000 11111111 11111111  = 65535
since char is unsigned; MSB won't be carry forwarded.

तथा

(int)(Short)(byte)-1 -> 1-1111111 11111111 11111111 11111111 = -1
since short is signed; MSB is be carry forwarded.

संदर्भ

नकारात्मक संख्याओं का प्रतिनिधित्व करने के लिए दो के पूरक का उपयोग क्यों किया जाता है?

"2 का पूरक" क्या है?

Question 8

सबसे महत्वपूर्ण बिट (32 वां) इंगित करता है कि संख्या सकारात्मक या नकारात्मक है। यदि यह 0 है, तो इसका मतलब है कि संख्या सकारात्मक है और यह अपने वास्तविक बाइनरी प्रतिनिधित्व में संग्रहीत है। लेकिन अगर यह 1 है, तो इसका मतलब है कि संख्या नकारात्मक है और अपने दो के पूरक प्रतिनिधित्व में संग्रहीत है। इसलिए जब हम अपने द्विआधारी प्रतिनिधित्व से पूर्णांक मान को पुनर्स्थापित करते हुए वजन -2 ^ 32 से 32 वें बिट देते हैं, तो हमें वास्तविक उत्तर मिलता है।

Question 9

धन्यवाद, उत्तर के लिए सपना देखने के लिए https://stackoverflow.com/a/13422442/1065835 ; पर विकि पृष्ठ वे एक उदाहरण है जो मदद की मुझे एक सकारात्मक संख्या के नकारात्मक समकक्ष की द्विआधारी प्रतिनिधित्व पता लगाने के लिए समझ में दे।

उदाहरण के लिए, 1 बाइट (= 2 निबल्स = 8 बिट) का उपयोग करके, दशमलव संख्या 5 का प्रतिनिधित्व किया जाता है

0000 01012 सबसे महत्वपूर्ण बिट 0 है, इसलिए पैटर्न एक गैर-नकारात्मक मूल्य का प्रतिनिधित्व करता है। -5 को दो-पूरक संकेतन में बदलने के लिए, बिट्स उल्टे होते हैं; 0 बन जाता है, और 1 बन जाता है:

1111 1010 इस बिंदु पर, अंक दशमलव मान का पूरक है 0105। दो के पूरक प्राप्त करने के लिए, 1 को परिणाम में जोड़ा जाता है:

1111 1011 परिणाम एक हस्ताक्षरित बाइनरी संख्या है जो दो-पूरक रूप में दशमलव मान in5 का प्रतिनिधित्व करता है। सबसे महत्वपूर्ण बिट 1 है, इसलिए प्रतिनिधित्व किया गया मान ऋणात्मक है।

Question 10

सकारात्मक संख्याओं को सीधे बाइनरी के रूप में संग्रहीत किया जाता है। नेगेटिव नंबर के लिए 2 की तारीफ जरूरी है।

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

15: 00000000 00000000 00000000 00001111
-15: 11111111 11111111 11111111 11110001

यहाँ हस्ताक्षरित बिट में अंतर है।

Question 11

सकारात्मक पूर्णांक के लिए 2'complement मूल्य MSB बिट 0 के साथ समान है (like +14 2'complement is 01110)।

केवल नकारात्मक पूर्णांक के लिए केवल हम 2'complement मान की गणना कर रहे हैं (-14= 10001+1 = 10010)।

तो अंतिम उत्तर दोनों मानों (+ve and -ve)को 2'complement रूप में ही संग्रहीत किया जाता है।