జావాలో స్ట్రింగ్ పూల్ యొక్క భావన ఏమిటి?

మీరు ఈ పదం గురించి విన్నారా? 'జావాలో స్ట్రింగ్ పూల్?' బాగా, లేకపోతే, మీరు సరైన స్థలానికి వచ్చారు. జావాలోని స్ట్రింగ్ పూల్ అనేది స్ట్రింగ్స్ యొక్క కొలను హీప్ మెమరీ. కొంచెం లోతుగా త్రవ్వి, జావా స్ట్రింగ్ పూల్ యొక్క ఈ భావనను వివరంగా అర్థం చేసుకుందాం.

ఈ వ్యాసంలో క్రింది గమనికలు చర్చించబడతాయి:

• స్ట్రింగ్‌ను ఎలా సృష్టించాలి?
• జావాలో స్ట్రింగ్ పూల్ అంటే ఏమిటి?
• జావాలో స్ట్రింగ్ పూల్ ఎలా పనిచేస్తుంది?
• ప్రవాహ రేఖ చిత్రం
• స్ట్రింగ్ పూల్ కోసం జావా ప్రోగ్రామ్

ప్రారంభిద్దాం!

అన్నింటిలో మొదటిది, స్ట్రింగ్ ఆబ్జెక్ట్ ఎంత ఖచ్చితంగా సృష్టించబడిందో అర్థం చేసుకుందాం!

స్ట్రింగ్ ఎలా సృష్టించాలి?

జావాలో స్ట్రింగ్ ఆబ్జెక్ట్ సృష్టించడానికి, రెండు మార్గాలు ఉన్నాయి:

• క్రొత్త ఆపరేటర్‌ను ఉపయోగించడం. ఉదాహరణకి,

స్ట్రింగ్ s1 = కొత్త స్ట్రింగ్ ('జోయి')

• స్ట్రింగ్ అక్షర లేదా స్థిరమైన వ్యక్తీకరణను ఉపయోగించడం. ఉదాహరణకి,

స్ట్రింగ్ s1 = 'జోయి' (స్ట్రింగ్ లిటరల్) లేదా స్ట్రింగ్ s1 = 'జో' + 'వై' (స్ట్రింగ్ స్థిరమైన వ్యక్తీకరణ)

ఇప్పుడు, నేను మాట్లాడుతున్న ఈ స్ట్రింగ్ పూల్ ఏమిటి మరియు జావాలో స్ట్రింగ్ యొక్క సృష్టి దీనికి సంబంధించినది. నేను అయోమయాన్ని తగ్గించుకుందాం!

జావాలో స్ట్రింగ్ పూల్ అంటే ఏమిటి?

స్ట్రింగ్ పూల్ జావా కుప్పలో నిల్వ చేసే ప్రాంతం.

స్ట్రింగ్ కేటాయింపు, అన్నిటిలాగే వస్తువు కేటాయింపు , సమయం మరియు జ్ఞాపకశక్తి రెండింటిలోనూ ఖరీదైన వ్యవహారం అని రుజువు చేస్తుంది. పనితీరును పెంచడానికి మరియు మెమరీ ఓవర్‌హెడ్‌ను తగ్గించడానికి స్ట్రింగ్ లిటరల్‌లను ప్రారంభించేటప్పుడు JVM కొన్ని దశలను చేస్తుంది. JVM లో సృష్టించబడిన స్ట్రింగ్ వస్తువుల సంఖ్యను తగ్గించడానికి, స్ట్రింగ్ క్లాస్ తీగల కొలను ఉంచుతుంది.

స్ట్రింగ్ అక్షరాలా సృష్టించబడిన ప్రతిసారీ, ది జెవిఎం మొదట స్ట్రింగ్ అక్షర పూల్‌ను తనిఖీ చేస్తుంది. స్ట్రింగ్ పూల్‌లో స్ట్రింగ్ ఇప్పటికే ఉంటే, పూల్ చేసిన ఉదాహరణకి సూచన తిరిగి వస్తుంది. పూల్‌లో స్ట్రింగ్ లేకపోతే, క్రొత్త స్ట్రింగ్ ఆబ్జెక్ట్ ప్రారంభమవుతుంది మరియు పూల్‌లో ఉంచబడుతుంది.

సిద్ధాంతపరంగా భావనను నేర్చుకున్న తరువాత, సాధారణ సందర్భాల సహాయంతో దశలవారీగా జావాలో స్ట్రింగ్ పూల్ ఎలా పనిచేస్తుందో నేను మీకు చెప్తాను!

జావాలో స్ట్రింగ్ పూల్ ఎలా పనిచేస్తుంది?

మీరు ఇలాంటి కొత్త స్ట్రింగ్‌ను సృష్టించినప్పుడు:

స్ట్రింగ్ s1 = “రాచెల్”

అదే విలువ స్ట్రింగ్ స్థిరమైన పూల్‌లో ఉందో లేదో JVM స్వయంచాలకంగా తనిఖీ చేస్తుంది.

• అవును అయితే, ఇది ఇప్పటికే ఉన్న విలువను ఆక్రమించింది.
• లేకపోతే, అది స్వయంగా కొత్త స్ట్రింగ్‌ను సృష్టించి స్ట్రింగ్ పూల్‌కు జోడిస్తుంది.

