"पाठ" और नए स्ट्रिंग ("पाठ") के बीच अंतर क्या है?


195

इन दो कथनों में क्या अंतर है?

String s = "text";

String s = new String("text");


किसी को भी इस पर जवाब दें। स्ट्रिंग = "जावा"; स्ट्रिंग बी = "जावा"; System.out.println (a == b); सच // लेकिन System.out.println ("a == b?" + a == b); // मिथ्या ...
एनर्जी

मुझे समझ नहीं आता जब मैंने कुछ टिप्पणी ("a = b?) => जोड़ दी, तो मेरा परिणाम FALSE हो गया। क्यों?
ऊर्जा

@Energy इसका परिणाम यह है falseकि संचालन का क्रम निर्धारित करता है कि + ऑपरेटर पहले चला जाता है, "a == b?" स्ट्रिंग "a == b? Java" बनाने के लिए। तब अभिव्यक्ति "a==b?Java" == bझूठी का मूल्यांकन करती है।
एलिसन बी

@AllisonB मिल गया, बहुत बहुत धन्यवाद!
एनर्जी

जवाबों:


187

new String("text"); स्पष्ट रूप से एक Stringवस्तु का एक नया और संदर्भित अलग उदाहरण बनाता है ; यदि कोई उपलब्ध है तो स्ट्रिंग निरंतर पूलString s = "text"; से एक उदाहरण का पुन: उपयोग कर सकता है।

आप शायद ही कभी new String(anotherString)निर्माणकर्ता का उपयोग करना चाहेंगे । एपीआई से:

String(String original): एक नव निर्मित String वस्तु को आरम्भिक करता है ताकि यह तर्क के समान वर्णों का प्रतिनिधित्व करे; दूसरे शब्दों में, नव निर्मित स्ट्रिंग तर्क स्ट्रिंग की एक प्रति है। जब तक मूल की एक स्पष्ट प्रति की आवश्यकता न हो, तब तक इस निर्माता का उपयोग अनावश्यक है क्योंकि तार अपरिवर्तनीय हैं।

संबंधित सवाल


क्या संदर्भित अंतर का मतलब है

निम्नलिखित स्निपेट की जांच करें:

    String s1 = "foobar";
    String s2 = "foobar";

    System.out.println(s1 == s2);      // true

    s2 = new String("foobar");
    System.out.println(s1 == s2);      // false
    System.out.println(s1.equals(s2)); // true

==दो संदर्भ प्रकारों पर एक संदर्भ पहचान तुलना है। दो वस्तुएं जो equalsजरूरी नहीं हैं ====संदर्भ प्रकारों पर उपयोग करना आमतौर पर गलत है ; equalsइसके बजाय ज्यादातर समय का उपयोग करने की आवश्यकता है।

फिर भी, यदि किसी भी कारण से आपको दो equalsनहीं बल्कि ==स्ट्रिंग बनाने की आवश्यकता है , तो आप कंस्ट्रक्टर का उपयोग कर सकते हैं new String(anotherString)। हालांकि, यह फिर से कहने की आवश्यकता है कि यह बहुत अजीब है, और शायद ही कभी इरादा है।

संदर्भ

संबंधित मुद्दों


3
अगर मैं लिखूं: स्ट्रिंग s = नया स्ट्रिंग ("एबीसी"); और अब मैं लिखता हूं: स्ट्रिंग एस = "एबीसी"; स्ट्रिंग स्ट्रिंग s = "abc"; स्ट्रिंग पूल में एक नया स्ट्रिंग शाब्दिक बनाएं?
केवेश कंवल

कोई भी पूर्ववर्ती प्रश्न का उत्तर क्यों नहीं देता है?
शाम

2
@KesheshKanwal नहीं, शाब्दिक नकल नहीं होगी। जैसा कि आप देख सकते हैं कि 2 "abc"एस हैं। उनमें से केवल एक स्ट्रिंग पूल में जाएगा, और दूसरा इसे संदर्भित करेगा। फिर वहाँ है sजो उचित नई वस्तु होगी।
कयामन

1
@ केशव कंवल - स्ट्रिंग एस = नया स्ट्रिंग ("एबीसी") केवल मूल्य "एबीसी" के साथ एक नया स्ट्रिंग ऑब्जेक्ट बनाएगा। और दूसरा कथन यह जाँच करेगा कि कोई "एबीसी" स्ट्रिंग शाब्दिक पहले से ही स्ट्रिंग पूल में मौजूद है या नहीं। यदि पहले से ही मौजूद है, तो मौजूदा एक का संदर्भ दिया जाता है और यदि नहीं तो नए शाब्दिक ("एबीसी") स्ट्रिंग पूल में बनाया जाता है। आशा है कि यह आपकी क्वेरी को हल करता है !!
user968813

इसके बारे में कोई 'हो सकता है' नहीं है। संकलक को पूल स्ट्रिंग शाब्दिक होना चाहिएJLS 3.10.5
लोर्ने

119

स्ट्रिंग लिटरल्स स्ट्रिंग स्ट्रिंग कॉन्सटेंट पूल में जाएंगे ।

नीचे स्नैपशॉट आपको इसे अधिक समय तक याद रखने के लिए इसे नेत्रहीन रूप से समझने में मदद कर सकता है ।

यहां छवि विवरण दर्ज करें


ऑब्जेक्ट निर्माण लाइन लाइन द्वारा:

String str1 = new String("java5");

कंस्ट्रक्टर में स्ट्रिंग शाब्दिक "जावा 5" का उपयोग करते हुए, स्ट्रिंग निरंतर पूल में एक नया स्ट्रिंग मान संग्रहीत किया जाता है। नए ऑपरेटर का उपयोग करके, मान के रूप में "java5" के साथ ढेर में एक नया स्ट्रिंग ऑब्जेक्ट बनाया जाता है।

String str2 = "java5"

संदर्भ "str2" को स्ट्रिंग निरंतर पूल में पहले से ही संग्रहीत मूल्य की ओर इशारा किया गया है

String str3 = new String(str2);

एक नए स्ट्रिंग ऑब्जेक्ट को "str2" के संदर्भ के समान मान के साथ ढेर में बनाया गया है

String str4 = "java5";

संदर्भ "str4" स्ट्रिंग स्थिर पूल में पहले से ही संग्रहीत मूल्य को इंगित करता है

कुल वस्तुएं: ढेर - 2, पूल - 1

आगे Oracle समुदाय पर पढ़ना


1
अच्छा जवाब .. लेकिन यह जानने के लिए कि अब मैं str1 = "java6" के मूल्य को बदलने के लिए giong हूँ, तो यह str4 के मूल्य को बदल देगा?
कोरोनापिन्टू

2
हाँ, मैंने जाँच की थी कि यह str4 के मूल्य को नहीं बदलेगा
कोरोना पिन्टू

@ ब्रज क्या आप अपने उत्तरदाता के दावे का दस्तावेज़ीकरण प्रदान कर सकते हैं?
बेसिल बोर्ल जूल

@ ब्रज: टेबल में 'हीप' और 'पूल' के लिए हेडर रिवर्स माना जाता है?
राहुल कुरुप

गलत। निरंतर पूल को संकलित समय पर बनाया जाता है, निष्पादन समय पर नहीं। जो पाठ उद्धृत नहीं है, उसके लिए उद्धरण स्वरूपण का उपयोग न करें।
लोर्न

15

एक स्ट्रिंग स्थिरांक पूल में एक स्ट्रिंग बनाता है

String s = "text";

अन्य एक निरंतर पूल में एक स्ट्रिंग बनाता है ( "text") और सामान्य हीप स्पेस में एक और स्ट्रिंग ( s)। दोनों तारों का एक ही मूल्य होगा, "पाठ"।

String s = new String("text");

s बाद में अप्रयुक्त होने पर (जीसी के लिए पात्र) खो दिया है।

दूसरी ओर स्ट्रिंग शाब्दिकों का पुन: उपयोग किया जाता है। यदि आप "text"अपनी कक्षा के कई स्थानों पर उपयोग करते हैं तो यह वास्तव में एक और केवल एक स्ट्रिंग होगा (अर्थात पूल में एक ही स्ट्रिंग के कई संदर्भ)।


निरंतर पूल में तार कभी नहीं खोते हैं। क्या आपके कहने का मतलब है कि अगर बाद में अप्रयुक्त किया गया तो वह खो गया है?
लोर्ने

@ ईजेपी: हाँ, मेरा मतलब "s" था। ध्यान देने के लिए धन्यवाद। मैं सवाल सही करूंगा।

9

JLS

जेएलएस द्वारा अवधारणा को "इंटर्निंग" कहा जाता है।

JLS 7 3.10.5 से प्रासंगिक मार्ग :

इसके अलावा, एक स्ट्रिंग शाब्दिक हमेशा कक्षा स्ट्रिंग के एक ही उदाहरण को संदर्भित करता है। ऐसा इसलिए है क्योंकि स्ट्रिंग शाब्दिक - या, अधिक सामान्यतः, स्ट्रिंग्स जो निरंतर अभिव्यक्तियों (§15.28) के मान हैं - "इंटर्नड" हैं इसलिए अद्वितीय उदाहरणों को साझा करने के लिए, String.intern विधि का उपयोग कर।

उदाहरण 3.10.5-1। स्ट्रिंग साहित्य

संकलन इकाई (consisting7.3) से मिलकर कार्यक्रम:

package testPackage;
class Test {
    public static void main(String[] args) {
        String hello = "Hello", lo = "lo";
        System.out.print((hello == "Hello") + " ");
        System.out.print((Other.hello == hello) + " ");
        System.out.print((other.Other.hello == hello) + " ");
        System.out.print((hello == ("Hel"+"lo")) + " ");
        System.out.print((hello == ("Hel"+lo)) + " ");
        System.out.println(hello == ("Hel"+lo).intern());
    }
}
class Other { static String hello = "Hello"; }

और संकलन इकाई:

package other;
public class Other { public static String hello = "Hello"; }

उत्पादन का उत्पादन:

true true true true false true

JVMs

JVMS 7 5.1 कहता है :

एक स्ट्रिंग शाब्दिक वर्ग स्ट्रिंग के एक उदाहरण के लिए एक संदर्भ है, और एक वर्ग या इंटरफ़ेस के द्विआधारी प्रतिनिधित्व में एक CONSTANT_String_info संरचना (fo4.4.3) से लिया गया है। CONSTANT_String_info संरचना यूनिकोड कोड बिंदुओं के अनुक्रम को स्ट्रिंग शाब्दिक रूप देता है।

जावा प्रोग्रामिंग लैंग्वेज के लिए आवश्यक है कि समान स्ट्रिंग शाब्दिक (यानी, शाब्दिक जिसमें कोड अंकों का समान अनुक्रम हो) को कक्षा स्ट्रिंग (JLS §3.10.5) के समान उदाहरण को संदर्भित करना होगा। इसके अलावा, यदि String.intern को किसी भी स्ट्रिंग पर विधि कहा जाता है, तो परिणाम उसी वर्ग उदाहरण के लिए एक संदर्भ है जो कि यदि स्ट्रिंग एक शाब्दिक के रूप में दिखाई देता है तो उसे लौटा दिया जाएगा। इस प्रकार, निम्नलिखित अभिव्यक्ति का मूल्य सही होना चाहिए:

("a" + "b" + "c").intern() == "abc"

एक स्ट्रिंग शाब्दिक प्राप्त करने के लिए, जावा वर्चुअल मशीन CONSTANT_String_info संरचना द्वारा दिए गए कोड बिंदुओं के अनुक्रम की जांच करता है।

  • यदि विधि String.intern को पहले कक्षा स्ट्रिंग के एक उदाहरण पर बुलाया गया है, जिसमें CONSTANT_String_info संरचना द्वारा दिए गए यूनिकोड कोड बिंदुओं का एक अनुक्रम है, तो स्ट्रिंग शाब्दिक व्युत्पत्ति का परिणाम कक्षा स्ट्रिंग के उसी उदाहरण का संदर्भ है।

  • अन्यथा, क्लास स्ट्रिंग का एक नया उदाहरण CONSTANT_String_ffo संरचना द्वारा दिए गए यूनिकोड कोड बिंदुओं के अनुक्रम से बना है; उस वर्ग उदाहरण का एक संदर्भ स्ट्रिंग शाब्दिक व्युत्पत्ति का परिणाम है। अंत में, नए स्ट्रिंग उदाहरण का आंतरिक तरीका लागू किया जाता है।

बाईटकोड

यह भी OpenJDK 7 पर बायोटेक कार्यान्वयन को देखने के लिए शिक्षाप्रद है।

अगर हम सड़ जाते हैं:

public class StringPool {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        String c = new String("abc");
        System.out.println(a);
        System.out.println(b);
        System.out.println(a == c);
    }
}

