Java Language
आदिम डेटा प्रकार

परिचय

वाक्य - विन्यास

• int aInt = 8; // इस int घोषणा के भाग (संख्या) को शाब्दिक कहा जाता है।

• int hexInt = 0x1a; // = 26; आप 0x के साथ उपसर्ग के साथ शाब्दिक मानों को परिभाषित कर सकते हैं।

• int binInt = 0b11010; // = 26; आप द्विआधारी शाब्दिक भी परिभाषित कर सकते हैं; 0b के साथ उपसर्ग।

• लंबा गुडलोंग = 10000000000 एल; // डिफ़ॉल्ट रूप से, पूर्णांक शाब्दिक प्रकार int हैं। शाब्दिक के अंत में एल जोड़कर आप संकलक को बता रहे हैं कि शाब्दिक एक लंबा है। इसके बिना संकलक एक "पूर्णांक संख्या बहुत बड़ी" त्रुटि फेंक देगा।

• डबल aDouble = 3.14; // फ्लोटिंग-पॉइंट लिटरल डिफ़ॉल्ट रूप से डबल टाइप के होते हैं।

• फ्लोट एफ्लोअट = 3.14 एफ; // डिफ़ॉल्ट रूप से यह शाब्दिक एक डबल (और "असंगत प्रकार" त्रुटि) का कारण होता, लेकिन एफ जोड़कर हम संकलक को बताते हैं कि यह एक फ्लोट है।

टिप्पणियों

byte a = 1;
byte b = 2;
byte c = (byte) (a + b);

अंतर आदिम

एक आदिम डेटा प्रकार जैसे int सीधे उस चर में मान रखता है जो इसका उपयोग कर रहा है, इस बीच एक चर जिसे Integer का उपयोग करके घोषित किया गया था वह मूल्य का संदर्भ रखता है।

जावा एपीआई के अनुसार: "इंटेगर वर्ग एक वस्तु में आदिम प्रकार के इंट का मान लपेटता है। प्रकार की वस्तु इंटीजर में एक एकल फ़ील्ड होता है जिसका प्रकार इंट होता है।"

डिफ़ॉल्ट रूप से, int एक 32-बिट हस्ताक्षरित पूर्णांक है। यह न्यूनतम मूल्य ^{२१ ३१} , और अधिकतम मूल्य ^३१ - १ स्टोर कर सकता है।

int example = -42;
int myInt = 284;
int anotherInt = 73;

int addedInts = myInt + anotherInt; // 284 + 73 = 357
int subtractedInts = myInt - anotherInt; // 284 - 73 = 211

यदि आपको इस सीमा के बाहर एक संख्या को संग्रहीत करने की आवश्यकता है, तो इसके बजाय long उपयोग किया जाना चाहिए। int का मान सीमा से अधिक होना पूर्णांक अतिप्रवाह की ओर जाता है, जिससे मान सीमा के विपरीत सीमा के विपरीत साइट में जुड़ जाता है (धनात्मक ऋणात्मक और विसे वर्सा बन जाता है)। मान है ((value - MIN_VALUE) % RANGE) + MIN_VALUE , या ((value + 2147483648) % 4294967296) - 2147483648

int demo = 2147483647; //maximum positive integer
System.out.println(demo); //prints 2147483647
demo = demo + 1; //leads to an integer overflow
System.out.println(demo); // prints -2147483648

int अधिकतम और न्यूनतम मूल्य निम्न पर int जा सकते हैं:

int high = Integer.MAX_VALUE;    // high == 2147483647
int low = Integer.MIN_VALUE;     // low == -2147483648

एक int का डिफ़ॉल्ट मान 0 है

int defaultInt;    // defaultInt == 0

लघु आदिम