మీరు ఈ ప్రవర్తనను ఆపాలనుకుంటే, క్రొత్త ఆపరేటర్‌ను ఉపయోగించి స్ట్రింగ్‌ను సృష్టించండి:

విజువల్ స్టూడియోలో పైథాన్ ఉపయోగించండి

స్ట్రింగ్ s1 = కొత్త స్ట్రింగ్ (“రాచెల్”)

ఇప్పుడు, మీరు ఈ స్ట్రింగ్‌ను జోడించడానికి సిద్ధంగా ఉంటే , జావా మీకు స్థానిక ఇంటర్న్ () పద్ధతిని పిలవగల ఇంటర్న్ () పద్ధతిని అందిస్తుంది:

S1.intern ()

ఇప్పుడు, స్ట్రింగ్ పూల్ యొక్క అమలు మరియు పనిని నేను ఒక ఉదాహరణ ద్వారా చూపిస్తాను.

కానీ దీనికి ముందు, ఒక చిన్న రిమైండర్!

మీరు == ఆపరేటర్ ఉపయోగించి 2 వస్తువులను పోల్చుతున్నారో మీకు తెలుసు, అది మెమరీలోని చిరునామాలను పోలుస్తుంది.

కాబట్టి మేము అదే వస్తువు లేదా కాదా అని పూర్తిగా తెలుసుకోవడానికి == ఉపయోగించి తీగలను పోల్చి చూస్తాము.

ఇప్పుడు, మా అమలు ప్రక్రియపై ఆశిద్దాం.

జావాలో స్ట్రింగ్ పూల్: ఫ్లో రేఖాచిత్రం

ఇప్పుడు ఇక్కడ ఏమి జరుగుతుందో దశలవారీగా గ్రహించండి:

• తరగతి ఎప్పుడు లోడ్ అవుతుంది ప్రారంభించబడింది.
• JVM ప్రోగ్రామ్‌లోని అన్ని స్ట్రింగ్ లిటరల్‌ల కోసం చూస్తుంది
• మొదట, ఇది 'ఆపిల్' అనే అక్షరాలా సూచించే వేరియబుల్ s1 ను కనుగొంటుంది మరియు ఇది మెమరీలో సృష్టించబడుతుంది
• 'ఆపిల్' అనే అక్షరానికి సూచన స్ట్రింగ్ స్థిరమైన పూల్ మెమరీలో ఉంచబడుతుంది.
• అప్పుడు అదే వేరియబుల్ s2 ను కనుగొంటుంది, ఇది అదే స్ట్రింగ్ సాహిత్య “మామిడి” ని సూచిస్తుంది.
• అప్పుడు ఇది అక్షరాలా “ఆపిల్” ను సూచించే మరొక వేరియబుల్ ఎస్ 3 ను కనుగొంటుంది
• ఇప్పుడు JVM ఇప్పటికే “ఆపిల్” అనే స్ట్రింగ్‌ను కనుగొంది, s1 మరియు s3 వేరియబుల్స్ రెండూ ఒకే వస్తువును సూచిస్తాయి, అంటే “ఆపిల్”.

స్ట్రింగ్ పూల్ కోసం జావా ప్రోగ్రామ్

పబ్లిక్ క్లాస్ స్ట్రింగ్పూల్ ఎక్స్పెరిమెంట్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {స్ట్రింగ్ s1 = 'రాచెల్' స్ట్రింగ్ s2 = 'రాచెల్' స్ట్రింగ్ s3 = కొత్త స్ట్రింగ్ ('రాచెల్') స్ట్రింగ్ s4 = కొత్త స్ట్రింగ్ ('రాచెల్'). ఇంటర్న్ ( ) System.out.println (s1 == s2) // true System.out.println (s1 == s3) // తప్పుడు System.out.println (s1 == s4) // true}}

అవుట్పుట్:

నిజం
తప్పుడు
నిజం

పై ఉదాహరణలో, మీరు స్ట్రింగ్ ప్రారంభించడం యొక్క ఉపయోగాన్ని మూడు విధాలుగా స్పష్టంగా చూడవచ్చు

స్ట్రింగ్ s1 = 'రాచెల్' స్ట్రింగ్ s2 = 'రాచెల్' స్ట్రింగ్ s3 = కొత్త స్ట్రింగ్ ('రాచెల్') స్ట్రింగ్ s4 = కొత్త స్ట్రింగ్ ('రాచెల్'). ఇంటర్న్ ()

ప్రోగ్రామ్ యొక్క అంతర్గత పని బహుశా ఇప్పుడు స్పష్టంగా ఉండాలి.

దీనితో, నేను నా బ్లాగ్ చివరికి చేరుకున్నాను. మీ జ్ఞాన స్థావరాన్ని విస్తృతం చేయడంలో ఇక్కడ వివరించిన విషయాలు మీకు సహాయపడ్డాయని నేను ఆశిస్తున్నాను. మేము జావా ప్రపంచంలోకి డైవింగ్ చేస్తూనే ఉంటాము. వేచి ఉండండి!

చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. జావా ప్రోగ్రామింగ్‌లోకి మీకు మంచి ప్రారంభాన్ని ఇవ్వడానికి మరియు హైబర్నేట్ & వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి ఈ కోర్సు రూపొందించబడింది. వసంత .

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలోని స్ట్రింగ్ పూల్” బ్లాగులోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.