String Constant Pool in Java in Hindi

Last Updated on October 31, 2021 by RAJENDRAPRASAD

String Constant Pool in Java in Hindi – Hello दोस्तों rajhindime.in में आपका स्वागत है |

दोस्तों, पिछले पोस्ट String in Java in Hindi में आपने String, तथा String object को कैसे create करें, इस बारे में  में विस्तृत जानकारी प्राप्त की |

आज के इस पोस्ट में आप String Constant Pool in Java के बारे में विस्तार से जानेंगे |

दोस्तों जैसा कि आप जानते हो कि, String  यह और कुछ नहीं बल्कि Characters का sequence है | चूँकि, String object यह Java में सबसे ज्यादा use होने वाला class है | इसलिए Java में इसके memory allocation को एक special तरीके से handle किया जाता है, जिसमे String Constant Pool एक important role निभाता है |

String Constant Pool के बारे में विस्तार से जाने, इससे पहले आइए जाने, इसकी जरुरत क्यों पड़ी |

Need of String Constant Pool

इसकी जरुरत को समझने के लिए, Voter ID form का example लेते हैं |

Voter ID form में बहुत सारे fields भरने होते हैं, आइए उन fields के data types को समझें |

जैसा कि आपने देखा, यहाँ maximum data type String ही use हुआ है | मान लो, ये सारे form हम किसी particular district, जैसे Mumbai के लिए भर रहे हैं, इस स्थिति में सारे voter के district same ही होगें |

मान लो Mumbai में कुल 1 करोड़ लोग हैं | इस स्थिति में अगर हर voter के district के लिए अगर अलग-अलग  String object create हुआ तो कम से कम 1 करोड़ create होगा, जबकि सब के लिए district Mumbai ही है |

इस तरह यहाँ same data के लिए भी बहुत सारी memory का use हो रहा है, इससे memory पर load बढ़ता है जिससे application के performance slow होने के साथ ही साथ cost भी बढ़ जाता है |

इसी memory load को minimize / optimize /handle करने के लिए String Constant Pool को अस्तित्त्व में लाया गया |

String Constant Pool (SCP):

यह एक special memory area है, जो Java के heap memory का part है | String Constant Pool में duplicate value store नहीं होते |

By default यह empty तथा Java String class द्वारा privately maintain किया जाता है |

हम जब भी String  create करते हैं, तब String object कुछ space heap memory में घेर लेते हैं अर्थात occupy करते हैं | इसी तरह बहुत सारे String create करने पर, यह बहुत सारी memory occupy कर सकते हैं, जिससे performance काम हो जाता है साथ ही साथ cost भी बढ़ जाता है |

इस कमी को पूरा करने के लिए String initialization के दौरान, JVM कुछ steps perform करता है, जिससे performance भी improve होता है साथ ही साथ memory पर load भी कम होता है |

String creation के दौरान object के count को कम करने के लिए, JVM String Constant Pool का use करता है |

जब भी हम कोई String leteral declare करते हैं तब, JVM एक object SCP में create करता है, और उसका reference stack memory में store करता है |

SCP में create किये गए object का मुख्य purpose (उद्देश्य) reusability होता है, जिसे आवश्यकतानुसार बार- बार use किया जा सकता है |

जब भी हम कोई String variable create करते हैं और उसे कोई value assign करते हैं तब, सबसे पहले JVM, String Constant Pool में देखता है कि वह value वहाँ पर already available है या नहीं |

अगर वही same value SCP में already available है, उस स्थिति में, JVM कोई नया object create नहीं करके, केवल उस object का reference return करता है | और यदि वही same value SCP में न हो तभी वो, SCP में नया object create करेगा |

आइए इसे example द्वारा समझते हैं |

Voter ID के example में हम सबसे पहले, Mr. Ram का form भरते हैं |

String distrinct_Ram = “Mumbai”;

यहाँ JVM  सबसे पहले SCP में देखेगा कि वहाँ “Mumbai” leteral पहले से store है या नहीं | चूँकि, initially SCP में कोई value नहीं होती, अब JVM एक object create करेगा जिसकी value “Mumbai”  है |

अब Mr. Shyam के लिए हम,

String distrinct_Shyam = “Mumbai”; लिखते हैं |

यहाँ JVM सबसे पहले SCP में देखेगा कि वहाँ “Mumbai” leteral पहले से store है या नहीं |

चूँकि इस बार SCP में value “Mumbai” already available है | इस स्थिति में JVM , SCP में कोई भी नया object नहीं create करेगा, केवल उसका reference return करेगा |

इसी तरह Mumbai के सभी Voters जो की हमारे example में 1 करोड़ हैं, उनके लिए String district के लिए SCP में केवल और केवल एक ही object create हुआ, जिसे सारे Voters ने बार-बार use किया |

इसी तरह आपने देखा कि, जहाँ हमें सारे Voters के district के लिए 1 करोड़ object बनाने पड़ते थे, वहाँ SCP के सहायता से केवल एक ही object में काम हो गया, और बहुत सारी memory बच गयी |

