आदिम प्रकार | स्मृति में आकार | मूल्य पहुंच |
---|---|---|
बाइट | 8 बिट | -128 से 127 |
छोटा | 16 बिट | -32768 से 32767 |
चार | 16 बिट | 0 से 65536 |
int यहाँ | 32 बिट्स | -2147483648 से 2147483647 |
लंबा | 64 बिट | -9223372036854775808 से 9223372036854775807 |
तैरना | 32 बिट्स | (2 की घात -149) से ((2 की घात -23) * 2 की घात 127) |
दोहरा | 64 बिट | (-2 की घात 63) से ((2 की घात 63) - 1) |
बूलियन | 8 (जब सरणियों में उपयोग किया जाता है), 32 (जब सरणियों में उपयोग नहीं किया जाता है) | सही या गलत |
public class Main {
public static void main(String[] args) {
BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
System.out.println(integer);
BigDecimal decimal = new BigDecimal("123.444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444");
System.out.println(decimal);
}
}
कन्स्ट्रक्टर को स्ट्रिंग पास करना केवल एक संभावित विकल्प है। यहां हम स्ट्रिंग्स का उपयोग करते हैं, क्योंकि हमारी संख्याएँ लंबे और दोहरे के लिए अधिकतम मानों से अधिक हैं , और हमें संकलक को समझाने के लिए किसी तरीके की आवश्यकता है कि हम कौन सी संख्या बनाना चाहते हैं :) 11111111111111111111111111111111111111111111111111111111111111111 कन्स्ट्रक्टर के लिए काम नहीं करेगा: जावा पारित संख्या को आदिम डेटा प्रकारों में से एक में क्रैम करने का प्रयास करेगा, लेकिन यह उनमें से किसी में फिट नहीं होगा। इसलिए वांछित संख्या पास करने के लिए एक स्ट्रिंग का उपयोग करना एक अच्छा विकल्प है। दोनों वर्ग पारित स्ट्रिंग्स से स्वचालित रूप से संख्यात्मक मान निकाल सकते हैं। बड़ी संख्या वाली कक्षाओं के साथ काम करते समय याद रखने वाली एक और महत्वपूर्ण बात यह है कि उनकी वस्तुएं अपरिवर्तनीय ( अपरिवर्तनीय ) हैं। आप पहले से ही अपरिवर्तनीयता से परिचित हैं, स्ट्रिंग वर्ग और आदिम प्रकार (पूर्णांक, लंबा, आदि) के लिए आवरण वर्ग के साथ अपने अनुभव के लिए धन्यवाद ।
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
System.out.println(integer);
integer.add(BigInteger.valueOf(33333333));
System.out.println(integer);
}
}
कंसोल आउटपुट:
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
जैसा कि आप उम्मीद करेंगे, हमारी संख्या नहीं बदली है। अतिरिक्त ऑपरेशन करने के लिए, ऑपरेशन के परिणाम प्राप्त करने के लिए आपको एक नई वस्तु बनानी होगी।
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111");
System.out.println(integer);
BigInteger result = integer.add(BigInteger.valueOf(33333333));
System.out.println(result);
}
}
कंसोल आउटपुट:
11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111144444444
देखें, अब सब कुछ वैसा ही काम करता है जैसा उसे होना चाहिए :) वैसे, क्या आपने देखा कि अतिरिक्त ऑपरेशन कितना असामान्य दिखता है?
BigInteger result = integer.add(BigInteger.valueOf(33333333));
यह एक और महत्वपूर्ण बात है। बड़ी संख्या वाली कक्षाएं + - * / ऑपरेटरों का उपयोग नहीं करती हैं। इसके बजाय, वे तरीकों का एक सेट प्रदान करते हैं। आइए मुख्य लोगों से परिचित हों (हमेशा की तरह, आप Oracle प्रलेखन में विधियों की पूरी सूची पा सकते हैं: यहाँ और यहाँ )।
-
अंकगणितीय संचालन के तरीके: जोड़ें () , घटाएं () , गुणा करें () , विभाजित करें () । इन विधियों का उपयोग क्रमशः जोड़, घटाव, गुणा और भाग करने के लिए किया जाता है।
-
DoubleValue() , intValue() , floatValue() , longValue() , आदि का उपयोग बड़ी संख्या को जावा के आदिम प्रकारों में से एक में बदलने के लिए किया जाता है। इन तरीकों का इस्तेमाल करते समय सावधान रहें। बिट आकार में अंतर के बारे में मत भूलना!
import java.math.BigInteger; public class Main { public static void main(String[] args) { BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"); long result = integer.longValue(); System.out.println(result); } }
कंसोल आउटपुट:
8198552921648689607
-
min() और max() आपको दो बड़ी संख्याओं का न्यूनतम और अधिकतम मान ज्ञात करने देता है।
ध्यान दें कि ये विधियां स्थिर नहीं हैं!import java.math.BigInteger; public class Main { public static void main(String[] args) { BigInteger integer = new BigInteger("11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"); BigInteger integer2 = new BigInteger("222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"); System.out.println(integer.max(integer2)); } }
कंसोल आउटपुट:
222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
बिगडेसिमल राउंडिंग व्यवहार
इस विषय का अपना एक अलग खंड है, क्योंकि बड़ी संख्याओं का पूर्णांक बनाना और पूर्णांकन व्यवहार को कॉन्फ़िगर करना इतना सरल नहीं है। आप BigDecimal के लिए दशमलव स्थानों की संख्या निर्धारित करने के लिए setScale() विधि का उपयोग कर सकते हैं । उदाहरण के लिए, मान लीजिए कि हम संख्या 111.5555555555 में दशमलव बिंदु के बाद तीन अंक चाहते हैं। हालाँकि, हम संख्या 3 को सेटस्केल () विधि के तर्क के रूप में पास करके जो चाहते हैं उसे प्राप्त नहीं कर सकते हैं। जैसा ऊपर बताया गया है, BigDecimalकम्प्यूटेशनल सटीकता पर सख्त आवश्यकताओं के साथ संख्याओं का प्रतिनिधित्व करने के लिए है। अपने वर्तमान स्वरूप में, हमारी संख्या में दशमलव बिंदु के बाद 10 अंक होते हैं। हम उनमें से 7 को छोड़ना चाहते हैं और केवल 3 को रखना चाहते हैं। तदनुसार, संख्या 3 के अतिरिक्त, हमें राउंडिंग मोड पास करना होगा। BigDecimal में कुल 8 राउंडिंग मोड हैं। यह बहुत ज्यादा है! लेकिन अगर आपको वास्तव में अपनी गणनाओं की सटीकता को ठीक करने की आवश्यकता है, तो आपके पास वह सब कुछ होगा जिसकी आपको आवश्यकता है। तो, यहाँ BigDecimal द्वारा पेश किए गए 8 राउंडिंग मोड हैं :-
ROUND_CEILING — राउंड अप
111.5555555555 -> setScale(3, ROUND_CEILING) -> 111.556
-
ROUND_DOWN — शून्य की ओर जाता है
111.5555555555 -> setScale(3, ROUND_DOWN) -> 111.555
-
ROUND_FLOOR — राउंड डाउन
111.5555555555 -> setScale(3, ROUND_FLOOR) -> 111.555
-
ROUND_HALF_UP - दशमलव बिंदु के बाद की संख्या> = 0.5 होने पर राउंड अप करें
0.55 -> setScale(1, ROUND_HALF_UP) -> 0.6 0.54 -> setScale(1, ROUND_HALF_UP) -> 0.5
-
ROUND_HALF_DOWN - दशमलव बिंदु के बाद की संख्या> 0.5 होने पर राउंड अप करें
0.55 -> setScale(1, ROUND_HALF_DOWN) -> 0.5 0.56 -> setScale(1, ROUND_HALF_DOWN) -> 0.6
-
ROUND_HALF_EVEN — पूर्णांकन दशमलव बिंदु के बाईं ओर की संख्या पर निर्भर करता है। यदि बाईं ओर की संख्या सम है, तो गोलाई कम की जाएगी। यदि दशमलव बिंदु के बाईं ओर की संख्या विषम है, तो पूर्णांकन ऊपर किया जाएगा।
2.5 -> setScale(0, ROUND_HALF_EVEN) -> 2
दशमलव स्थान के बाईं ओर की संख्या 2 (सम) है। संख्या को गोल कर दिया गया है। हम 0 दशमलव स्थान चाहते हैं, इसलिए परिणाम 2 है।
3.5 -> setScale(0, ROUND_HALF_EVEN) -> 4
दशमलव बिंदु के बाईं ओर की संख्या 3 (विषम) है। संख्या गोल है। हम 0 दशमलव स्थान चाहते हैं, इसलिए परिणाम 4 है।
-
ROUND_UNNECCESSARY - इस मोड का उपयोग तब किया जाता है जब आपको राउंडिंग मोड को किसी विधि में पास करना होता है, लेकिन संख्या को गोल करने की आवश्यकता नहीं होती है। यदि आप ROUND_UNNECCESSARY मोड सेट के साथ किसी संख्या को गोल करने का प्रयास करते हैं, तो एक अंकगणितीय अपवाद फेंक दिया जाता है।
3.51 -> setScale(1, ROUND_UNNECCESSARY) -> ArithmeticException
-
ROUND_UP - शून्य से राउंड दूर।
111.5551 -> setScale(3, ROUND_UP) -> 111.556
बड़ी संख्याओं की तुलना करना
यह भी महत्वपूर्ण है। आपको याद होगा कि हम जावा में वस्तुओं की तुलना करने के लिए बराबर () विधि का उपयोग करते हैं। कार्यान्वयन या तो भाषा द्वारा ही प्रदान किया जाता है (मानक जावा कक्षाओं के लिए) या प्रोग्रामर द्वारा ओवरराइड किया जाता है। लेकिन BigDecimal ऑब्जेक्ट्स के मामले में , तुलना के लिए बराबर () विधि का उपयोग करने की अनुशंसा नहीं की जाती है। ऐसा इसलिए है क्योंकि BigDecimal.equals() विधि तभी सही होती है जब 2 संख्याओं का मान और पैमाना समान हो: आइए Double और BigDecimal वर्गों के लिए equals() पद्धति के व्यवहार की तुलना करें:
import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
Double a = 1.5;
Double b = 1.50;
System.out.println(a.equals(b));
BigDecimal x = new BigDecimal("1.5");
BigDecimal y = new BigDecimal("1.50");
System.out.println(x.equals(y));
}
}
कंसोल आउटपुट:
true
false
जैसा कि आप देख सकते हैं, BigDecimal के लिए , 1.5 और 1.50 की संख्या असमान निकली! यह BigDecimal वर्ग में बराबर () पद्धति के कार्यान्वयन की विशिष्टता के कारण था । दो BigDecimal ऑब्जेक्ट्स की अधिक सटीक तुलना के लिए , ComparTo() विधि का उपयोग करना बेहतर होता है :
import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
BigDecimal x = new BigDecimal("1.5");
BigDecimal y = new BigDecimal("1.50");
System.out.println(x.compareTo(y));
}
}
कंसोल आउटपुट:
0
तुलना करने के लिए () विधि 0 लौटाती है, जिसका अर्थ है कि 1.5 और 1.50 बराबर हैं। और यह वह परिणाम है जिसकी हमें उम्मीद थी! :) यह आज के हमारे पाठ का समापन करता है। अब कार्यों पर वापस जाने का समय आ गया है! :)
GO TO FULL VERSION