एक short एक 16-बिट हस्ताक्षरित पूर्णांक है। इसका न्यूनतम मूल्य -2 ¹⁵ (-32,768) है, और अधिकतम मूल्य 2 ¹⁵ (1 (32,767)

short example = -48;
short myShort = 987;
short anotherShort = 17;

short addedShorts = (short) (myShort + anotherShort); // 1,004
short subtractedShorts = (short) (myShort - anotherShort); // 970

short अधिकतम और न्यूनतम मूल्यों को निम्न पर पाया जा सकता है:

short high = Short.MAX_VALUE;        // high == 32767
short low = Short.MIN_VALUE;         // low == -32768

एक short का डिफ़ॉल्ट मान 0 है

short defaultShort;    // defaultShort == 0

लंबे आदिम

डिफ़ॉल्ट रूप से, long एक 64-बिट हस्ताक्षरित पूर्णांक है (जावा 8 में, इसे या तो हस्ताक्षरित या अहस्ताक्षरित किया जा सकता है)। हस्ताक्षरित, यह न्यूनतम मूल्य को ^{६३ 63} , और अधिकतम मूल्य ^६३ - १ को स्टोर कर सकता है, और अहस्ताक्षरित यह न्यूनतम मान ० और अधिकतम मूल्य ^६४ - १ को स्टोर कर सकता है

long example = -42;
long myLong = 284;
long anotherLong = 73;

//an "L" must be appended to the end of the number, because by default,
//numbers are assumed to be the int type. Appending an "L" makes it a long
//as 549755813888 (2 ^ 39) is larger than the maximum value of an int (2^31 - 1),
//"L" must be appended 
long bigNumber = 549755813888L;

long addedLongs = myLong + anotherLong; // 284 + 73 = 357
long subtractedLongs = myLong - anotherLong; // 284 - 73 = 211

की अधिकतम और न्यूनतम मूल्यों long पर पाया जा सकता:

long high = Long.MAX_VALUE;    // high == 9223372036854775807L
long low = Long.MIN_VALUE;     // low == -9223372036854775808L

एक long का डिफ़ॉल्ट मान 0L है

long defaultLong;    // defaultLong == 0L

नोट: अक्षर "एल" long शाब्दिक के अंत में जोड़ा गया है, यह असंवेदनशील है, हालांकि यह पूंजी का उपयोग करने के लिए अच्छा अभ्यास है क्योंकि यह अंक एक से अलग करना आसान है:

2L == 2l;            // true

चेतावनी: जावा कैश इंटर्जेन्स ऑब्जेक्ट्स -128 से लेकर 127 तक के उदाहरण हैं। तर्क यहां बताया गया है: https://blogs.oracle.com/darcy/entry/boxing_and_caches_integer_valueof

निम्नलिखित परिणाम पाए जा सकते हैं:

Long val1 = 127L;
Long val2 = 127L;

System.out.println(val1 == val2); // true

Long val3 = 128L;
Long val4 = 128L;

System.out.println(val3 == val4); // false

2 ऑब्जेक्ट लॉन्ग वैल्यू की ठीक से तुलना करने के लिए, निम्नलिखित कोड (जावा 1.7 से आगे) का उपयोग करें:

Long val3 = 128L;
Long val4 = 128L;

System.out.println(Objects.equal(val3, val4)); // true

एक आदिम लंबे समय तक किसी वस्तु की तुलना करने पर == के साथ 2 वस्तुओं की तुलना करने पर एक गलत नकारात्मक परिणाम नहीं होगा।

बूलियन आदिम

एक boolean दो मूल्यों में से एक को स्टोर कर सकता है, या तो true या false

boolean foo = true;
System.out.println("foo = " + foo);                // foo = true

boolean bar = false;
System.out.println("bar = " + bar);                // bar = false

boolean notFoo = !foo;
System.out.println("notFoo = " + notFoo);          // notFoo = false

boolean fooAndBar = foo && bar;
System.out.println("fooAndBar = " + fooAndBar);    // fooAndBar = false

boolean fooOrBar = foo || bar;
System.out.println("fooOrBar = " + fooOrBar);      // fooOrBar = true

boolean fooXorBar = foo ^ bar;
System.out.println("fooXorBar = " + fooXorBar);    // fooXorBar = true

एक boolean का डिफ़ॉल्ट मान गलत है

boolean defaultBoolean;    // defaultBoolean == false

बाइट आदिम

एक byte एक 8-बिट हस्ताक्षरित पूर्णांक है। यह -2 ⁷ (-128) का न्यूनतम मूल्य और 2 ⁷ - 1 (127) का अधिकतम मूल्य संग्रहीत कर सकता है।

byte example = -36;
byte myByte = 96;
byte anotherByte = 7;

byte addedBytes = (byte) (myByte + anotherByte); // 103
byte subtractedBytes = (byte) (myBytes - anotherByte); // 89

byte अधिकतम और न्यूनतम मूल्यों को निम्न पर पाया जा सकता है:

byte high = Byte.MAX_VALUE;        // high == 127
byte low = Byte.MIN_VALUE;         // low == -128

एक byte का डिफ़ॉल्ट मान 0 है

byte defaultByte;    // defaultByte == 0

तैरने वाला आदिम

float एक एकल-सटीक 32-बिट IEEE 754 फ़्लोटिंग पॉइंट नंबर है। डिफ़ॉल्ट रूप से, दशमलव को युगल के रूप में व्याख्या की जाती है। एक float बनाने के लिए, बस दशमलव शाब्दिक रूप से एक f संलग्न करें।

double doubleExample = 0.5;      // without 'f' after digits = double
float floatExample = 0.5f;       // with 'f' after digits    = float

float myFloat = 92.7f;           // this is a float...
float positiveFloat = 89.3f;     // it can be positive,
float negativeFloat = -89.3f;    // or negative
float integerFloat = 43.0f;      // it can be a whole number (not an int)
float underZeroFloat = 0.0549f;  // it can be a fractional value less than 0

फ़्लैट्स पाँच सामान्य अंकगणितीय संक्रियाओं को संभालते हैं: जोड़, घटाव, गुणा, भाग और मापांक।

नोट: फ़्लोटिंग पॉइंट त्रुटियों के परिणामस्वरूप निम्न भिन्न हो सकते हैं। कुछ परिणामों को स्पष्टता और पठनीयता के उद्देश्य के लिए गोल किया गया है (अर्थात इसके अतिरिक्त उदाहरण का मुद्रित परिणाम वास्तव में 34.600002 था)।

// addition
float result = 37.2f + -2.6f;  // result: 34.6

// subtraction
float result = 45.1f - 10.3f;    // result: 34.8

// multiplication
float result = 26.3f * 1.7f;   // result: 44.71

// division
float result = 37.1f / 4.8f;   // result: 7.729166

// modulus
float result = 37.1f % 4.8f;   // result: 3.4999971

जिस तरह से फ्लोटिंग पॉइंट नंबर स्टोर किए जाते हैं (यानी बाइनरी फॉर्म में), कई नंबर का सटीक प्रतिनिधित्व नहीं होता है।

float notExact = 3.1415926f;
System.out.println(notExact); // 3.1415925

float का उपयोग करते समय अधिकांश अनुप्रयोगों के लिए ठीक है, न तो float और न ही double का उपयोग दशमलव संख्याओं (जैसे मौद्रिक मात्रा), या संख्याओं के सटीक प्रतिनिधित्व को संग्रहीत करने के लिए किया जाना चाहिए जहां उच्च परिशुद्धता की आवश्यकता होती है। इसके बजाय, BigDecimal वर्ग का उपयोग किया जाना चाहिए।

एक float का डिफ़ॉल्ट मान 0.0f है ।

float defaultFloat;    // defaultFloat == 0.0f

एक float लगभग 10 मिलियन में 1 की त्रुटि के लिए सटीक है।

नोट: float . Float.POSITIVE_INFINITY , Float.NEGATIVE_INFINITY , Float.NaN । float मान हैं। NaN उन परिचालनों के परिणामों के लिए है जो निर्धारित नहीं किए जा सकते हैं, जैसे 2 अनंत मानों को विभाजित करना। इसके अलावा 0f और -0f अलग हैं, लेकिन == पैदावार सच है:

float f1 = 0f;
float f2 = -0f;
System.out.println(f1 == f2); // true
System.out.println(1f / f1); // Infinity
System.out.println(1f / f2); // -Infinity
System.out.println(Float.POSITIVE_INFINITY / Float.POSITIVE_INFINITY); // NaN

डबल आदिम

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

double example = -7162.37;
double myDouble = 974.21;
double anotherDouble = 658.7;

double addedDoubles = myDouble + anotherDouble; // 315.51
double subtractedDoubles = myDouble - anotherDouble; // 1632.91

double scientificNotationDouble = 1.2e-3;    // 0.0012

जिस तरह से फ़्लोटिंग पॉइंट संख्याओं को संग्रहीत किया जाता है, कई संख्याओं का सटीक प्रतिनिधित्व नहीं होता है।

double notExact = 1.32 - 0.42; // result should be 0.9
System.out.println(notExact); // 0.9000000000000001

double का उपयोग करते समय अधिकांश अनुप्रयोगों के लिए ठीक है, न तो float और न ही double का उपयोग सटीक संख्याओं जैसे कि मुद्रा को स्टोर करने के लिए किया जाना चाहिए। इसके बजाय, BigDecimal वर्ग का उपयोग किया जाना चाहिए

एक double का डिफ़ॉल्ट मान 0.0d है

public double defaultDouble;    // defaultDouble == 0.0

नोट: Double.POSITIVE_INFINITY , Double.NEGATIVE_INFINITY , Double.NaN double मान हैं। NaN उन परिचालनों के परिणामों के लिए है जो निर्धारित नहीं किए जा सकते हैं, जैसे 2 अनंत मानों को विभाजित करना। इसके अलावा 0d और -0d अलग हैं, लेकिन == पैदावार सच है:

double d1 = 0d;
double d2 = -0d;
System.out.println(d1 == d2); // true
System.out.println(1d / d1); // Infinity
System.out.println(1d / d2); // -Infinity
System.out.println(Double.POSITIVE_INFINITY / Double.POSITIVE_INFINITY); // NaN

चारु आदिम

एक char एकल 16-बिट यूनिकोड चरित्र को संग्रहीत कर सकता है। एक चरित्र शाब्दिक एकल उद्धरण में संलग्न है

char myChar = 'u';
char myChar2 = '5';
char myChar3 = 65; // myChar3 == 'A'

इसका न्यूनतम मान \u0000 (दशमलव प्रतिनिधित्व में 0, इसे शून्य वर्ण भी कहा जाता है) और अधिकतम मूल्य of \uffff (65,535)।

एक char का डिफ़ॉल्ट मान \u0000 ।

char defaultChar;    // defaultChar == \u0000

एक ' वैल्यू ऑफ ए एस्केप सीक्वेंस (एक बैकस्लैश से पहले का चरित्र) के एक चार्ट को परिभाषित करने के लिए उपयोग किया जाना है:

char singleQuote = '\'';

अन्य भागने के क्रम भी हैं:

char tab = '\t';
char backspace = '\b';
char newline = '\n';
char carriageReturn = '\r';
char formfeed = '\f';
char singleQuote = '\'';
char doubleQuote = '\"'; // escaping redundant here; '"' would be the same; however still allowed
char backslash = '\\';
char unicodeChar = '\uXXXX' // XXXX represents the Unicode-value of the character you want to display

आप किसी भी यूनिकोड वर्ण के char की घोषणा कर सकते हैं।

char heart = '\u2764';
System.out.println(Character.toString(heart)); // Prints a line containing "❤".

एक char जोड़ना भी संभव है। प्रत्येक निम्न-केस पत्र के माध्यम से पुनरावृति करना, आप निम्न कार्य कर सकते हैं:

for (int i = 0; i <= 26; i++) {
    char letter = (char) ('a' + i);
    System.out.println(letter);
}

नकारात्मक मूल्य प्रतिनिधित्व

जावा और अधिकांश अन्य भाषाओं में 2 के पूरक अंकन नामक एक प्रतिनिधित्व में नकारात्मक अभिन्न संख्याओं को संग्रहीत किया जाता है।

n बिट्स का उपयोग करके डेटा प्रकार के एक अद्वितीय बाइनरी प्रतिनिधित्व के लिए, मान इस तरह एन्कोड किए गए हैं:

कम से कम महत्वपूर्ण n-1 बिट्स अभिन्न प्रतिनिधित्व में एक सकारात्मक अभिन्न संख्या x संग्रहीत करते हैं। सबसे महत्वपूर्ण मूल्य थोड़ा vith मूल्य s संग्रहीत करता है। उन बिट्स द्वारा repesented मूल्य है

x - s * 2 ^n-1

अर्थात यदि सबसे महत्वपूर्ण बिट 1 है, तो एक मान जो कि संख्या से 1 बड़ा है जो आप अन्य बिट्स ( 2 n-2 + 2 n-3 + ... + 2 1 + 2 0 = 2 n-1 - 1 ) प्रत्येक मान के लिए एक अद्वितीय बाइनरी प्रतिनिधित्व की अनुमति से घटाया जाता है - 2 ^n-1 (s = 1; x = 0) से 2 ^n-1 - 1 (s = 0; x = 2 ^n-1) ; 1)।

