आदिम प्रकार | मेमरी मध्ये आकार | मूल्य श्रेणी |
---|---|---|
बाइट | 8 बिट | -128 ते 127 |
लहान | 16 बिट | -३२७६८ ते ३२७६७ |
चार | 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);
}
}
कन्स्ट्रक्टरला स्ट्रिंग पास करणे हा फक्त एक संभाव्य पर्याय आहे. येथे आपण स्ट्रिंग्स वापरतो, कारण आपली संख्या लांब आणि दुप्पट साठी जास्तीत जास्त मूल्यांपेक्षा जास्त आहे , आणि आपल्याला कोणती संख्या तयार करायची आहे हे कंपाइलरला समजावून सांगण्यासाठी आपल्याला काही मार्ग आवश्यक आहेत :) फक्त संख्या पास करणे 1111111111111111111111111111111111111111111111111111111111111111111111111111 कन्स्ट्रक्टरसाठी कार्य करणार नाही: Java पास केलेल्या नंबरला एका आदिम डेटा प्रकारात क्रॅम करण्याचा प्रयत्न करेल, परंतु ते त्यापैकी कोणत्याहीमध्ये बसणार नाही. म्हणूनच इच्छित संख्या पास करण्यासाठी स्ट्रिंग वापरणे हा एक चांगला पर्याय आहे. दोन्ही वर्ग आपोआप पास केलेल्या स्ट्रिंगमधून संख्यात्मक मूल्ये काढू शकतात. मोठ्या-संख्येच्या वर्गांसह काम करताना लक्षात ठेवण्याचा आणखी एक महत्त्वाचा मुद्दा म्हणजे त्यांच्या वस्तू अपरिवर्तनीय ( अपरिवर्तनीय ) आहेत. स्ट्रिंग क्लास आणि आदिम प्रकारांसाठी (पूर्णांक, लांब, इ.) रॅपर क्लासेसच्या अनुभवामुळे तुम्ही अचलतेशी आधीच परिचित आहात .
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));
हा आणखी एक महत्त्वाचा मुद्दा आहे. मोठ्या-संख्येचे वर्ग + - * / ऑपरेटर वापरत नाहीत. त्याऐवजी, ते पद्धतींचा संच प्रदान करतात. चला मुख्य गोष्टींशी परिचित होऊ या (नेहमीप्रमाणे, तुम्हाला ओरॅकल दस्तऐवजीकरणातील पद्धतींची संपूर्ण यादी मिळेल: येथे आणि येथे ).
-
अंकगणित ऑपरेशन्सच्या पद्धती: add() , वजा () , गुणाकार () , divide() . या पद्धतींचा वापर अनुक्रमे बेरीज, वजाबाकी, गुणाकार आणि भागाकार करण्यासाठी केला जातो.
-
doubleValue() , intValue() , floatValue() , longValue() , इ. मोठ्या संख्येला Java च्या आदिम प्रकारात रूपांतरित करण्यासाठी वापरले जातात. या पद्धती वापरताना काळजी घ्या. बिट आकारातील फरकांबद्दल विसरू नका!
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 rounding वर्तन
या विषयाचा स्वतःचा स्वतंत्र विभाग आहे, कारण मोठ्या संख्येचे पूर्णीकरण करणे आणि गोलाकार वर्तन कॉन्फिगर करणे इतके सोपे नाही. BigDecimal साठी दशांश स्थानांची संख्या सेट करण्यासाठी तुम्ही setScale() पद्धत वापरू शकता . उदाहरणार्थ, समजा 111.5555555555 या संख्येला दशांश बिंदूनंतर तीन अंक हवे आहेत. तथापि, आम्ही setScale() पद्धतीसाठी वितर्क म्हणून क्रमांक 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.55 -> setScale(1, ROUND_HALF_UP) -> 0.6 0.54 -> setScale(1, ROUND_HALF_UP) -> 0.5
-
ROUND_HALF_DOWN — दशांश बिंदू > ०.५ नंतरची संख्या असल्यास पूर्णांक
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
मोठ्या संख्येची तुलना
हे देखील महत्त्वाचे आहे. तुम्हाला आठवत असेल की आम्ही Java मधील ऑब्जेक्ट्सची तुलना करण्यासाठी equals() पद्धत वापरतो. अंमलबजावणी एकतर भाषेद्वारे प्रदान केली जाते (मानक Java वर्गांसाठी) किंवा प्रोग्रामरद्वारे अधिलिखित केले जाते. परंतु BigDecimal ऑब्जेक्ट्सच्या बाबतीत , तुलनेसाठी equals() पद्धत वापरण्याची शिफारस केलेली नाही. याचे कारण असे की BigDecimal.equals() पद्धत 2 संख्यांचे मूल्य आणि स्केल समान असल्यासच खरे मिळते: दुहेरी आणि 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 वर्गात equals() पद्धतीच्या अंमलबजावणीच्या वैशिष्ट्यांमुळे होते . दोन BigDecimal ऑब्जेक्ट्सची अधिक अचूक तुलना करण्यासाठी , compareTo() पद्धत वापरणे चांगले आहे :
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
compareTo () पद्धतीने 0 परत केले, याचा अर्थ 1.5 आणि 1.50 समान आहेत. आणि हा परिणाम आम्हाला अपेक्षित आहे! :) आज आपला धडा संपतो. आता कार्यांवर परत जाण्याची वेळ आली आहे! :)
GO TO FULL VERSION