Non-premitive data type में आपने जाना कि, जब बह हम कोई object create करते हैं तब, उसके reference variable, Stack memory में तथा object की value heap memory में store होती है |

आइए समझे, SCP के case में memory allocation कैसे होता है |

Memory allocation in String Constant Pool

आपने String in Java इस post में जाना कि, String को हम दो प्रकार से declare करते हैं | पहला direct अर्थात बिना new keyword के तथा दूसरा new keyword का use करके |

आइए, दोनों ही स्थिति में SCP का समझें |

1. String literal का use करके (without using new keyword)

इस स्थिति में maximum एक तथा minimum zero object create होंगे |

हम जब-जब direct String declare करेंगे, तब-तब केवल एक ही object SCP में create होगा, यदि declared value SCP में पहले से नहीं होगा तब |

String district_Ram = “Mumbai”;

2. new keyword का use करके

इस स्थिति में maximum दो तथा minimum एक object create होगा |

हम, जब-जब new keyword का use करके String declare करेंगे, तब-तब एक object हमेशा Heap memory में create होगा तथा केवल एक object SCP में create होगा यदि declared value पहले से SCP में न हो तब |

String district_Ram = new String (“Mumbai”);

Program 1:

public class StringConstantpoolDemo1 {
	
	public static void main(String[] args) {
		
		String district_Ram = "Mumbai";
		String district_Shyam = "Mumbai";

		if (district_Ram == district_Shyam)
			System.out.println("Yes");
		else
			System.out.println("No");
	}
}

Output:

Yes

Explanation:

उपर लिखे program 1 में district_Ram तथा district_Shyam दोनों एक ही object Mumbai को access करते हैं, इसलिए output “Yes” ,मिला |

Program 2:

public class StringConstantpoolDemo1 {
	
	public static void main(String[] args) {
		
		String district_Ram = new String ("Mumbai");
		String district_Shyam = new String ("Mumbai");

		if (district_Ram == district_Shyam)
			System.out.println("Yes");
		else
			System.out.println("No");
	}
}

Output:

No

Explanation:

उपर लिखे program 2 में district_Ram तथा district_Shyam दोनों, दो अलग-अलग  object Mumbai को access करते हैं, इसलिए output “No” ,मिला |

Program 3:

public class StringConstantpoolDemo1 {
	
	public static void main(String[] args) {
		
		String district_Ram = "Mumbai";
		String district_Shyam = "Mumbai";
		String district_Laxman = new String ("Mumbai");

		System.out.println((district_Ram == district_Shyam)+", String are equal."); // true  
		System.out.println((district_Ram == district_Laxman)+", String are not equal."); // false  
	}
}

Output:

true, String are equal.
false, String are not equal.

Explanation:

उपर लिखे program 3 में district_Ram और district_Shyam दोनों, एक ही object Mumbai को access करते हैं, जो कि SCP में create हुआ है, तथा district_Laxman एक अलग object Mumbai को access कर रहा है, जो कि heap memory में create हुआ है |

Program 4:

public class StringConstantpoolDemo1 {
	
	public static void main(String[] args) {
		
		String district_Ram = "Mumbai";
		String district_Shyam = "Mumbai";
		String district_Laxman = new String ("Mumbai");
		String district_Sita = new String ("Mumbai").intern();

		System.out.println((district_Ram == district_Shyam)+", String are equal."); // true  
		System.out.println((district_Ram == district_Laxman)+", String are not equal."); // false  
		System.out.println((district_Ram == district_Sita)+", String are equal."); // true
		System.out.println((district_Laxman == district_Sita)+", String are not equal."); // false
	}
}

Output:

true, String are equal.
false, String are not equal.
true, String are equal.
false, String are not equal.

Explanation:

उपर के सभी programs में आपने देखा कि, जब भी हम new keyword का use करते हैं, तब एक object heap memory में जरूर create होता है |

new keyword के इस feature को हम String.intern() method का use करके stop कर सकते हैं |

String.intern() method, String object को SCP में create करता है, यदि वह String value पहले से SCP में available न हो | और यदि वह value, SCP में पहले से ही available हो तब उस object का reference return करता है, जैसा कि बिल्कुल direct String creation के case में होता है |

इसका अर्थ यह है कि,

String district_Ram = “Mumbai”; 
String district_Sita = new String (“Mumbai”).intern();

दोनों का internal memory allocation एक ही तरह का होता है |

Conclusion – आज आपने क्या सीखा

इस post में आपने जाना कि, कैसे String Constant Pool का use करके JVM तथा Java compiler, String object के memory allocation को optimize करते हैं |

आशा है कि, आपको मेरा यह Blog String Constant Pool in Java in Hindi जरूर पसंद आया होगा |

अगर आप इस post से related कोई सवाल पूँछना चाहते हैं अथवा कोई सुझाव देना चाहते हैं तो comment करके जरूर बताएं, मैं उसका reply जरूर दूँगा |

इस post को अपना कीमती समय देने के लिए बहुत बहुत धन्यवाद् | फिर मिलेंगें |