சரம் கட்டுபவர்

"வாழ்த்துக்கள், அமிகோ!"

"ஹலோ ரிஷி!"

"சுவாரஸ்யமான ஒன்றைக் கற்றுக்கொள்வதற்கான சரங்களைப் பற்றி நீங்கள் இப்போது போதுமான அளவு அறிந்திருக்கிறீர்கள். மேலும் குறிப்பாக, சரம் வகுப்பைப் போலவே, ஆனால் சரியாகப் பொருந்தாத ஒரு புதிய வகுப்பு."

"சாதாரண சரங்கள் எவ்வாறு குறைகின்றன மற்றும் பிற சரம் போன்ற வகுப்புகள் ஏன் தேவைப்படுகின்றன என்பது எனக்கு முற்றிலும் தெளிவாகத் தெரியவில்லை என்றாலும் புதிராகத் தெரிகிறது."

"ஜாவாவில் சரங்கள் மாறாத பொருள்கள் என்பதில் இருந்து ஆரம்பிக்கலாம்."

"அது எப்படி? நான் மறந்துவிட்டேன் ... அல்லது நான் தொடங்குவது தெரியாது ..."

"மாறாத பொருள்கள், அவை உருவாக்கப்பட்ட பிறகு அதன் நிலைகளை மாற்ற முடியாதவை என்பதை நான் உங்களுக்கு நினைவூட்டுகிறேன்."

"ஆஹா... ஜாவாவில் சரங்கள் ஏன் மாறாமல் இருக்கின்றன?"

"இது சரம் வகுப்பை மிகவும் உகந்ததாக்குவதற்கும், எல்லா இடங்களிலும் பயன்படுத்தப்படுவதற்கும் இது செய்யப்பட்டது. எடுத்துக்காட்டாக, ஹாஷ்மேப் சேகரிப்பில் மாறாத வகைகள் மட்டுமே விசைகளாகப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது .

"இருப்பினும், ப்ரோகிராமர்கள் ஸ்ட்ரிங் கிளாஸ் மாறக்கூடியதாக இருப்பதை மிகவும் வசதியாகக் காணும் சூழ்நிலைகள் அடிக்கடி எழுகின்றன. ஒவ்வொரு முறையும் அதன் முறைகளில் ஒன்று அழைக்கப்படும்போது புதிய சப்ஸ்ட்ரிங்கை உருவாக்காத வகுப்பை அவர்கள் விரும்புகிறார்கள்."

"ஆனால் அது எதற்கு நல்லது?"

"சரி, எங்களிடம் மிகப் பெரிய சரம் உள்ளது என்று வைத்துக்கொள்வோம், அதன் முடிவில் எதையாவது அடிக்கடி சேர்க்க வேண்டும். இந்த விஷயத்தில், எழுத்துக்களின் ( ArrayList<Character>) தொகுப்பு கூட சரம் பொருள்களை மீண்டும் உருவாக்குவதையும் இணைப்பதையும் விட திறமையானதாக இருக்கும்."

"அதனால்தான் சரம் வகுப்பில் இல்லாத சரங்கள் தேவையா?"

"சரியாக. ஜாவா மொழி மாற்றக்கூடிய சரம் போன்ற வகையைச் சேர்த்துள்ளது. அது StringBuilder"என்று அழைக்கப்படுகிறது.

ஒரு பொருளை உருவாக்குதல்

StringBuilder" தற்போதுள்ள சரத்தின் அடிப்படையில் ஒரு பொருளை உருவாக்க , நீங்கள் ஒரு அறிக்கையை இயக்க வேண்டும்:

StringBuilder name = new StringBuilder(string);

"வெற்று மாறக்கூடிய சரத்தை உருவாக்க, நீங்கள் இது போன்ற ஒரு அறிக்கையைப் பயன்படுத்த வேண்டும்:

StringBuilder name = new StringBuilder();

முறைகளின் பட்டியல்

" StringBuilderவகுப்பில் இரண்டு டஜன் பயனுள்ள முறைகள் உள்ளன. இங்கே மிக முக்கியமானவை:

StringBuilder append(obj)

StringBuilder insert(int index, obj)

StringBuilder replace(int start, int end, String str)

StringBuilder deleteCharAt(int index)

StringBuilder delete(int start, int end)

int indexOf(String str, int index)

