சரத்தின் உள் செயல்பாடுகள் மற்றும் சப்ஸ்ட்ரிங் முறை

"ஹாய், அமிகோ!"

"ஹாய், எல்லி."

"சப்ஸ்ட்ரிங்ஸைப் பற்றி நான் உங்களுக்குச் சொல்லப் போகிறேன். ஒரு சப்ஸ்ட்ரிங் என்பது ஒரு சரத்தின் ஒரு பகுதியாகும். மேலும் சரங்களில் செய்யப்படும் பொதுவான செயல்பாடு (பல சரங்களை ஒன்றாக இணைத்த பிறகு) ஒரு சப்ஸ்ட்ரிங்கைப் பெறுவது."

7) சரத்தின் ஒரு பகுதியை நான் எவ்வாறு பெறுவது?

"சப்ஸ்ட்ரிங் முறை ஒரு சரத்தின் ஒரு பகுதியை வழங்குகிறது. இந்த முறை இரண்டு பதிப்புகளைக் கொண்டுள்ளது."

"முதல் பதிப்பு தொடக்கம் மற்றும் முடிவு குறியீடுகளால் குறிப்பிடப்பட்ட துணைச்சரத்தை வழங்குகிறது. ஆனால் இறுதி குறியீட்டில் உள்ள எழுத்து சேர்க்கப்படவில்லை! நீங்கள் எண்கள் 1 மற்றும் 3 ஐக் கடந்தால், துணைச்சரத்தில் இரண்டாவது மற்றும் மூன்றாவது எழுத்துகள் மட்டுமே இருக்கும் (குறியீடுகள் தொடங்குவதை நினைவில் கொள்க. 0 உடன்)."

"இரண்டாவது பதிப்பு, அனுப்பப்பட்ட குறியீட்டிலிருந்து தொடங்கி சரத்தின் இறுதி வரை சப்ஸ்ட்ரிங்கை வழங்குகிறது."

String substring(int beginIndex, int endIndex)

String s = "Good news, everyone!";
s = s.substring(1,6);

s == "ood n";

String substring(int beginIndex)

String s = "Good news, everyone!";
s = s.substring(1);

"அது போதும். நன்றி, எல்லி."

"ஸ்ட்ரிங் பொருள்களின் உள் செயல்பாடுகளையும் நான் உங்களுக்கு விளக்கப் போகிறேன்."

"உங்களுக்கு ஏற்கனவே தெரியும், சரம் என்பது ஒரு மாறாத வகுப்பு. அது நமக்கு என்ன நன்மைகளைத் தருகிறது? அது நடக்கும் போது, ​​முக்கிய நன்மைகளில் ஒன்று, ஒரு சப்ஸ்ட்ரிங்கைப் பெறும் திறன் ஆகும். ஆனால் முதலில் முதல் விஷயம்."

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

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

"ஆனால், ஒரு புதிய எழுத்து வரிசைக்கான குறிப்பைச் சேமிப்பதற்குப் பதிலாக, பொருள் பழைய வரிசைக்கான குறிப்பையும், அதனுடன் தொடர்புடைய அசல் எழுத்து வரிசையின் பகுதியைத் தீர்மானிக்கப் பயன்படுத்தும் இரண்டு மாறிகளையும் சேமிக்கிறது."

"எனக்கு அது எதுவும் புரியவில்லை."

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

"பாருங்கள்:"

String s = "mama";

char[] value = {'m','a','m','a'};
offset = 0;
count = 4;

String s2 = s.substring(1);

char[] value = {'m','a','m','a'};
offset = 1;
count = 3;

String s3 = s.substring(1, 3);

char[] value = {'m','a','m','a'};
offset = 1;
count = 2;

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

"அது இப்போது புரிகிறது."

"எனவே, நீங்கள் 10,000 எழுத்துக்கள் நீளமுள்ள ஒரு சரத்தை எடுத்து, எந்த நீளத்திலும் 10,000 துணைச்சரங்களை உருவாக்கினால், இந்த சப்ஸ்ட்ரிங்ஸ் மிகக் குறைந்த நினைவகத்தைப் பயன்படுத்தும், ஏனெனில் எழுத்து வரிசை நகலெடுக்கப்படவில்லை. இந்த சரங்கள், நீங்கள் அதிகம் பயன்படுத்த எதிர்பார்க்கலாம். இடம், இரண்டு பைட்டுகளை மட்டுமே எடுக்கும்."

"கூல்!"

"ஆனால் நீங்கள் சரங்களை மாற்றியமைத்தால் அதைச் செய்ய முடியுமா?"

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

"உங்களுக்குப் பிடித்ததில் மகிழ்ச்சி."