दिलचस्प पोस्ट
जहां जावाबेन्स का प्रयोग किया जाता है? विंडोज फोन 7 बंद आवेदन बैच अपडेट / EF5 को हटाएं जावास्क्रिप्ट आईई पता लगाने, क्यों नहीं सरल सशर्त टिप्पणियों का उपयोग करें? यह निर्धारित करने के लिए कि क्या गिट एक फ़ाइल को द्विपदीय या पाठ के रूप में संभालती है? कैसे PHP में एक निर्देशिका ज़िप? आधुनिक टीसीपी कनेक्शन की सैद्धांतिक अधिकतम संख्या क्या है जो आधुनिक लिनक्स बॉक्स में हो सकती है मिश्रित सामग्री को अनुमति देने के लिए क्रोम कैसे प्राप्त करें? मैं कैसे परीक्षण कर सकता हूँ यदि एक चर एक संख्या में है Bash? कैसे ग्रिडव्यू में हैडर और उपशीर्षक जोड़ने के लिए स्प्रिंग डाटा के मोंगोटेमप्लेट और मोंगो रिपॉजिटरी में क्या अंतर है? एक सर्वर प्रक्रिया के रूप में Excel फ़ाइलों को पढ़ना जावा का उपयोग जावा में डिफ़ॉल्ट वर्णसेट / एन्कोडिंग कैसे खोजें? विशिष्ट निर्देशांक पर एक जावास्क्रिप्ट क्लिक () घटना को ट्रिगर करना

इन दो गुणन कार्यों को अलग-अलग परिणाम क्यों देते हैं?

सही लंबी मान पाने के लिए मुझे "एल" पत्र जोड़ने की आवश्यकता क्यों है? और अन्य मूल्य क्या है?

long oneYearWithL = 1000*60*60*24*365L; long oneYearWithoutL = 1000*60*60*24*365; System.out.println(oneYearWithL);//gives correct calculation result : 31536000000 System.out.println(oneYearWithoutL)//gives incorrect calculation result: 1471228928 

वेब के समाधान से एकत्रित समाधान "इन दो गुणन कार्यों को अलग-अलग परिणाम क्यों देते हैं?"

 long oneYearWithL = 1000*60*60*24*365L; long oneYearWithoutL = 1000*60*60*24*365; 