इसका अच्छा दुष्प्रभाव यह भी है, कि आप बाइनरी अभ्यावेदन जोड़ सकते हैं जैसे कि वे सकारात्मक बाइनरी नंबर थे:

v1 = x1 - s1 * 2n-1
v2 = x2 - s2 * 2n-1

x1 + x2 - 2n-1 = x1 + x2 - s2 * 2n-1
              = v1 + v2

(x1 + x2) mod 2n-1 = x1 + x2 - 2n-1
                  = v1 + v2

(x1 + x2) mod 2n-1 - 2n-1 = (x1 + x2 - 2n-1) - 2n-1
                         = (x1 - s1 * 2n-1) + (x2 - s2 * 2n-1)
                         = v1 + v2

ध्यान दें कि यह तथ्य एडिटिव इनवर्स के बाइनरी प्रतिनिधित्व (यानी नकारात्मक मूल्य) को आसान बनाता है:

निरीक्षण करें कि सभी बिट्स में संख्या परिणामों के लिए बिटवाइज पूरक जोड़ना 1. अब वैल्यू ओवरफ्लो बनाने के लिए 1 जोड़ें और आपको तटस्थ तत्व 0 (सभी बिट्स 0) मिलता है।

एक नंबर के नकारात्मक मूल्य तो i (करने के लिए संभव पदोन्नति अनदेखी का उपयोग कर गणना की जा सकती int यहाँ)

