Apache Commons कडून StringUtils वर्ग

StringUtils चा परिचय

StringUtils हा सर्वात जास्त वापरला जाणारा Apache Commons वर्ग आहे. यात विविध उपयुक्तता आणि पद्धती आहेत ज्या विकसकांना मूलभूत ऑपरेशन्ससाठी बॉयलरप्लेट किंवा फक्त अनावश्यक कोड लिहिणे टाळण्यास मदत करतात.

StringUtils क्लासमधील बर्‍याच पद्धतींमध्ये त्यांचे java.lang.String समतुल्य आहेत परंतु, java.lang.String पद्धतींच्या विपरीत , शून्य-सुरक्षित आहेत. याचा अर्थ असा की NullPointerException सर्वात अनपेक्षित क्षणी टाकला जात नाही .

Apache Commons मध्ये अनेक पद्धतींचा समावेश आहे आणि आम्ही सर्वात सामान्यतः वापरल्या जाणार्‍या काही पद्धती पाहू.

StringUtils पद्धतींची यादी:

StringUtils.isEmpty() आणि StringUtils.isBlank()

स्ट्रिंगमध्ये कोणताही मजकूर आहे की नाही हे तपासण्यासाठी दोन्ही पद्धती वापरल्या जातात. जर स्ट्रिंग खरोखर रिक्त असेल तर ते सत्य परत करतात. याव्यतिरिक्त, जर स्ट्रिंगमध्ये फक्त स्पेस असेल तर isBlank() देखील खरे होईल .

त्यांच्या स्वतःच्या व्यस्त पद्धती देखील आहेत: isNotEmpty() आणि isNotBlank() .

तुम्ही isEmpty() त्याच्या java.lang.String.isEmpty() समकक्ष , तसेच isBlank() सोबत कसे वापरू शकता ते पाहू या :

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

if(StringUtils.isEmpty(emptyValue)) {
   System.out.println("emptyValue is emptyValue");
}

if(StringUtils.isBlank(blankValue)) {
   System.out.println("blankValue is blankValue");
}

if(!nullValue.isEmpty()) {
   System.out.println("nullString isn't null");
}

येथे स्ट्रिंग प्रकाराचे तीन व्हेरिएबल्स आहेत . एक पॉइंट null कडे दर्शवितो, दुसरा शून्य नाही परंतु त्यात कोणतीही सामग्री नाही (रिक्त स्ट्रिंग), आणि तिसरा रिकामा नाही परंतु रिक्त परिणाम मुद्रित करेल.

हा कोड चालवल्याने परिणाम होतो:

emptyValue is emptyValue
blankValue is blankValue
Exception in thread "main" java.lang.NullPointerException

java.lang.String मध्ये तयार केलेली isEmpty() पद्धत शून्य सुरक्षित नाही . जर तुम्ही ते रिकामे आहे की नाही हे तपासण्याचा प्रयत्न केला तर तुम्हाला NullPointerException सहज मिळेल , कारण तुम्ही या पद्धतीला शून्य संदर्भावर कॉल करता . संदर्भ शून्य आहे की नाही हे आगाऊ तपासणे आवश्यक आहे:

String nullValue = null;
String emptyValue = "";
String blankValue = "\n \t   \n";

if(StringUtils.isEmpty(emptyValue)) {
   System.out.println("emptyValue is emptyValue");
}

if(StringUtils.isBlank(blankValue)) {
   System.out.println("blankValue is blankValue");
}

if(nullValue != null && !nullValue.isEmpty()) {
   System.out.println("nullString isn't null");
}

आता याचा परिणाम होतो:

emptyValue is emptyValue
blankValue is blankValue

आणि जर आम्ही या पद्धती तपासल्या तरnullString:

String nullValue = null;

if(StringUtils.isEmpty(nullValue)) {
   System.out.println("nullValue is emptyValue");
}

if(StringUtils.isBlank(nullValue)) {
   System.out.println("nullValue is blankValue");
}

मग आम्हाला मिळते:

nullValue is emptyValue
nullValue is blankValue

StringUtils पद्धती शून्य सुरक्षित आहेत आणि त्या null पास झाल्या तरी अपेक्षित परिणाम देतात .

StringUtils.equals()

