జావాలో, ' ఇంటర్న్ () పెద్ద మొత్తంలో స్ట్రింగ్ డేటాను నిల్వ చేస్తే, అదే మూలకం ఉన్న స్ట్రింగ్‌లు ఒకే మెమరీని పంచుకునేలా చేయడానికి ” పద్ధతి ఉపయోగించబడుతుంది. ప్రోగ్రామ్ కోసం మెమరీ స్థలాన్ని తగ్గించడానికి ఈ పద్ధతి చాలా ఉపయోగకరంగా ఉంటుంది. ఉదాహరణకు, మీరు ఉద్యోగుల పేర్ల యొక్క భారీ జాబితాను కలిగి ఉంటే పేరు ' జాక్ ” అని పదిసార్లు కనిపిస్తుంది. ది ' ఇంటర్న్ () 'పద్ధతి నిర్ధారిస్తుంది' జాక్ ” మెమరీలో ఒకే ఒక్క ఖాళీని మాత్రమే ఆక్రమిస్తుంది.
ఈ పోస్ట్ జావాలో String.intern() పద్ధతి యొక్క వినియోగాన్ని చర్చిస్తుంది.
జావాలో String.intern() అంటే ఏమిటి?
ది ' ఇంటర్న్ () ”జావాలోని పద్ధతి పేర్కొన్న స్ట్రింగ్ ఆబ్జెక్ట్‌కు సూచనను తిరిగి ఇవ్వడానికి ఉపయోగించబడుతుంది. అయినప్పటికీ, స్ట్రింగ్ పూల్‌లో అదే కంటెంట్/డేటాతో స్ట్రింగ్ ఆబ్జెక్ట్ ఉంటే, అది మునుపటి స్ట్రింగ్ సూచనను అందిస్తుంది. ఇంకా, స్ట్రింగ్ పూల్‌లో స్ట్రింగ్ ఉనికిలో లేకుంటే అది కొత్త స్ట్రింగ్‌ను మరియు స్ట్రింగ్ పూల్‌కు దాని సూచనను జోడిస్తుంది.
వాక్యనిర్మాణం
పేర్కొన్న పద్ధతిని ఉపయోగించడానికి, క్రింద ఇవ్వబడిన వాక్యనిర్మాణాన్ని అనుసరించండి:
స్ట్రింగ్ . ఇంటర్న్ ( )
ఈ ఉదాహరణలో, ''ని ఎందుకు ఉపయోగించాల్సిన అవసరం ఉందో మేము చర్చిస్తాము. ఇంటర్న్ () జావాలో “పద్ధతి”ని ఉపయోగించి ఒక కుప్పలో స్ట్రింగ్ సృష్టించబడినప్పుడు స్ట్రింగ్() ”నిర్మాణకర్త. మొదట, స్ట్రింగ్ ఆబ్జెక్ట్ 'ని ఉపయోగించి సృష్టించబడుతుంది స్ట్రింగ్() ”నిర్మాణకర్త. ఆ తర్వాత, స్ట్రింగ్ కోసం డేటా ఈ వస్తువుకు పారామీటర్‌గా పంపబడుతుంది మరియు వేరియబుల్లో నిల్వ చేయబడుతుంది:
స్ట్రింగ్ a = కొత్త స్ట్రింగ్ ( 'Linuxhintకి స్వాగతం.' ) ;
అదే విధానాన్ని అనుసరించడం ద్వారా మరొక స్ట్రింగ్ ఆబ్జెక్ట్ సృష్టించబడుతుంది:
స్ట్రింగ్ బి = కొత్త స్ట్రింగ్ ( 'Linuxhint కు స్వాగతం' ) ;'ని పిలవండి println()” పద్ధతి మరియు సెట్ “a=b ” ఈ పద్ధతికి వాదనగా. ప్రతి స్ట్రింగ్ మెమరీలో దాని స్వంత స్థలాన్ని కలిగి ఉన్నందున ఇది ఫలితాన్ని తప్పుగా అందిస్తుంది:
వ్యవస్థ . బయటకు . println ( a == బి ) ;
పైన పేర్కొన్న ఉదాహరణ యొక్క అవుట్‌పుట్ తప్పుగా ఉందని గమనించవచ్చు:
ఉదాహరణ 1: String.intern() స్ట్రింగ్ ఆబ్జెక్ట్‌లను తనిఖీ చేసే విధానం
ఈ ఉదాహరణలో, '' ఉపయోగించి రెండు స్ట్రింగ్ వస్తువులు సృష్టించబడతాయి స్ట్రింగ్() ” కన్స్ట్రక్టర్ మరియు స్ట్రింగ్ కన్స్ట్రక్టర్‌కు ఆర్గ్యుమెంట్‌గా పంపబడుతుంది. తరువాత, 'ని పిలవండి ఇంటర్న్ () 'ప్రతి స్ట్రింగ్ కోసం పద్ధతి మరియు మొదటి స్ట్రింగ్‌ను వేరియబుల్లో నిల్వ చేయండి' a 'మరియు' లో రెండవది బి ”. పరిస్థితిని తనిఖీ చేయండి' a=b 'మరియు' ఉపయోగించండి println() ” ఫలితాన్ని ప్రదర్శించడానికి:
స్ట్రింగ్ a = కొత్త స్ట్రింగ్ ( 'Linuxhint కు స్వాగతం' ) . ఇంటర్న్ ( ) ;స్ట్రింగ్ బి = కొత్త స్ట్రింగ్ ( 'Linuxhint కు స్వాగతం' ) . ఇంటర్న్ ( ) ;
వ్యవస్థ . బయటకు . println ( a == బి ) ;
ఫలితంగా, ఇది ' నిజం 'విలువ ఎందుకంటే' ఇంటర్న్ () ” పద్ధతి స్ట్రింగ్ డేటాను నిల్వ చేయడానికి ప్రతి స్ట్రింగ్ ఒకే మెమరీలో స్థలాన్ని ఆక్రమించిందని నిర్ధారిస్తుంది:
ఉదాహరణ 2: String.intern() స్ట్రింగ్ మరియు స్ట్రింగ్ ఆబ్జెక్ట్‌ని తనిఖీ చేసే విధానం
ఈ పేర్కొన్న ఉదాహరణలో, వివిధ స్ట్రింగ్‌లు వేర్వేరు వేరియబుల్స్‌లో సృష్టించబడతాయి మరియు నిల్వ చేయబడతాయి. ఈ ప్రయోజనం కోసం, ముందుగా, ఒక వేరియబుల్ స్ట్రింగ్ విలువతో ప్రారంభించబడుతుంది ' Linux ”:
స్ట్రింగ్ a = 'Linux' ;'ని ఉపయోగించండి ఇంటర్న్ () స్ట్రింగ్‌ని యాక్సెస్ చేయడం ద్వారా పద్ధతి a 'మరియు దానిని వేరియబుల్లో నిల్వ చేయండి' బి ”:
స్ట్రింగ్ బి = a. ఇంటర్న్ ( ) ;'' సహాయంతో కొత్త స్ట్రింగ్-రకం వస్తువు సృష్టించబడింది స్ట్రింగ్() 'కన్స్ట్రక్టర్ మరియు పాస్లు' Linux ” ఈ కన్స్ట్రక్టర్‌కి పారామీటర్‌గా. అప్పుడు, దానిని వేరియబుల్లో నిల్వ చేయండి ' సి ”:
స్ట్రింగ్ సి = కొత్త స్ట్రింగ్ ( 'Linux' ) ;
'ని పిలవండి ఇంటర్న్ () 'వేరియబుల్ యాక్సెస్ చేయడం ద్వారా పద్ధతి' సి 'మరియు ఫలితాన్ని 'లో నిల్వ చేయండి డి ”:
స్ట్రింగ్ డి = సి. ఇంటర్న్ ( ) ;ఇప్పుడు, ఈ సృష్టించిన తీగలను ఒకదానితో ఒకటి సరిపోల్చండి. ఆ ప్రయోజనం కోసం, ' println() ” పద్ధతి మరియు దిగువ కోడ్ స్నిప్పెట్ ప్రకారం పరామితిని పాస్ చేయండి:
వ్యవస్థ . బయటకు . println ( a == బి ) ;వ్యవస్థ . బయటకు . println ( a == సి ) ;
వ్యవస్థ . బయటకు . println ( a == డి ) ;
వ్యవస్థ . బయటకు . println ( బి == సి ) ;
వ్యవస్థ . బయటకు . println ( బి == డి ) ; వ్యవస్థ . బయటకు . println ( సి == డి ) ;
ప్రతి సంబంధిత స్టేట్‌మెంట్ యొక్క అవుట్‌పుట్ కన్సోల్‌లో ముద్రించబడుతుంది. మేము ప్రతి స్టేట్‌మెంట్‌తో అవుట్‌పుట్‌ను మ్యాప్ చేసాము:
జావాలోని string.intern() పద్ధతి గురించి అంతే.
ముగింపు
ది ' String.intern() ” జావాలోని పద్ధతి పేర్కొన్న స్ట్రింగ్ ఆబ్జెక్ట్‌కు సూచనను అందిస్తుంది. అయినప్పటికీ, స్ట్రింగ్ పూల్‌లో అదే కంటెంట్/డేటాతో స్ట్రింగ్ ఆబ్జెక్ట్ ఉంటే, అది మునుపటి స్ట్రింగ్ సూచనను అందిస్తుంది. ఈ పోస్ట్ జావాలో String.intern() పద్ధతి యొక్క వివిధ ఉపయోగ సందర్భాలను పేర్కొంది.