(~i) + 1

उदाहरण: 0 ( byte ) का ऋणात्मक मान लेना:

0 को नकारने का परिणाम, 11111111 । 1 जोड़ने पर 100000000 (9 बिट्स) का मूल्य मिलता है। क्योंकि एक byte केवल 8 बिट्स को स्टोर कर सकता है, बाईं ओर का मूल्य छोटा है, और परिणाम 00000000

प्राइमरी बनाम बॉक्सिंग प्राइमेटिक्स की मेमोरी खपत

बॉक्स ऑब्जेक्ट्स को टाइप और मेमोरी मैनेजमेंट के लिए हमेशा 8 बाइट्स की आवश्यकता होती है, और क्योंकि ऑब्जेक्ट्स का आकार हमेशा 8 से अधिक होता है, बॉक्सिंग प्रकारों के लिए कुल 16 बाइट्स की आवश्यकता होती है । इसके अलावा , बॉक्सिंग ऑब्जेक्ट का प्रत्येक उपयोग एक संदर्भ संग्रहीत करता है जो JVM और JVM विकल्पों के आधार पर एक और 4 या 8 बाइट्स के लिए खाता है।

डेटा-गहन संचालन में, मेमोरी की खपत प्रदर्शन पर एक बड़ा प्रभाव डाल सकती है। सरणियों का उपयोग करते समय मेमोरी की खपत और भी बढ़ जाती है: एक float[5] सरणी को केवल 32 बाइट्स की आवश्यकता होगी; जबकि एक Float[5] 5 अलग-अलग गैर-शून्य मानों को संग्रहीत करने के लिए 112 बाइट्स की कुल आवश्यकता होगी (संकुचित बिंदुओं के बिना 64 बिट पर, यह 152 बाइट्स तक बढ़ जाती है)।