ही पद्धत दोन स्ट्रिंग्सची तुलना करते आणि जर ते एकसारखे असतील किंवा दोन्ही संदर्भ null कडे निर्देशित करत असतील तर ते सत्य मिळवते , परंतु लक्षात ठेवा की ही पद्धत केस सेन्सेटिव्ह आहे.

ते कसे कार्य करते ते पाहूया:

System.out.println(StringUtils.equals(null, null));
System.out.println(StringUtils.equals(null, "some information"));
System.out.println(StringUtils.equals("some information", null));
System.out.println(StringUtils.equals("some information",  "some information"));
System.out.println(StringUtils.equals("some additional information", "some information"));

परिणाम:

true
false
false
true
false

StringUtils मधील equals() पद्धतीची java.lang.String.equals() शी तुलना करण्यासाठी :

String nullValue = null;

System.out.println(StringUtils.equals(nullValue, null));
System.out.println(StringUtils.equals(nullValue, "some information"));

System.out.println(nullValue.equals(null));
System.out.println(nullValue.equals("some information"));

हे तुम्हाला येथे परत आणते:

true
false
Exception in thread "main" java.lang.NullPointerException

पुन्हा, नल रेफरन्सवर मेथड कॉल केल्याने NullPointerException मध्ये परिणाम होतो आणि तुम्हाला ते वापरण्यापूर्वी संदर्भ व्हेरिएबल शून्य आहे का ते तपासावे लागेल .

StringUtils.compare()

या पद्धतीची घोषणा असे दिसते:

public static int compare(final String str1, final String str2)

java.lang.String.compareTo() पद्धतीप्रमाणे ही पद्धत दोन स्ट्रिंग्सची लेक्सोग्राफिकली तुलना करते , परत येते:

• 0 जर str1 str2 च्या समान असेल (किंवा दोन्ही शून्य असेल)
• str1 str2 पेक्षा कमी असल्यास मूल्य 0 पेक्षा कमी आहे
• str1 str2 पेक्षा मोठे असल्यास 0 पेक्षा मोठे मूल्य

शब्दकोशाचा क्रम म्हणजे शब्दकोशाचा क्रम. आपण हे आपल्या प्रोग्राममध्ये कसे वापरू शकतो ते पाहूया:

System.out.println(StringUtils.compare(null, null));
System.out.println(StringUtils.compare(null , "codeGym"));
System.out.println(StringUtils.compare("codeGym", null));
System.out.println(StringUtils.compare("codeGym", "CODEGYM"));
System.out.println(StringUtils.compare("codeGym", "codeGym"));

आम्हाला मिळते:

0
-1
1
32
0

टीप: शून्य मूल्य नॉन- नल मूल्यापेक्षा कमी मानले जाते . दोन शून्य मूल्ये समान मानली जातात.

स्ट्रिंगमध्ये दुसरी सबस्ट्रिंग आहे का ते तपासत आहे

हे करण्यासाठी, StringUtils मध्ये 5 पद्धती आहेत:

• समाविष्टीत आहे()
• IgnoreCase() समाविष्ट आहे
• समाविष्टीत आहे Any()
• समाविष्ट नाही ()
• फक्त() समाविष्ट आहे

शोध क्रम दुसर्‍या क्रमामध्ये समाविष्ट आहे की नाही यावर अवलंबून समाविष्ट() पद्धत सत्य किंवा असत्य दर्शवते .

अशा पद्धतीत null पास केल्यास , ते खोटे परत येईल . नॉन- नल पास केल्यास , पद्धत पास केलेल्या ऑब्जेक्टवर फक्त java.lang.String.indexOf(String str) कॉल करेल.

उदाहरणे:

String value = "CodeGym is cool";

System.out.println(StringUtils.contains(null, "a"));
System.out.println(StringUtils.contains(value, "CodeGym"));
System.out.println(StringUtils.contains(value, "C++"));
System.out.println(StringUtils.contains(value, "codegym"));

पद्धत केस सेन्सेटिव्ह आहे, त्यामुळे शेवटचा कॉल देखील खोटा परत येईल :

false
true
false
false

पहिल्या वितर्क म्हणून पास केलेल्या स्ट्रिंगमध्ये 2-N आर्ग्युमेंटमध्ये पास केलेल्या सबस्ट्रिंगपैकी किमान एक असल्यास containsAny() पद्धत सत्य मिळवते .

उदाहरण:

String value = "CodeGym is cool";
System.out.println(StringUtils.containsAny(value, "cool", "c00l", "bro", "hello"));