int lastIndexOf(String str, int index)

char charAt(int index)

String substring(int start, int end)

StringBuilder reverse()

void setCharAt(int index, char)

int length()

"இப்போது நான் இந்த முறைகள் ஒவ்வொன்றையும் உங்களுக்கு சுருக்கமாக விவரிக்கிறேன்.

ஒரு சரத்தில் சேர்க்கிறது

"மாற்றக்கூடிய சரத்தில் ( StringBuilder) எதையாவது சேர்க்க, append()முறையைப் பயன்படுத்தவும். எடுத்துக்காட்டு:

StringBuilder builder = new StringBuilder("Hi");
builder.append("Bye");
builder.append(123);

நிலையான சரத்திற்கு மாற்றுகிறது

"ஒரு பொருளை ஒரு சரம் பொருளாக மாற்ற , நீங்கள் அதன் முறையை StringBuilderஅழைக்க வேண்டும் . எடுத்துக்காட்டுtoString()

StringBuilder builder = new StringBuilder("Hi");
builder.append(123);
String result = builder.toString();
System.out.println(result);

ஒரு எழுத்தை எப்படி நீக்குவது?

"மாற்றக்கூடிய சரத்தில் உள்ள எழுத்தை நீக்க, நீங்கள் deleteCharAt()முறையைப் பயன்படுத்த வேண்டும். எடுத்துக்காட்டு:

StringBuilder builder = new StringBuilder("Hello");
builder.deleteCharAt(2);
String result = builder.toString();
System.out.println(result);

ஒரு சரத்தின் ஒரு பகுதியை மற்றொரு சரத்துடன் மாற்றுவது எப்படி?

"இதற்கு ஒரு replace(int begin, int end, String str)முறை உள்ளது. உதாரணம்:

StringBuilder builder = new StringBuilder("Mellow");
builder.replace(2, 5, "Hello!");
String result = builder.toString();
System.out.println(result);

"வசதியாக இருக்கிறது. நன்றி, ரிஷி."

"அதைக் குறிப்பிட வேண்டாம். இது எப்படி, ஒரு சரத்தை பின்னோக்கி புரட்ட முடியுமா? அதை எப்படி செய்வீர்கள்?"

"சரி... நான் ஒரு சரத்தை உருவாக்குவேன் StringBuilder, அதில் ஒரு சரத்தை வைப்பேன்... பிறகு ஒரு புதிய சரத்தை உருவாக்கி, கடைசி எழுத்திலிருந்து முதல் எழுத்துக்கு ஒரு லூப்பில்... அல்லது பிட்வைஸ் ஷிப்ட்...

"மோசமாக இல்லை. ஆனால் அது வேகமாக இருக்கலாம். இதைச் செய்வதற்கு ஒரு சிறப்பு முறை உள்ளது - reverse();எடுத்துக்காட்டு:

String str = "Hello";
StringBuilder builder = new StringBuilder(str);
builder.reverse();
String result = builder.toString();
System.out.println(result);

"வகுப்பைத் தவிர , StringBuilderஜாவாவில் மற்றொரு சரம் போன்ற வகுப்பு StringBufferஉள்ளதுStringBuildersynchronized

"அதற்கு என்ன பொருள்?"

StringBuffer" ஒரே நேரத்தில் பல நூல்களில் இருந்து பொருளை அணுக முடியும் என்பதே இதன் பொருள் ."

"எனக்கு இன்னும் இழைகள் பற்றி அதிகம் பரிச்சயம் இல்லை. ஆனால் 'பல திரிகளில் இருந்து அணுக முடியாது' என்பதை விட 'பல திரிகளில் இருந்து அணுகலாம்' என்பது தெளிவாக உள்ளது... பிறகு ஏன் எப்போதும் பயன்படுத்தக்கூடாது? StringBuffer"

"ஏனெனில் இது மிகவும் மெதுவாக உள்ளது . ஜாவா மல்டித்ரெடிங்StringBuilder தேடலில் மல்டித்ரெடிங்கை நீங்கள் தீவிரமாக ஆராயத் தொடங்கும் போது உங்களுக்கு அத்தகைய வகுப்பு தேவைப்படலாம் .

"எதிர்காலத்திற்காக" என்று குறிக்கப்பட்டதை மறக்காமல் இருக்க என் நினைவாக எழுதுகிறேன்.