आपका पहला मान वास्तव में एक लंबा है (चूंकि 365L long , और 1000*60*60*24 integer , इसलिए integer मान वाले long मान को multiplying करने का परिणाम एक long मूल्य है।

लेकिन दूसरा मान एक पूर्णांक है (चूंकि आप केवल एक integer मान के साथ एक integer मान mulitplying हैं, इसलिए परिणाम 32-bit पूर्णांक होगा। अब उस multiplication लिए प्राप्त परिणाम पूर्णांक की वास्तविक श्रेणी के बाहर है। वेरिएबल को असाइन किया गया है, इसे वैध पूर्णांक श्रेणी में फिट करने के लिए छोटा किया गया है।

निम्नलिखित प्रिंट स्टेटमेंट पर नज़र डालें: –

 System.out.println(1000*60*60*24*365L); System.out.println(1000*60*60*24*365); System.out.println(Integer.MAX_VALUE); * 365) System.out.println(1000*60*60*24*365L); System.out.println(1000*60*60*24*365); System.out.println(Integer.MAX_VALUE); 

जब आप उपरोक्त कोड चलाते हैं: –

आउटपुट: –

 31536000000 1471228928 2147483647 

तो, आप अंतर देख सकते हैं ..

 011101010111101100010010110000000000 -- Binary equivalent of 1000*60*60*24*365L 01111111111111111111111111111111 -- Binary equivalent of Integer.MAX_VALUE 

इसलिए, यदि आप अपने नंबर के अंत में उस L को नहीं जोड़ते हैं, तो 4 सबसे महत्वपूर्ण बिट को पहली बाइनरी स्ट्रिंग से हटा दिया जाता है ..

तो, स्ट्रिंग हो जाती है ..

 (0111)01010111101100010010110000000000 -- Remove the most significant bits.. 01010111101100010010110000000000 -- Binary equivalent of 1471228928 

(जो आपको आउटपुट के रूप में मिलता है)


अद्यतन: – ऊपर की व्याख्या से, आप यह भी समझ सकते हैं कि, पहले असाइनमेंट में भी, अगर 365L साथ गुणा करने से पहले integers multiplication का परिणाम सीमा से बाहर हो जाता है, तो फिर इसे पूर्णांक श्रेणी में फिट करने के लिए छोटा किया जाएगा, या आवश्यक होने पर 2's complement representation परिवर्तित किया जाता है, और उसके बाद केवल इसे long value - 365L साथ गुणा किया जाएगा long value - 365L

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

 long thirtyYearWithL = 1000*60*60*24*30*365L; 

उपरोक्त उदाहरण में, पहले भाग पर विचार करें – 1000*60*60*24*30 इस गुणा का परिणाम है: – 2592000000 अब 'देखते हैं कि यह कैसे binary equivalent में दर्शाया गया है: –

 2592000000 = 10011010011111101100100000000000 -- MSB is `1`, a negative value 01100101100000010011100000000001 -- 2's complement representation 

2's complement प्रस्तुति का दशमलव प्रतिनिधित्व 1702967297 तो, 2592000000 को बदलकर 2592000000 दिया जाता है, इससे पहले कि वह 365L गुणा 365L । अब से, यह मान integer range में फिट बैठता है, जो है: – [-2147483648 to 2147483647] , इसलिए इसे और अधिक छोटा नहीं किया जाएगा

तो, वास्तविक परिणाम होगा: –

 long thirtyYearWithL = 1000*60*60*24*30*365L; = 2592000000 * 365L; = -1702967297 * 365L = -621583063040 

इसलिए, ये सभी सामान केवल गिनती के संचालन को लागू करने के अंतिम परिणाम को अंतिम रूप मानते हैं। और यह जांच left to right ( left to right सहकारीता वाले ऑपरेटर के मुताबिक) चलती परिचालनों के प्रत्येक अस्थायी परिणाम पर की जाती है। अगर कोई अस्थायी परिणाम सीमा से बाहर हो पाया जाता है, तो वह अगले ऑपरेशन के साथ आगे बढ़ने से पहले आवश्यक सीमा में फिट होने के अनुसार तब्दील हो जाता है।


2 अपडेट करें: –

इसलिए, इसके बजाय: –

 long thirtyYearWithL = 1000*60*60*24*30*365L; 

यदि आप शुरू में अपना 365L ले जाते हैं, तो आपको सही परिणाम मिलेगा: –

 long thirtyYearWithL = 365L*1000*60*60*24*30; // will give you correct result 

क्योंकि, अब आपके temporary परिणाम long प्रकार के होंगे, और वह मूल्य रखने में सक्षम है

L बिना आपकी गणना 32-बिट मूल्य के रूप में की जाती है। यदि आप हेक्साडेसिमल के रूप में मूल्यों को व्यक्त करते हैं, तो छोटे मान बड़े मान के केवल 4 बाइट्स हैं।

32 बिट पूर्णांक प्रकार के लिए जावा डिफ़ॉल्ट। L , लांग के लिए, 64 बिट्स हैं 365 बाद L डालकर, आप संकलक को long रूप में 365 का इलाज करने के लिए कह रहे हैं। जब 32 और 64 बिट मानों को गुणा किया जाता है, तो संकलक 32 बिट मान को 64 बिट तक बढ़ाता है, ताकि आपके मध्यवर्ती परिणाम आपके अभिव्यक्ति के मूल्यांकन में पूर्ण 64 बिट श्रेणी बनाए रखे।

जावा भाषा विशिष्टता में आदिम प्रकार और मान देखें।

गुणन के व्यवहार को स्पष्ट रूप से https://docs.oracle.com/javase/specs/jls/se7/html/jls/15.html#jls-15.17.1 पर परिभाषित किया गया है, निम्नानुसार:

15.17.1 गुणा ऑपरेटर *

बाइनरी * ऑपरेटर गुणा करता है, उसके ऑपरेंड के उत्पाद का उत्पादन करता है। गुणा एक commutative ऑपरेशन है अगर ऑपरेटर अभिव्यक्ति का कोई साइड इफेक्ट नहीं है जबकि पूर्णांक गुणन साहचर्य है जब ऑपरेंड एक ही प्रकार के होते हैं, तो फ़्लोटिंग-पॉइंट गुणन संबद्ध नहीं होता है। यदि एक पूर्णांक गुणा अतिप्रवाह होता है, तो परिणाम गणितीय उत्पाद के निम्न-आदेश बिट्स होते हैं, जो कि कुछ पर्याप्त बड़े दो आकृति प्रारूप में दर्शाए गए हैं नतीजतन, यदि अतिप्रवाह होता है, तो परिणाम का संकेत दो ऑपरेंड मानों के गणितीय उत्पाद के संकेत के समान नहीं हो सकता है।

फ्लोटिंग-प्वाइंट गुणन के परिणाम आईईईई 754 अंकगणित के नियमों द्वारा नियंत्रित होते हैं:

  • यदि या तो ऑपरेशन ना एनएएन है, तो परिणाम NaN
  • यदि नतीजा NaN न हो, तो परिणाम का संकेत सकारात्मक है अगर दोनों ऑपरेंड्स के पास एक ही चिह्न है, और नकारात्मक अगर ऑपरेंड के पास भिन्न लक्षण हैं
  • एक अनन्तता का गुणन शून्य परिणाम से NaN में होता है
  • एक परिमित मूल्य के आधार पर एक अनन्तता का गुणन एक हस्ताक्षरित अनंत में होता है। यह संकेत ऊपर वर्णित नियम द्वारा निर्धारित किया गया है।
  • शेष मामलों में, जहां न तो कोई अनन्तता और न ही एनएन शामिल है, सटीक गणितीय उत्पाद की गणना की जाती है। एक अस्थायी बिंदु मान सेट तब चुना जाता है:
    • यदि गुणन अभिव्यक्ति एफपी-सख्त (§15.4) है:
      • यदि गुणा अभिव्यक्ति का प्रकार float , तो फ़्लोट वैल्यू सेट को चुना जाना चाहिए।
      • यदि गुणा अभिव्यक्ति का प्रकार double , तो डबल मान सेट चुना जाना चाहिए।
    • अगर गुणा अभिव्यक्ति एफपी-सख्त नहीं है:
      • यदि गुणन अभिव्यक्ति का प्रकार float , तो या तो फ्लोट वैल्यू सेट या फ्लोट-एक्स्टोनेंट वैल्यू सेट को चुना जा सकता है, कार्यान्वयन की लहर पर।
      • यदि गुणा अभिव्यक्ति का प्रकार double , तो या तो कार्यान्वयन की लहर पर, डबल मान सेट या डबल-विस्तारित-एक्सपोनेंट वैल्यू सेट चुना जा सकता है।

इसके बाद, उत्पाद का प्रतिनिधित्व करने के लिए चुने हुए मूल्य सेट से एक मूल्य चुना जाना चाहिए।

यदि उत्पाद की भयावहता का प्रतिनिधित्व करने के लिए बहुत बड़ा है, तो हम कहते हैं कि ऑपरेशन ओवरफ्लो; परिणाम तो उपयुक्त चिन्ह का एक अनन्तता है

अन्यथा, आईईईई 754 गोल-टू-नजदीकी मोड का उपयोग करके चुना हुआ मान सेट में उत्पाद को निकटतम मान में गोल किया जाता है। जावा प्रोग्रामिंग भाषा को आईईईई 754 (§4.2.4) द्वारा परिभाषित के रूप में क्रमिक अंडरफ्लो के समर्थन की आवश्यकता है।

इस तथ्य के बावजूद कि अतिप्रवाह, अंडरफ्लो, या जानकारी की हानि हो सकती है, एक गुणक ऑपरेटर का मूल्यांकन कभी-कभी रन-टाइम अपवाद फेंकता नहीं है