प्रदर्शित होईल:

true

ही पद्धत केस सेन्सेटिव्ह देखील आहे.

समाविष्ट नाही () पद्धत

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

उदाहरण:

String s = "CodeGym is cool";
System.out.println(StringUtils.containsNone(s, 'g', 'a'));

कन्सोल आउटपुट:

false

सबस्ट्रिंगसह कार्य करणे

सबस्ट्रिंग्ससह कार्य करणे हे स्ट्रिंग क्लासच्या पद्धतींसह कार्य करण्यासारखे आहे :

substring(String str, int start)
substring (String str, int start, int end)

या पद्धती स्ट्रिंग स्ट्रिंगमधून सबस्ट्रिंग परत करतात . स्ट्रिंग दोन निर्देशांकांद्वारे दिली जाते: प्रारंभ आणि शेवट . आणि Java मध्ये नेहमीप्रमाणे, श्रेणीचा शेवटचा वर्ण end-1 आहे . या पद्धतींचा फायदा काय आहे?

तुम्ही अशा पद्धतीला null पास केल्यास, ते अपवाद टाकण्याऐवजी null परत करेल . या पद्धती नकारात्मक निर्देशांक मूल्यांना समर्थन देतात. या प्रकरणात, स्ट्रिंग बंद लूप मानली जाते. शेवटचे पात्र पहिल्या नंतर येते, आणि असेच.

आपण ते कसे वापरू शकतो ते पाहूया:

System.out.println(StringUtils.substring("lets java", 2, 6));
System.out.println(StringUtils.substring("lets java", -8));
System.out.println(StringUtils.substring(null, 3));

वरील कोड चालवल्याने आम्हाला मिळते:

ts j
ets java
null

StringUtils.split()

एक पद्धत जी तुम्हाला विशेष परिसीमक वर्ण वापरून स्ट्रिंगला सबस्ट्रिंगमध्ये विभाजित करण्यास अनुमती देते. लक्ष्य स्ट्रिंगमध्ये एक असल्यास, पद्धत सबस्ट्रिंगचा अॅरे देईल. कोणतेही वर्ण नसल्यास, रिक्त अॅरे परत केला जाईल. बरं, जर null पद्धतीला पास केले तर ते null परत येईल . चला या कोडवर एक नजर टाकूया आणि पद्धत कशी कार्य करते:

String myData = "Address, City, State, Zip, Phone, Email, Password";

System.out.println(Arrays.toString(StringUtils.split(myData, ',')));
System.out.println(Arrays.toString(StringUtils.split(null, '.')));
System.out.println(Arrays.toString(StringUtils.split("", '.')));

परिणाम:

[Address,  City,  State,  Zip,  Phone,  Email,  Password]
null
[]

StringUtils.join()

join() पद्धत तुम्हाला स्ट्रिंग्सच्या अ‍ॅरेला एकाच स्ट्रिंगमध्ये जोडण्याची परवानगी देते. त्याच वेळी, एक विशेष विभाजक वर्ण त्यास पास केला जाऊ शकतो, जो परिणामी स्ट्रिंगमधील सबस्ट्रिंगमध्ये जोडला जाईल. आणि जर null पद्धतीला पास केले तर ते null परत येईल .

ही पद्धत स्प्लिट() पद्धतीच्या अगदी उलट आहे . हे साधे उदाहरण पाहू:

String myData = "Address, City, State, Zip, Phone, Email, Password";

String[] myString =  StringUtils.split(myData, ',');
System.out.println(StringUtils.join(myString, '-'));

वरील कोड चालवल्याने आम्हाला मिळते:

Address- City- State- Zip- Phone- Email- Password

StringUtils.replace()

स्ट्रिंगमध्ये स्ट्रिंग शोधते, ती अस्तित्वात असल्यास ती शोधते आणि त्यातील सर्व घटनांना नवीन स्ट्रिंगने बदलते.

या पद्धतीची घोषणा असे दिसते:

public static String replace(final String text, final String searchString, final String replacement)

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

चला ही पद्धत वापरून पाहू:

String value = "CodeGym is the best";
System.out.println(StringUtils.replace(value, "best", "cool"));

परिणाम:

CodeGym is the cool

• Java मधील Apache Commons च्या StringUtils वर्गासाठी मार्गदर्शक
• Apache Commons Java StringUtils वर्ग मार्गदर्शक