दिलचस्प पोस्ट
PHP में फ़ाइल एक्सटेंशन कैसे प्राप्त करें? जावास्क्रिप्ट `अपरिभाषित` बनाम` शून्य 0` इनलाइन विधानसभा के माध्यम से स्मृति हेरफेर के आसपास ताले कोई उपयोगकर्ता एंड्रॉइड डिवाइस पर हेडसेट कैसे प्लग करता है, यह कैसे पता लगा सकता है? (ACTION_AUDIO_BECOMING_NOISY के विपरीत) कैसे xcode4 में आवेदन परीक्षण को लागू करने के लिए? ओपनजीएल 3.2 कोर प्रोफाइल के साथ ओएस एक्स पर जीएलयूटीयूटी पटरियों 3 link_to (: method =>: हटाएं) काम नहीं कर रहा है एक टैग पर विशेषता डाउनलोड करें जो IE में काम नहीं कर रहा है NSFetchedResultsController बनाम UILocalizedIndexedCollation विशेषता मूल्य PHP के माध्यम से XML को सॉर्ट करें कैंसर 2 एचटीसी सेवा के साथ कैशिंग परिणाम समाप्त करने के लिए "किसी भी प्रक्रिया" के लिए प्रतीक्षा करें फोर्स पॉइंट ("।") के रूप में जावा में दशमलव विभाजक वाई-फाई के बजाय एंड्रॉइड एप्लिकेशन में 3 जी कनेक्शन का उपयोग कैसे करें? जावा एक सरणी से डुप्लिकेट निकालें?

जावा पूर्णांक अंडरफ्लो और अतिप्रवाह को कैसे संभालता है और आप इसके लिए कैसे जांचेंगे?

कैसे जावा पूर्णांक underflows और overflows संभालता है?

उस पर अग्रणी, आप कैसे जाँच लेंगे कि यह हो रहा है?

Solutions Collecting From Web of "जावा पूर्णांक अंडरफ्लो और अतिप्रवाह को कैसे संभालता है और आप इसके लिए कैसे जांचेंगे?"

यदि यह अतिप्रवाह हो, तो यह न्यूनतम मूल्य पर वापस जाता है और वहां से जारी रहता है। अगर यह कम से कम होता है, तो यह अधिकतम मूल्य पर वापस जाता है और वहां से जारी रहता है।

आप पहले से यह जांच सकते हैं:

 public static boolean willAdditionOverflow(int left, int right) { if (right < 0 && right != Integer.MIN_VALUE) { return willSubtractionOverflow(left, -right); } else { return (~(left ^ right) & (left ^ (left + right))) < 0; } } public static boolean willSubtractionOverflow(int left, int right) { if (right < 0) { return willAdditionOverflow(left, -right); } else { return ((left ^ right) & (left ^ (left - right))) < 0; } } 

(आप long के लिए एक ही चेक करने के लिए long long से int विकल्प कर सकते हैं)

यदि आपको लगता है कि यह अक्सर से अधिक हो सकता है, तो java.math.BigInteger या ऑब्जेक्ट का उपयोग करने पर विचार करें जो बड़े मूल्यों को संग्रहीत कर सकता है, जैसे long या शायद java.math.BigInteger पिछले एक अतिप्रवाह नहीं है, व्यावहारिक रूप से, उपलब्ध JVM स्मृति सीमा है


यदि आप पहले से ही Java8 पर होते हैं, तो आप नए Math#addExact() और Math#subtractExact() विधियों का उपयोग कर सकते हैं जो ओवरफ्लो पर ArithmeticException Math#addExact() फेंक देंगे।

 public static boolean willAdditionOverflow(int left, int right) { try { Math.addExact(left, right); return false; } catch (ArithmeticException e) { return true; } } public static boolean willSubtractionOverflow(int left, int right) { try { Math.subtractExact(left, right); return false; } catch (ArithmeticException e) { return true; } } 

स्रोत कोड यहां और यहां क्रमशः पाया जा सकता है।

बेशक, आप उन्हें boolean उपयोगिता विधि में छिपाने के बजाय उन्हें तुरंत उपयोग कर सकते हैं

