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

1. StringTokenizerவர்க்கம்

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

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);

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

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பிரிப்பானாகக் கருதப்படுகிறது.

2. 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.}");

அத்தகைய குறியீடு மிகவும் படிக்கக்கூடியதாக இல்லை. மாறி பெயர்கள் நீளமாக இருந்தால், குறியீடு இன்னும் கடினமாகிவிடும்:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

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

மிகவும் படிக்க முடியவில்லை, இல்லையா?

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

String.format

சரம் வகுப்பில் ஒரு நிலையான 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%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

3. சரம் குளம்

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

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

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

அதன்படி, உங்கள் குறியீட்டில் உள்ள பல மாறிகளுக்கு ஒரே எழுத்தை ஒதுக்கினால் String, இந்த மாறிகள் ஒரே குறிப்பைக் கொண்டிருக்கும். ஒரே ஒரு முறைக்கு ஒரு எழுத்து சேர்க்கப்படும் 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. Stringஇதைச் செய்ய, நீங்கள் மாறியின் முறையை அழைக்க வேண்டும் intern().

இந்த 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

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