बॉक्सिंग मूल्य कैश

बॉक्सिंग प्रकारों के अंतरिक्ष ओवरहेड्स को बॉक्सिंग वैल्यू कैश द्वारा एक हद तक कम किया जा सकता है। कुछ बॉक्स प्रकार के उदाहरणों का एक कैश लागू करते हैं। उदाहरण के लिए, डिफ़ॉल्ट रूप से, Integer संख्या -128 से +127 तक संख्याओं का प्रतिनिधित्व करने के लिए Integer क्लास इंस्टेंसेस को कैश करेगा। यह, हालांकि, अतिरिक्त मेमोरी अप्रत्यक्ष से उत्पन्न होने वाली अतिरिक्त लागत को कम नहीं करता है।

यदि आप ऑटोबॉक्सिंग या स्थिर valueOf(primitive) विधि से कॉल करके बॉक्सिंग प्रकार का एक उदाहरण बनाते हैं, तो रनटाइम सिस्टम एक कैश्ड मान का उपयोग करने का प्रयास करेगा। यदि आपका एप्लिकेशन कैश की गई श्रेणी में बहुत सारे मानों का उपयोग करता है, तो यह बॉक्सिंग प्रकारों का उपयोग करके मेमोरी पेनल्टी को काफी हद तक कम कर सकता है। निश्चित रूप से, यदि आप "हाथ से" बॉक्सिंग वैल्यू इंस्टेंस बना रहे हैं, तो new बजाय valueOf का उपयोग करना बेहतर है। ( new ऑपरेशन हमेशा एक नया उदाहरण बनाता है।) यदि, हालांकि, आपके अधिकांश मूल्य कैश्ड श्रेणी में नहीं हैं, तो new को कॉल करने और कैश लुक को सहेजने के लिए तेज़ हो सकता है।