ठीक है, जहां तक ​​आदिम पूर्णांक प्रकार जाते हैं, जावा ओवर / अंडरफ़्लो को संभाल नहीं करता है (फ्लोट के लिए और डबल वर्तन अलग है, यह आईआईई -754 के जनादेश के रूप में अन्तर्निहित होगा।

दो इंट जोड़ते समय, जब कोई अतिप्रवाह होता है तो आपको कोई संकेत नहीं मिलेगा। ओवरफ्लो की जांच करने के लिए एक सरल तरीका यह है कि वास्तव में ऑपरेशन करने के लिए अगले बड़े प्रकार का उपयोग करें और जांच करें कि परिणाम अभी भी स्रोत प्रकार के लिए सीमा में है:

 public int addWithOverflowCheck(int a, int b) { // the cast of a is required, to make the + work with long precision, // if we just added (a + b) the addition would use int precision and // the result would be cast to long afterwards! long result = ((long) a) + b; if (result > Integer.MAX_VALUE) { throw new RuntimeException("Overflow occured"); } else if (result < Integer.MIN_VALUE) { throw new RuntimeException("Underflow occured"); } // at this point we can safely cast back to int, we checked before // that the value will be withing int's limits return (int) result; } 

फेंक क्लाजों के स्थान पर आप क्या करेंगे, आपके एप्लिकेशन की आवश्यकताओं पर निर्भर करता है (न्यूनतम, अधिकतम फ्लश करें या जो भी लॉग करें) यदि आप लंबे आपरेशनों पर अतिप्रवाह का पता लगाना चाहते हैं, तो आप प्राथमिकताओं के साथ भाग्य से बाहर हैं, बजाय बिगइंटेगर का उपयोग करें।


संपादित करें (2014-05-21): चूंकि इस प्रश्न को बहुत बार संदर्भित किया जाता है और मुझे वही समस्या को हल करना पड़ता है, वही पद्धति से अतिप्रवाह स्थिति का मूल्यांकन करना काफी आसान होता है, एक सीपीयू इसके वी फ्लैग की गणना करेगा।

इसकी मूल रूप से एक बूलीयन अभिव्यक्ति जिसमें परिणाम दोनों के रूप में के रूप में अच्छी तरह से दोनों operands के हस्ताक्षर शामिल है:

 /** * Add two int's with overflow detection (r = s + d) */ public static int add(final int s, final int d) throws ArithmeticException { int r = s + d; if (((s & d & ~r) | (~s & ~d & r)) < 0) throw new ArithmeticException("int overflow add(" + s + ", " + d + ")"); return r; } 

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

छोटे प्रकार के लिए, इंट के लिए अंतर्निहित रूपांतरण के कारण (विवरण के लिए bitwise कार्रवाई के लिए जेएलएस देखें), <0 जाँचने के बजाय, चेक को स्पष्ट रूप से हस्ताक्षर बिट (0x8000 के लिए लघु परिपथों, बाइट ऑपेरेन्ड के लिए 0x80, कोस्ट को समायोजित करना) की आवश्यकता है और पैरामीटर घोषणा appropiately):

 /** * Subtract two short's with overflow detection (r = d - s) */ public static short sub(final short d, final short s) throws ArithmeticException { int r = d - s; if ((((~s & d & ~r) | (s & ~d & r)) & 0x8000) != 0) throw new ArithmeticException("short overflow sub(" + s + ", " + d + ")"); return (short) r; } 

(ध्यान दें कि उपरोक्त उदाहरण उप- प्रवाह अतिप्रवाह का पता लगाने के लिए अभिव्यक्ति की आवश्यकता का उपयोग करता है)


तो कैसे / क्यों ये बूलियन एक्सपेंस काम करते हैं? सबसे पहले, कुछ तार्किक सोच से पता चलता है कि यदि दोनों तर्कों के संकेत समान हैं, तो एक अतिप्रवाह केवल तभी उत्पन्न हो सकता है। क्योंकि, अगर एक तर्क ऋणात्मक और एक सकारात्मक है, तो परिणाम (जोड़) के करीब शून्य के करीब होना चाहिए, या चरम स्थिति में एक तर्क शून्य है, दूसरे तर्क के समान है। चूंकि तर्क स्वयं एक अतिप्रवाह स्थिति नहीं बना सकते हैं, इसलिए उनका योग एक अतिप्रवाह भी नहीं बना सकता है।

तो क्या होता है अगर दोनों तर्कों का एक ही चिन्ह होता है? इस मामले पर एक नज़र रखना, दोनों सकारात्मक हैं: दो तर्क जो कि MAX_VALUE प्रकार से बड़ा राशि बनाते हैं, हमेशा एक नकारात्मक मान अर्जित करेगा, इसलिए एक अतिप्रवाह तब होता है जब arg1 + arg2> MAX_VALUE अब अधिकतम मान जिसका परिणाम हो सकता है MAX_VALUE + MAX_VALUE होगा (चरम स्थिति दोनों तर्क MAX_VALUE हैं)। एक बाइट (उदाहरण) के लिए 127 + 127 = 254 का मतलब होगा। दो मानों को जोड़ते हुए सभी मानों के बिट अभ्यावेदन को देखते हुए, एक पाता है कि जो अतिप्रवाह (128 से 254) सभी में बिट 7 सेट हैं जो सभी अतिप्रवाह नहीं करते (0 से 127) में बिट 7 (सर्वोच्च, साइन) साफ़ है वास्तव में यह है कि अभिव्यक्ति की जांच का पहला (सही) भाग क्या है:

 if (((s & d & ~r) | (~s & ~d & r)) < 0) 

(~ एस और ~ डी एंड आर) सच हो गया है, केवल अगर , दोनों operands (एस, डी) सकारात्मक हैं और परिणाम (आर) नकारात्मक है (अभिव्यक्ति सभी 32 बिट पर काम करता है, लेकिन केवल बिट में हम रुचि रखते हैं सबसे ऊपरी (साइन) बिट है, जो <0 के द्वारा जांच की जाती है।

अब यदि दोनों तर्क नकारात्मक हैं, तो उनकी राशि किसी भी तर्क के मुकाबले शून्य के करीब नहीं हो सकती है, इस राशि को शून्य अनंत के करीब होना चाहिए। सबसे चरम मूल्य है जो हम उत्पादन कर सकते हैं MIN_VALUE + MIN_VALUE है, जो (फिर बाइट उदाहरण के लिए) दर्शाता है कि किसी भी श्रेणी के मान (-1 से -128) के लिए साइन बिट सेट होता है, जबकि किसी भी संभावित अतिप्रवाह मूल्य (-12 9 से -256 ) में हस्ताक्षर बिट साफ़ है। तो परिणाम का संकेत फिर से अतिप्रवाह स्थिति का पता चलता है। यह है कि बाएं आधे (एस एंड डी और ~ आर) मामले के लिए जांच करता है, जहां दोनों तर्क (एस, डी) नकारात्मक हैं और परिणाम सकारात्मक है। तर्क सकारात्मक स्थिति के बराबर है; सभी नकारात्मक पैटर्न जो दो नकारात्मक मूल्यों को जोड़ने से हो सकते हैं, उनके पास साइन बिट साफ़ हो जाएगा यदि और केवल एक अंडरफ़्लो हुआ हो।

जावा या तो पूर्णांक या लंबी आदिम प्रकारों के लिए पूर्णांक ओवरफ़्लो के साथ कुछ भी नहीं करता है और सकारात्मक और नकारात्मक पूर्णांक के साथ अतिप्रवाह को अनदेखा करता है

यह जवाब पहले पूर्णांक के अतिप्रवाह के बारे में बताता है, अभिव्यक्ति मूल्यांकन में मध्यवर्ती मूल्यों के साथ भी, यह कैसे हो सकता है, का एक उदाहरण देता है, और फिर संसाधनों के लिंक देता है जो पूर्णांक ओवरफ्लो को रोकने और पता लगाने के लिए विस्तृत तकनीकों को प्रदान करता है।

पूर्णांक अंकगणितीय और अभिव्यक्ति अप्रत्याशित या अनग्याप्त अतिप्रवाह में reslulting एक आम प्रोग्रामिंग त्रुटि है। अप्रत्याशित या अनअकेक्ट किए गए पूर्णांक ओवरफ़्लो भी एक प्रसिद्ध ज्ञात सुरक्षा समस्या है, विशेष रूप से यह सरणी, स्टैक और सूची ऑब्जेक्ट को प्रभावित करता है।

ओवरफ्लो या तो एक सकारात्मक या नकारात्मक दिशा में हो सकता है जहां सकारात्मक या नकारात्मक मूल्य प्रश्न में प्राचीन प्रकार के अधिकतम या न्यूनतम मूल्यों से परे होगा। अभिव्यक्ति या आपरेशन मूल्यांकन के दौरान एक मध्यवर्ती मूल्य में अतिप्रवाह हो सकता है और अभिव्यक्ति या संचालन के परिणाम को प्रभावित कर सकता है जहां अंतिम मूल्य सीमा के भीतर होने की उम्मीद की जाएगी।

कभी-कभी नकारात्मक अतिप्रवाह गलत तरीके से अंडरफ्लो कहा जाता है। अंडरफ्लो क्या होता है जब कोई मान शून्य से अधिक हो सकता है, क्योंकि प्रतिनिधित्व की अनुमति होती है अंडरफ्लो पूर्णांक अंकगणितीय में होता है और उम्मीद की जाती है। इंटीजर अंडरफ्लो तब होता है जब एक पूर्णांक मूल्यांकन 1 और 0 या 0 और 1 के बीच होगा। एक भिन्न परिणाम 0 से कम हो जाएगा। यह सामान्य है और पूर्णांक अंकगणितीय के साथ अपेक्षा की जाती है और एक त्रुटि नहीं माना जाता है। हालांकि, यह एक अपवाद फेंकने वाला कोड बना सकता है। एक उदाहरण एक "अंकगणितीय अपवाद: / शून्य द्वारा" अपवाद है यदि पूर्णांक कम प्रवाह के परिणाम अभिव्यक्ति में विभाजक के रूप में उपयोग किया जाता है।

निम्नलिखित कोड पर विचार करें:

 int bigValue = Integer.MAX_VALUE; int x = bigValue * 2 / 5; int y = bigValue / x; 

जिसके परिणामस्वरूप एक्स को असाइन किया जा सकता है 0 और बड़ा वेल्यू / एक्स के बाद के मूल्यांकन में एक अपवाद फेंकता है, "एरिथमेटिक एक्सप्शन: / बाय शून्य" (अर्थात शून्य से विभाजित)

एक्स के लिए अपेक्षित परिणाम 858,993,458 होगा, जो 2,147,483,647 के अधिकतम इंट मान से कम है। हालांकि, पूर्णांक के मूल्यांकन से मध्यवर्ती परिणाम। MAX_Value * 2, 4,294,967,294 होगा, जो अधिकतम इंट मान से अधिक है और 2 एस पूरक पूर्णांक के अनुसार 2 है। बाद के मूल्यांकन -2 / 5 का मूल्यांकन करता है जो कि एक्स को सौंपा जाता है।

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

 int bigValue = Integer.MAX_VALUE; int x = bigValue / 5 * 2; int y = bigValue / x; 

परिणाम में एक्स को 858,993,458 सौंपा गया है और y को सौंपा गया 2, जो उम्मीद की जाती है।

BigValue / 5 का मध्यवर्ती परिणाम 429,496,72 9 है जो किसी इंट के लिए अधिकतम मूल्य से अधिक नहीं है। 42 9, 49672 9 * 2 के बाद के मूल्यांकन में एक इंट के लिए अधिकतम मूल्य से अधिक नहीं है और अपेक्षित परिणाम x को सौंपा जाता है। वाई के लिए मूल्यांकन तो शून्य से विभाजित नहीं होता है अपेक्षित के रूप में एक्स और वाई के लिए मूल्यांकन

जावा पूर्णांक मूल्यों के रूप में संग्रहित है और 2s के साथ अनुरूप व्यवहार पूर्णांक अभ्यावेदन पर हस्ताक्षर किए हैं। जब परिणामस्वरूप मूल्य अधिकतम या न्यूनतम पूर्णांक मानों से बड़ा या छोटा होता है, तो 2 के पूरक पूर्णांक मान परिणाम इसके बजाय। परिस्थितियों में स्पष्ट रूप से 2s पूरक व्यवहार का उपयोग करने के लिए डिज़ाइन नहीं किया गया है, जो सबसे सामान्य पूर्णांक अंकगणित स्थितियों में है, परिणामस्वरूप 2s पूरक मूल्य के कारण ऊपर के उदाहरण में दिखाया गया प्रोग्रामिंग तर्क या गणना त्रुटि का कारण होगा। एक उत्कृष्ट विकिपीडिया आलेख का वर्णन है 2s द्विआधारी पूर्णांक यहां बधाई देता है: दो पूरक – विकिपीडिया

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

प्री-कंडिशन टेस्टिंग में अंकगणित संचालन या अभिव्यक्ति में जाने वाले मूल्यों की जांच करना शामिल होता है ताकि यह सुनिश्चित हो सके कि उन मानों के साथ एक अतिप्रवाह नहीं होगा। प्रोग्रामिंग और डिजाइन के लिए परीक्षण बनाने की आवश्यकता होगी जो सुनिश्चित करता है कि इनपुट मान ओवरफ़्लो का कारण नहीं बनेंगे और फिर यह निर्धारित करेंगे कि क्या इनपुट मान होने चाहिए जिससे ओवरफ़्लो का कारण होगा।

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

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

कार्नेगी मेलॉन सॉफ्टवेयर इंजीनियरिंग संस्थान के सीईआरटी कार्यक्रम और ओरेकल ने सुरक्षित जावा प्रोग्रामिंग के लिए मानकों का एक सेट बनाया है। मानकों में शामिल हैं पूर्णांक अतिप्रवाह को रोकने और पता लगाने के लिए तकनीकें। मानक को स्वतंत्र रूप से सुलभ ऑनलाइन संसाधन के रूप में प्रकाशित किया गया है: जावा के लिए सीईआरटी ओरेकल सिक्योर कोडिंग स्टैंडर्ड

मानक के अनुभाग जो पूर्णांक ओवरफ्लो को रोकने या पहचानने के लिए कोडिंग तकनीकों का व्यावहारिक उदाहरण बताता है और इसमें है: NUM00-J पूर्णांक अतिप्रवाह का पता लगा या रोकें

जावा के लिए सीईआरटी ओरेकल सिक्योर कोडिंग स्टैंडर्ड का बुक फॉर्म और पीडीएफ फॉर्म भी उपलब्ध हैं।

डिफ़ॉल्ट रूप से, जावा के int और लंबा गणित चुपचाप ओवरफ्लो और अंडरफ्लो के आसपास लपेटते हैं। (अन्य पूर्णांक प्रकारों पर पूर्णांक परिचालनों को पहली बार ऑपरेटर्स को इंट्रेट या लम्बे, प्रति जेएलएस 4.2.2 के लिए प्रचारित किया जाता है।)

Java 8 के रूप में, java.lang.Math addExact , subtractExact , multiplyExact , incrementExact , decrementExact और negateExact static विधियों दोनों int और लंबे तर्क के लिए प्रदान करता है जो कि नामित ऑपरेशन करते हैं, ओवरफ्लो पर negateExact फेंकते हैं। (कोई विभाजित नहीं है ईएक्सट मेथड – आपको एक विशेष केस ( MIN_VALUE / -1 ) खुद को जांचना होगा।)

जावा 8 के रूप में, java.lang.Math भी एक int के लिए लंबे समय तक डालने के लिए toIntExact को प्रदान करता है, toIntExact को फेंकने के लिए अगर लंबे समय का मान किसी int में फिट नहीं होता है यह उपयोगी हो सकता है जैसे कि अनचेक किए गए लंबे गणित का उपयोग करके toIntExact की राशि की गणना करना, फिर अंत में toIntExact को डालने के लिए उपयोग करने के लिए (लेकिन सावधानी से अपनी राशि का प्रवाह नहीं होने दें)।

यदि आप अभी भी जावा के पुराने संस्करण का उपयोग कर रहे हैं, तो Google गुवा ने चेक किए गए अतिरिक्त, घटाव, गुणा और एक्सपोनेंटिएशन (अतिप्रवाह पर फेंकने) के लिए इंटमैथ और लोंगमैथ स्थिर तरीके प्रदान किए हैं। ये कक्षाएं फैक्टोरियल और द्विपद गुणांक की गणना करने के तरीकों को भी प्रदान करती हैं जो अतिप्रवाह पर MAX_VALUE लौटते हैं (जो जांचने के लिए कम सुविधाजनक है)। गुवा की आदिम उपयोगिता कक्षाएं, SignedBytes , SignedBytes , Shorts और checkedCast , बड़े प्रकारों को सीमित करने के लिए checkedCast विधियां प्रदान करते हैं ( checkedCast फेंकना / ओवरफ्लो पर नहीं , checkedCast ), साथ ही साथ saturatingCast MIN_VALUE विधियों जो अतिप्रवाह पर MIN_VALUE या MAX_VALUE लौटाते हैं।

इस समस्या में खुद को थोड़े चलते हुए, यहां मेरा समाधान है (गुणा और जोड़ दोनों के लिए):

 static boolean wouldOverflowOccurwhenMultiplying(int a, int b) { // If either a or b are Integer.MIN_VALUE, then multiplying by anything other than 0 or 1 will result in overflow if (a == 0 || b == 0) { return false; } else if (a > 0 && b > 0) { // both positive, non zero return a > Integer.MAX_VALUE / b; } else if (b < 0 && a < 0) { // both negative, non zero return a < Integer.MAX_VALUE / b; } else { // exactly one of a,b is negative and one is positive, neither are zero if (b > 0) { // this last if statements protects against Integer.MIN_VALUE / -1, which in itself causes overflow. return a < Integer.MIN_VALUE / b; } else { // a > 0 return b < Integer.MIN_VALUE / a; } } } boolean wouldOverflowOccurWhenAdding(int a, int b) { if (a > 0 && b > 0) { return a > Integer.MAX_VALUE - b; } else if (a < 0 && b < 0) { return a < Integer.MIN_VALUE - b; } return false; } 

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

ऐसे पुस्तकालय हैं जो सुरक्षित अंकगणितीय संचालन प्रदान करते हैं, जो पूर्णांक ओवरफ्लो / अंडरफ्लो को चेक करते हैं। उदाहरण के लिए, पेरू के इंटमैथ। चेकेडऐड (इंट ए, इंट बी) a और b की राशि देता है, बशर्ते वह अतिप्रवाह नहीं करता है, और एर्थमेटिक एक्सपैशन को फेंकता है यदि a + b ओवरफ्लो हस्ताक्षरित int अरथमेटिक में है।

मुझे लगता है कि आपको इस तरह से कुछ का उपयोग करना चाहिए और इसे अपकास्टिंग कहा जाता है:

 public int multiplyBy2(int x) throws ArithmeticException { long result = 2 * (long) x; if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE){ throw new ArithmeticException("Integer overflow"); } return (int) result; } 

आप यहां आगे पढ़ सकते हैं: पूर्णांक ओवरफ़्लो का पता लगा या रोकें

यह काफी विश्वसनीय स्रोत है

यह कुछ भी नहीं करता – नीचे / अतिप्रवाह बस होता है

एक "-1" जो एक गणना का परिणाम है जो अतिप्रवाह है, "-1" से कोई भिन्न नहीं है, जिसके परिणामस्वरूप किसी भी अन्य जानकारी के परिणामस्वरूप तो आप कुछ स्थिति के माध्यम से नहीं बता सकते हैं या यह सिर्फ एक मूल्य का निरीक्षण कर रहा है चाहे वह अतिप्रवाह हो।

लेकिन आप अपने कम्प्यूटेशंस के बारे में अधिक हो सकते हैं ताकि अतिप्रवाह से बचने के लिए, अगर यह मामला हो, या कम से कम यह कब हो जाएगा कि यह कब होगा। आपकी स्थिति क्या है?

यह चारों ओर लपेटता है

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

सार्वजनिक कक्षा परीक्षण {

 public static void main(String[] args) { int i = Integer.MAX_VALUE; int j = Integer.MIN_VALUE; System.out.println(i+1); System.out.println(j-1); } 

}

प्रिंट

-+२१४७४८३६४८

2147483647

 static final int safeAdd(int left, int right) throws ArithmeticException { if (right > 0 ? left > Integer.MAX_VALUE - right : left < Integer.MIN_VALUE - right) { throw new ArithmeticException("Integer overflow"); } return left + right; } static final int safeSubtract(int left, int right) throws ArithmeticException { if (right > 0 ? left < Integer.MIN_VALUE + right : left > Integer.MAX_VALUE + right) { throw new ArithmeticException("Integer overflow"); } return left - right; } static final int safeMultiply(int left, int right) throws ArithmeticException { if (right > 0 ? left > Integer.MAX_VALUE/right || left < Integer.MIN_VALUE/right : (right < -1 ? left > Integer.MIN_VALUE/right || left < Integer.MAX_VALUE/right : right == -1 && left == Integer.MIN_VALUE) ) { throw new ArithmeticException("Integer overflow"); } return left * right; } static final int safeDivide(int left, int right) throws ArithmeticException { if ((left == Integer.MIN_VALUE) && (right == -1)) { throw new ArithmeticException("Integer overflow"); } return left / right; } static final int safeNegate(int a) throws ArithmeticException { if (a == Integer.MIN_VALUE) { throw new ArithmeticException("Integer overflow"); } return -a; } static final int safeAbs(int a) throws ArithmeticException { if (a == Integer.MIN_VALUE) { throw new ArithmeticException("Integer overflow"); } return Math.abs(a); } 

एक मामला है, जो ऊपर वर्णित नहीं है:

 int res = 1; while (res != 0) { res *= 2; } System.out.println(res); 

उत्पादन करेंगे:

 0 

इस मामले पर यहां चर्चा की गई: पूर्णांक अतिप्रवाह शून्य उत्पन्न करता है।

मुझे लगता है कि यह ठीक होना चाहिए।

 static boolean addWillOverFlow(int a, int b) { return (Integer.signum(a) == Integer.signum(b)) && (Integer.signum(a) != Integer.signum(a+b)); }