Java मध्ये स्ट्रिंगसह काम करण्यासाठी सुविधा वर्ग

1. StringTokenizerवर्ग

आणि आता आणखी काही सामान्य परिस्थिती ज्यामध्ये स्ट्रिंग्ससह काम करणे समाविष्ट आहे. तुम्ही स्ट्रिंगला अनेक भागांमध्ये कसे विभाजित कराल? हे करण्याचे अनेक मार्ग आहेत.

split()पद्धत

स्ट्रिंगला अनेक भागांमध्ये विभाजित करण्याचा पहिला मार्ग म्हणजे पद्धत वापरणे split(). विशिष्ट सीमांकन स्ट्रिंग परिभाषित करणारी नियमित अभिव्यक्ती वितर्क म्हणून पास करणे आवश्यक आहे. जावा मल्टीथ्रेडिंग क्वेस्टमध्ये रेग्युलर एक्सप्रेशन म्हणजे काय ते तुम्ही शिकाल .

उदाहरण:

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

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

सोपा, परंतु कधीकधी हा दृष्टीकोन अतिरेक असतो. जर तेथे बरेच परिसीमक असतील (उदाहरणार्थ, रिक्त स्थान, नवीन रेखा वर्ण, टॅब, पूर्णविराम), तर तुम्हाला त्याऐवजी जटिल नियमित अभिव्यक्ती तयार करावी लागेल. ते वाचणे कठीण आहे आणि म्हणून सुधारणे कठीण आहे.

StringTokenizerवर्ग

Java मध्ये एक विशेष वर्ग आहे ज्यांचे संपूर्ण कार्य स्ट्रिंगला सबस्ट्रिंगमध्ये विभाजित करणे आहे.

हा वर्ग रेग्युलर एक्सप्रेशन वापरत नाही: त्याऐवजी, तुम्ही डिलिमिटर असलेल्या स्ट्रिंगमध्ये पास करता. या पध्दतीचा फायदा असा आहे की तो संपूर्ण स्ट्रिंग एकाच वेळी तुकडे करत नाही, तर त्याऐवजी एका वेळी एक पायरी सुरुवातीपासून शेवटपर्यंत सरकतो.

वर्गात कन्स्ट्रक्टर आणि दोन महत्त्वाच्या पद्धती आहेत. आम्ही कन्स्ट्रक्टरला एक स्ट्रिंग पास करतो जी आम्ही भागांमध्ये विभाजित करतो आणि एक स्ट्रिंग ज्यामध्ये सीमांकित वर्णांचा संच असतो.

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$dतिसरा युक्तिवाद मिळेल, %2$dदुसरा युक्तिवाद मिळेल आणि %dपहिला युक्तिवाद मिळेल. %sआणि फॉरमॅट स्पेसिफायर्स हे किंवा %dसारख्या स्पेसिफायर्सची पर्वा न करता वितर्कांचा संदर्भ घेतात%3$d%2$s

3. स्ट्रिंग पूल

StringPoolस्ट्रिंग लिटरल म्हणून कोडमध्ये निर्दिष्ट केलेली प्रत्येक स्ट्रिंग प्रोग्राम चालू असताना मेमरीच्या क्षेत्रात संग्रहित केली जाते . StringPoolस्ट्रिंग संचयित करण्यासाठी एक विशेष अॅरे आहे. स्ट्रिंग स्टोरेज ऑप्टिमाइझ करणे हा त्याचा उद्देश आहे:

प्रथम, कोडमध्ये निर्दिष्ट केलेल्या स्ट्रिंग्स कुठेतरी संग्रहित केल्या पाहिजेत, बरोबर? कोडमध्ये कमांड्स असतात, परंतु डेटा (विशेषत: मोठ्या स्ट्रिंग्स) कोडपासून स्वतंत्रपणे मेमरीमध्ये संग्रहित करणे आवश्यक आहे. कोडमध्ये फक्त स्ट्रिंग ऑब्जेक्ट्सचे संदर्भ दिसतात.

दुसरे, सर्व समान स्ट्रिंग अक्षरे फक्त एकदाच मेमरीमध्ये संग्रहित करणे आवश्यक आहे. आणि ते फक्त कसे कार्य करते. जेव्हा तुमचा वर्ग कोड Java मशीनद्वारे लोड केला जातो, तेव्हा सर्व स्ट्रिंग लिटरल्स 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()स्ट्रिंगमध्ये जोडेल आणि मधील स्ट्रिंगचा संदर्भ देईल .StringPoolStringPool

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

तुम्ही ही पद्धत सहसा वापरण्याची शक्यता नाही, परंतु लोकांना मुलाखतींमध्ये याबद्दल विचारणे आवडते . त्यामुळे न कळण्यापेक्षा त्याबद्दल जाणून घेणे चांगले.