प्राइमरी को परिवर्तित करना

जावा में, हम पूर्णांक मान और फ्लोटिंग-पॉइंट मानों के बीच परिवर्तित कर सकते हैं। साथ ही, चूंकि प्रत्येक वर्ण यूनिकोड एन्कोडिंग में एक संख्या से मेल खाता है, इसलिए char प्रकार को पूर्णांक और फ्लोटिंग-पॉइंट प्रकारों से परिवर्तित किया जा सकता है। boolean एकमात्र आदिम डेटाटाइप है जिसे किसी अन्य आदिम डेटाटाइप से या उससे परिवर्तित नहीं किया जा सकता है।

रूपांतरण दो प्रकार के होते हैं: रूपांतरण को चौड़ा करना और रूपांतरण को संकुचित करना ।

एक व्यापक रूपांतरण तब होता है जब एक डेटाटाइप का मान दूसरे डेटाटाइप के मान में परिवर्तित हो जाता है जो पूर्व की तुलना में अधिक बिट्स को अधिग्रहित करता है। इस मामले में डेटा हानि का कोई मुद्दा नहीं है।

इसके विपरीत, एक संकीर्ण रूपांतरण तब होता है जब एक डेटाटाइप का मान दूसरे डेटाटाइप के मान में परिवर्तित हो जाता है जो पूर्व की तुलना में कम बिट्स पर कब्जा कर लेता है। इस मामले में डेटा हानि हो सकती है।

जावा स्वचालित रूप से व्यापक रूपांतरण करता है। लेकिन अगर आप (यदि आप सुनिश्चित करें कि कोई डेटा हानि हो जाएगा रहे हैं) एक संकुचन रूपांतरण करने के लिए चाहते हैं, तो आप जावा रूपांतरण एक भाषा एक के रूप में जाना निर्माण का उपयोग कर प्रदर्शन करने के लिए मजबूर कर सकते हैं cast ।

व्यापक रूपांतरण:

int a = 1;    
double d = a;    // valid conversion to double, no cast needed (widening)

संकीर्ण रूपांतरण:

double d = 18.96
int b = d;       // invalid conversion to int, will throw a compile-time error
int b = (int) d; // valid conversion to int, but result is truncated (gets rounded down)
                 // This is type-casting
                 // Now, b = 18

आदिम प्रकार धोखा देती है

सभी आदिम प्रकारों का आकार और मान दिखाने वाली तालिका:

टिप्पणियाँ:

1. जावा लैंग्वेज स्पेसिफिकेशन अनिवार्य है जो कि इंटीग्रल टाइप ( long byte ) पर हस्ताक्षर करता है, बाइनरी ट्वोज़-सप्लीमेंट प्रतिनिधित्व का उपयोग करता है, और फ़्लोटिंग पॉइंट प्रकार मानक IEE 754 बाइनरी फ़्लोटिंग पॉइंट प्रतिनिधित्व का उपयोग करता है।
2. जावा 8 और बाद में int और long पर अहस्ताक्षरित संचालन करने के लिए तरीके प्रदान करते हैं। हालांकि ये विधियां संबंधित प्रकारों के मानों को असम्बद्ध मानने के लिए एक कार्यक्रम की अनुमति देती हैं, पर हस्ताक्षर किए गए प्रकार रहते हैं।
3. ऊपर दिखाए गए सबसे छोटे तैरने वाले बिंदु उप - असामान्य हैं ; यानी वे एक सामान्य मूल्य से कम परिशुद्धता है। सबसे छोटी सामान्य संख्या 1.175494351e are 38 और 2.2250738585072014e are 308 है
4. एक char पारंपरिक यूनिकोड / UTF-16 कोड इकाई का प्रतिनिधित्व करता है।
5. हालाँकि एक boolean में केवल एक बिट जानकारी होती है, मेमोरी में इसका आकार जावा वर्चुअल मशीन के कार्यान्वयन के आधार पर भिन्न होता है ( बूलियन प्रकार देखें)।