ஜாவாவில் சரங்களுடன் வேலை செய்வதற்கான வசதியான வகுப்புகள்

கோட்ஜிம் பல்கலைக்கழகப் பாடத்தின் ஒரு பகுதியாக வழிகாட்டியுடன் விரிவுரைத் துணுக்கு. முழு பாடத்திற்கும் பதிவு செய்யவும்.

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

"உடனே சொல்லமாட்டேன் எல்லி. ஆனா நீ சொல்றது சரியா?"

split()முறை

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

உதாரணமாக:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

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

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

StringTokenizerவர்க்கம்

கோட்ஜிம் பல்கலைக்கழகப் பாடத்தின் ஒரு பகுதியாக வழிகாட்டியுடன் விரிவுரைத் துணுக்கு. முழு பாடத்திற்கும் பதிவு செய்யவும்.

"ஜாவாவில் ஒரு சிறப்பு வகுப்பு உள்ளது, அதன் முழு வேலையும் ஒரு சரத்தை துணை சரங்களாகப் பிரிப்பதாகும்.

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

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

String nextToken()

boolean hasMoreTokens()

"இந்த வகுப்பு எப்படியோ எனக்கு ஸ்கேனர் வகுப்பை நினைவூட்டுகிறது, இதில் nextLine()முறைகளும் உள்ளன hashNextLine().

"நீங்கள் செய்த நல்ல அவதானிப்பு. StringTokenizerஇந்த கட்டளை மூலம் நீங்கள் ஒரு பொருளை உருவாக்கலாம்:

StringTokenizer name = new StringTokenizer(string, delimiters);

சரம் என்பது பகுதிகளாகப் பிரிக்கப்பட வேண்டிய சரம். மற்றும் delimiters என்பது ஒரு சரம், மேலும் அதில் உள்ள ஒவ்வொரு எழுத்தும் ஒரு delimiter ஆக கருதப்படுகிறது. உதாரணமாக:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

"கஸ்ட்ரக்டருக்கு இரண்டாவது சரத்தில் அனுப்பப்பட்ட சரத்தில் உள்ள ஒவ்வொரு எழுத்தும் StringTokenizerஒரு பிரிப்பானாகக் கருதப்படுகிறது.

String.format()முறை மற்றும் StringFormatterவகுப்பு

"ஸ்ட்ரிங் வகுப்பின் மற்றொரு சுவாரஸ்யமான முறை format().

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

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

அத்தகைய நிரலுக்கான குறியீடு இப்படி இருக்கும்:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

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

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

"ஆம், படிக்க கடினமாக இருக்கிறது!"

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

String.format

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

String name = String.format(pattern, parameters);

உதாரணமாக:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

" முறையின் முதல் அளவுரு என்பது , நீங்கள் தரவைச் செருக வேண்டிய இடங்களில், format()வடிவமைப்பு விவரக்குறிப்புகள் (போன்றவை %dமற்றும் ) எனப்படும் சிறப்பு எழுத்துகளுடன் தேவையான அனைத்து உரைகளையும் உள்ளடக்கிய ஒரு வடிவமைப்பு சரமாகும்.%s

" இந்த முறை மற்றும் வடிவமைப்பு குறிப்பான்களை அளவுரு பட்டியலில் உள்ள வடிவமைப்பு சரத்தைப் பின்பற்றும் அளவுருக்களுடன் format()மாற்றுகிறது . நாம் ஒரு சரத்தைச் செருக விரும்பினால், எழுதுகிறோம். எண்ணைச் செருக விரும்பினால், வடிவக் குறிப்பான் . எடுத்துக்காட்டு:%s%d%s%d

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

"வடிவமைப்பு சரத்திற்குள் பயன்படுத்தக்கூடிய வடிவமைப்பு குறிப்பான்களின் குறுகிய பட்டியல் இங்கே:

%s

%d

%f

%b

%c

%t

%%

"இந்த விவரக்குறிப்புகள் தரவு வகையைக் குறிக்கின்றன, ஆனால் தரவின் வரிசையைக் குறிக்கும் குறிப்பான்களும் உள்ளன. அதன் எண்ணின் மூலம் ஒரு வாதத்தைப் பெற (எண்கள் ஒன்றிலிருந்து தொடங்குகிறது), " % 1$ d " என்பதற்குப் பதிலாக " % 1$ d " என்று எழுத வேண்டும் . %d ". எடுத்துக்காட்டு:

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$d3 வது வாதத்தைப் பெறுவார், %2$dஇரண்டாவது வாதத்தைப் பெறுவார், மேலும் %dமுதல் வாதத்தைப் பெறுவார். மற்றும் வடிவமைப்பு குறிப்பான்கள் போன்ற அல்லது %sகுறிப்பிடும் %dகுறிப்பான்களைப் பொருட்படுத்தாமல் வாதங்களைக் குறிக்கிறது%3$d%2$s

சரம் குளம்

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

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

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

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

இது தோராயமாக எவ்வாறு செயல்படுகிறது என்பது இங்கே:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

"அதனால்தான் aமற்றும் bமாறிகள் ஒரே குறிப்புகளை சேமிக்கும்."

"நான் எல்லாவற்றையும் சரியாகப் புரிந்துகொண்டேன் என்று நம்புகிறேன்.

intern()முறை.

"மேலும் சிறந்த அம்சம் என்னவென்றால், நீங்கள் நிரலாக்க ரீதியாக எந்த சரத்தையும் சேர்க்கலாம் . இதைச் செய்ய, நீங்கள் மாறியின் முறையை StringPoolஅழைக்க வேண்டும் .Stringintern()

"இந்த intern()முறை சரத்தை ஏற்கனவே இல்லாவிடில் சேர்க்கும் StringPool, மேலும் StringPool.

StringPool"மேலும் இந்த முறையைப் பயன்படுத்தி இரண்டு ஒத்த சரங்களைச் சேர்த்தால் என்ன நடக்கும் intern()?"

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

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

இந்த முறையை நீங்கள் அடிக்கடி பயன்படுத்த வாய்ப்பில்லை. வேலை நேர்காணல்களில் மக்கள் அதைப் பற்றி கேட்க விரும்புகிறார்கள்.

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