हमारे पास निरंतर पूल है:

#2 = String             #32   // abc
[...]
#32 = Utf8               abc

और main:

 0: ldc           #2          // String abc
 2: astore_1
 3: ldc           #2          // String abc
 5: astore_2
 6: new           #3          // class java/lang/String
 9: dup
10: ldc           #2          // String abc
12: invokespecial #4          // Method java/lang/String."<init>":(Ljava/lang/String;)V
15: astore_3
16: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
19: aload_1
20: invokevirtual #6          // Method java/io/PrintStream.println:(Ljava/lang/String;)V
23: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
26: aload_2
27: invokevirtual #6          // Method java/io/PrintStream.println:(Ljava/lang/String;)V
30: getstatic     #5          // Field java/lang/System.out:Ljava/io/PrintStream;
33: aload_1
34: aload_3
35: if_acmpne     42
38: iconst_1
39: goto          43
42: iconst_0
43: invokevirtual #7          // Method java/io/PrintStream.println:(Z)V

नोट कैसे:

  • 0और 3: एक ही ldc #2निरंतर लोड किया जाता है (शाब्दिक)
  • 12: एक नया स्ट्रिंग उदाहरण बनाया गया है ( #2तर्क के रूप में)
  • 35: aऔर cनियमित वस्तुओं के साथ तुलना की जाती हैif_acmpne

निरंतर तार का प्रतिनिधित्व बाइटकोड पर काफी जादू है:

और ऊपर दिए गए JVMS उद्धरण से लगता है कि जब भी यूटीएफ 8 को इंगित किया जाता है, तब समान उदाहरणों को लोड किया जाता है ldc

मैंने खेतों के लिए इसी तरह के परीक्षण किए हैं, और:

निष्कर्ष : स्ट्रिंग पूल के लिए प्रत्यक्ष बाइटकोड समर्थन है, और मेमोरी प्रतिनिधित्व कुशल है।

बोनस: इसकी तुलना इंटेगर पूल से करें , जिसमें डायरेक्ट बायटेकोड सपोर्ट नहीं है (यानी कोई CONSTANT_String_infoएनालॉग नहीं )।


2

@ ब्रज: मुझे लगता है कि यू ने दूसरे तरीके का उल्लेख किया है। अगर मैं गलत हूं कृपया मुझे सही

ऑब्जेक्ट निर्माण लाइन लाइन द्वारा:

स्ट्रिंग str1 = नया स्ट्रिंग ("java5")

   Pool- "java5" (1 Object)

   Heap - str1 => "java5" (1 Object)

स्ट्रिंग str2 = "java5"

  pool- str2 => "java5" (1 Object)

  heap - str1 => "java5" (1 Object)

स्ट्रिंग str3 = नया स्ट्रिंग (str2)

  pool- str2 => "java5" (1 Object)

  heap- str1 => "java5", str3 => "java5" (2 Objects)

स्ट्रिंग स्ट्रिंग 4 = "जावा 5"

  pool - str2 => str4 => "java5" (1 Object)

  heap - str1 => "java5", str3 => "java5" (2 Objects)

str1के मूल्य में शामिल नहीं है str2या str3या str4किसी भी तरह से।
लोर्न

1

"bla"जादू की फैक्ट्री की तरह सोचें Strings.createString("bla")(छद्म)। फैक्ट्री में इस तरह से बनाए गए सभी तारों का एक पूल है।

यदि यह लागू हो जाता है, तो यह जांचता है कि क्या इस मान के साथ पूल में पहले से ही स्ट्रिंग है। यदि सही है, तो यह इस स्ट्रिंग ऑब्जेक्ट को लौटाता है, इसलिए इस तरह से प्राप्त स्ट्रिंग्स वास्तव में एक ही ऑब्जेक्ट हैं।

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

मैन्युअल रूप से बनाने new String("")से स्ट्रिंग शाब्दिक पूल को दरकिनार करके इस व्यवहार को ओवरराइड किया जाता है। इसलिए समानता को हमेशा जाँचना चाहिए, equals()जो वस्तु संदर्भ समानता के बजाय चरित्र अनुक्रम की तुलना करता है।


आप जिस less मैजिक फैक्ट्री ’का उल्लेख करते हैं, वह जावा कंपाइलर से अधिक या कम नहीं है। यह इस प्रक्रिया को लिखने के लिए एक गलती है क्योंकि यह रनटाइम में हुई थी।
लोर्न का

1

अंतर समझने का एक सरल तरीका निम्न है: -

String s ="abc";
String s1= "abc";
String s2=new String("abc");

        if(s==s1){
            System.out.println("s==s1 is true");
        }else{
            System.out.println("s==s1 is false");
        }
        if(s==s2){
            System.out.println("s==s2 is true");
        }else{
            System.out.println("s==s2 is false");
        }

आउटपुट है

s==s1 is true
s==s2 is false

इस प्रकार नई स्ट्रिंग () हमेशा एक नया उदाहरण बनाएगी।


1

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

String obj1 = "abc";
String obj2 = "abc";

"obj1" और "obj2" समान स्ट्रिंग शाब्दिक को इंगित करेंगे और स्ट्रिंग शाब्दिक पूल में केवल एक "abc" शाब्दिक होगा।

जब हम नए कीवर्ड का उपयोग करते हुए स्ट्रिंग क्लास ऑब्जेक्ट बनाते हैं तो इस प्रकार बनाए गए स्ट्रिंग को ढेर मेमोरी में संग्रहीत किया जाता है। स्ट्रिंग स्ट्रिंग वर्ग के निर्माता के लिए पैरामीटर के रूप में पारित किसी भी स्ट्रिंग शाब्दिक हालांकि स्ट्रिंग पूल में संग्रहीत किया जाता है। यदि हम नए ऑपरेटर के साथ समान मूल्य का उपयोग करके कई ऑब्जेक्ट बनाते हैं, तो हर बार हीप में एक नई ऑब्जेक्ट बनाई जाएगी, क्योंकि इस नए ऑपरेटर से बचा जाना चाहिए।

String obj1 = new String("abc");
String obj2 = new String("abc");

"obj1" और "obj2" दो अलग-अलग वस्तुओं को ढेर में इंगित करेंगे और स्ट्रिंग शाब्दिक पूल में केवल एक "abc" शाब्दिक होगा।

तार के व्यवहार के संबंध में कुछ ऐसा भी है जो ध्यान देने योग्य है कि स्ट्रिंग पर किया गया कोई भी नया असाइनमेंट या कॉन्सेप्टन मेमोरी में एक नई वस्तु बनाता है।

String str1 = "abc";
String str2 = "abc" + "def";
str1 = "xyz";
str2 = str1 + "ghi";

अब उपरोक्त मामले में:
लाइन 1: "एबीसी" शाब्दिक स्ट्रिंग पूल में संग्रहीत है।
पंक्ति 2: "एब्सडेफ़" शाब्दिक स्ट्रिंग पूल में संग्रहीत होता है।
पंक्ति 3: एक नया "xyz" शाब्दिक स्ट्रिंग पूल में संग्रहीत है और "str1" इस शाब्दिक को इंगित करता है।
पंक्ति 4: चूँकि मान किसी अन्य चर के साथ जोड़कर उत्पन्न होता है, परिणाम ढेर स्मृति में संग्रहीत होता है और "घी" को शाब्दिक रूप से जोड़ा जाता है, इसे स्ट्रिंग पूल में इसके अस्तित्व के लिए जाँचा जाएगा और तब से बनाया जाएगा जब तक इसमें मौजूद न हो उपरोक्त मामला।


0

यद्यपि यह प्रोग्रामर के दृष्टिकोण से समान दिखता है, लेकिन इसका बड़ा प्रदर्शन प्रभाव पड़ता है। आप पहले फ़ॉर्म का उपयोग लगभग हमेशा करना चाहेंगे।


0
String str = new String("hello")

यह जांच करेगा कि क्या स्ट्रिंग निरंतर पूल में पहले से ही स्ट्रिंग "हैलो" है? यदि मौजूद है तो यह स्ट्रिंग निरंतर पूल में एक प्रविष्टि नहीं जोड़ेगा। यदि मौजूद नहीं है तो यह स्ट्रिंग निरंतर पूल में एक प्रविष्टि जोड़ देगा।

ढेर मेमोरी क्षेत्र में एक strऑब्जेक्ट बनाया जाएगा और हीप मेमोरी लोकेशन में बनाई गई ऑब्जेक्ट के संदर्भ बिंदु।

यदि आप strस्ट्रिंग स्थिर स्थिर पूल में स्थित बिंदु वस्तु का संदर्भ चाहते हैं तो किसी को स्पष्ट रूप से कॉल करना होगाstr.intern();

String str = "world";

यह जांच करेगा कि क्या स्ट्रिंग निरंतर पूल में पहले से ही स्ट्रिंग "हैलो" है? यदि मौजूद है तो यह स्ट्रिंग निरंतर पूल में एक प्रविष्टि नहीं जोड़ेगा। यदि मौजूद नहीं है तो यह स्ट्रिंग निरंतर पूल में एक प्रविष्टि जोड़ देगा।

उपरोक्त दोनों मामले में, कॉन्स्टेंट पूल में मौजूद strस्ट्रिंग का संदर्भ इंगित करता है "world"


'यह' जावा कंपाइलर है। स्ट्रिंग शाब्दिक संकलन समय में निरंतर पूल में एक अद्वितीय प्रविष्टि बनाता है। यह इस प्रक्रिया को बहाने के लिए एक गलती है, क्योंकि यह रनटाइम के दौरान होता है ..
मार्क्विस ऑफ़ लोर्न

क्या आप स्पष्ट कर सकते हैं कि इस पोस्ट में स्पष्ट रूप से क्या गलत है?
जयेश

इस पोस्ट में जो गलत है वह यह है कि स्ट्रिंग शाब्दिक समय जटिल है, जैसा कि मैंने पहले ही कहा था। कोड निष्पादित करते समय नहीं, जैसा कि आपके उत्तर में है।
लोर्न

@ ईजेपी मैं आपकी प्रतिक्रिया की सराहना करता हूं। क्या आप कृपया सटीक लाइन बता सकते हैं जो उत्तर में गलत है। मुझे लगता है कि ऊपर लिखे सभी उत्तर वही हैं जो मैंने लिखे थे। कृपया मदद करें, मैं अपनी समझ को सही करना चाहता हूं। धन्यवाद।
जयेश

आपने पूरी प्रक्रिया के बारे में लिखा है जैसे कि यह सब तब होता है जब कोड की लाइन निष्पादित होती है, जो, जैसा कि मैंने आपको बार-बार बताया है, ऐसा नहीं है। आप अपने उत्तर में एक भी 'सटीक लाइन' के गलत होने को कम नहीं कर सकते।
लोर्न

0

जब आप एक स्ट्रिंग को स्टोर करते हैं

String string1 = "Hello";

सीधे, तब JVM दिए गए मूल्य के साथ एक स्ट्रिंग ऑब्जेक्ट बनाता है मेमोरी के एक अलग ब्लॉक के दौरान स्ट्रिंग स्थिर पूल।

और जब भी हमारे पास एक और स्ट्रिंग के रूप में प्रयास करने और उत्पन्न करने की प्रवृत्ति होती है

String string2 = "Hello";

JVM यह पुष्टि करता है कि स्थिर मूल्य के साथ कोई स्ट्रिंग वस्तु String Continuous Pool के भीतर मौजूद है, यदि ऐसा है, तो एक ब्रांड नई वस्तु बनाने के बजाय JVM नए चर के लिए मौजूदा ऑब्जेक्ट का संदर्भ प्रदान करता है।

और जब हम स्ट्रिंग को स्टोर करते हैं

String string = new String("Hello");

नए कीवर्ड का उपयोग करते हुए, दी गई कीमत के साथ एक बिलकुल नई वस्तु स्ट्रिंग स्ट्रिंग स्थिर पूल की सामग्री से कोई फर्क नहीं पड़ता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.