मैं जानता था कि निम्नलिखित दोनों कथनों को स्ट्रिंग बनाते हैं a रनटाइम पर लगातार पूल में:
String s = "a"
String s = new String("a")
जेवीएम पर इनका परीक्षण करते समय, पर्मेंन आकार दोनों मामलों के लिए समान होता है।
निम्नलिखित कोड स्निपेट, हालांकि, इससे अलग व्यवहार करते हैं:
String s2 = null;
for (int i = 0; i < 100; i++)
{
s2 = s2 + i;
}
का उपयोग करते हुए .intern()प्रत्येक पुनरावृत्ति में परमिट का आकार बढ़ता है:
String s2 = null;
for (int i = 0; i < 100; i++)
{
s2 = s2 + i;
s2.intern();
}
यह व्यवहार अवलोकनीय क्यों है? कर देता है s2.intern() पूल में प्रविष्टियाँ जोड़ें? यह इन घोषणाओं से कैसे अलग है?
String s = "a"
String s = new String("a")
उत्तर:
उत्तर № 1 के लिए 4यहाँ एक छोटी सी व्याख्या है:
"a"स्ट्रिंग बनाएँ "ए" इंटर्न पूल में अगर पहले से मौजूद नहीं हैnew String("a")क्योंकि पैरामीटर है "ए", डोर "ए" इंटर्न पूल (यदि पहले से मौजूद नहीं है) और की एक प्रति में बनाया गया है "ए" आंतरिक पूल से बाहर बनाया गया है- किसी भी स्ट्रिंग एस लिया
s.intern()इंटर्न पूल में मौजूद होने पर उस स्ट्रिंग की एक आंतरिक कॉपी लौटाता है। यदि उस स्ट्रिंग को इंटर्न पूल में नहीं जोड़ा जाता है और नई कॉपी लौटाता है।
के लिए एक संदर्भ प्रशिक्षु () तरीका:
जब आंतरिक विधि को लागू किया जाता है, यदि पूलपहले से ही एक शामिल है इस स्ट्रिंग वस्तु के बराबर स्ट्रिंग जो कि बराबर (ऑब्जेक्ट) द्वारा निर्धारित की जाती है विधि, फिर पूल से स्ट्रिंग लौटा दी जाती है। अन्यथा, यह स्ट्रिंग ऑब्जेक्ट को पूल में जोड़ा जाता है और इस स्ट्रिंग का एक संदर्भ वस्तु लौटाई जाती है।
ध्यान दें: बनाने के लिए String तथा डॉन "टी इसे आंतरिक पूल में जोड़ें आप ऐसा कर सकते हैं स्ट्रिंग के एक सरणी का उपयोग स्ट्रिंग कंस्ट्रक्टर के पैरामीटर के रूप में करें:
char[] helloArray = { "h", "e", "l", "l", "o", "." };
String helloString = new String(helloArray);
यहाँ का संदर्भ है jls जहाँ यह समझाया गया है कि एक स्ट्रिंग शाब्दिक तार के आंतरिक पूल में मौजूद है:
एक स्ट्रिंग शाब्दिक वर्ग स्ट्रिंग (.34.3.1, al4.3.3) के उदाहरण के लिए एक संदर्भ है।
इसके अलावा, एक स्ट्रिंग शाब्दिक हमेशा कक्षा के एक ही उदाहरण को संदर्भित करता है स्ट्रिंग। यह है क्योंकि स्ट्रिंग शाब्दिक - या, अधिक सामान्यतः, तार वे निरंतर भावों के मान हैं (§15.28) - "नजरबंद" हैं इसलिए String.intern विधि का उपयोग करते हुए, अद्वितीय उदाहरण साझा करने के लिए।
यहाँ अंतिम टिप्पणी के लिए एक कदम से कदम स्पष्टीकरण:
// Creates the string "123", add it to the intern pool and assign "123" to s
String s = "123";
// s.intern() returns the intern string of s. Because s is already the
// string "123" present in the intern pool s and s.intern() are the same
System.out.println(s == s.intern());// true
// "123" is already in intern pool. new String("123") create a new String
// that equals "123" but it is a different object
String s2 = new String("123");
// It prints false because s2 is equals to "123", but not the same object
// because a new String was created in the preciding row
System.out.println(s2 == s);// false
// It prints true because s2.intern() returns the string present in the
// intern pool that is equals to s2. That string exists and is "123"
System.out.println(s2.intern() == s); // true
अतिरिक्त नोट: प्रत्येक स्ट्रिंग s के लिए जो s2, s.intern () == s2.intern () के बराबर है, भले ही s == s2 गलत हो।
// If s equals s2 but are not the same
if (s.equals(s2) && s != s2) {
// THe intern string of s and s2 are always the same
System.out.println(s.intern() == s2.intern()); // prints always true
}
जवाब के लिए 0 № 2
चूँकि इंटर्न स्ट्रिंग्स को JVM- वाइड इंटर्न किया गया है, इसलिए उन्हें स्टैटिकली इंटर्न किया जाना चाहिए, जिसके लिए तंत्र का उपयोग करना होगा वर्ग कैशिंग के लिए विशेषता, जो पर्मगेन मेमोरी का उपभोग करेगा।