అపాచీ కామన్స్ నుండి StringUtils తరగతి

StringUtils పరిచయం

StringUtils ఎక్కువగా ఉపయోగించే Apache Commons తరగతి. ఇది డెవలపర్‌లు బాయిలర్‌ప్లేట్ లేదా బేసిక్ ఆపరేషన్‌ల కోసం విపరీతమైన కోడ్‌ను వ్రాయకుండా నివారించడంలో సహాయపడే వివిధ వినియోగాలు మరియు పద్ధతులను కలిగి ఉంది.

StringUtils తరగతిలోని అనేక పద్ధతులు వాటి java.lang.String సమానమైన వాటిని కలిగి ఉంటాయి కానీ, java.lang.String పద్ధతుల వలె కాకుండా , శూన్య-సురక్షితమైనవి. దీనర్థం NullPointerException చాలా ఊహించని సమయంలో విసిరివేయబడదు .

అపాచీ కామన్స్ అనేక పద్ధతులను కలిగి ఉంది మరియు మేము సాధారణంగా ఉపయోగించే కొన్నింటిని పరిశీలిస్తాము.

StringUtils పద్ధతుల జాబితా:

StringUtils.isEmpty() మరియు StringUtils.isBlank()

స్ట్రింగ్ ఏదైనా వచనాన్ని కలిగి ఉందో లేదో తనిఖీ చేయడానికి రెండు పద్ధతులు ఉపయోగించబడతాయి. స్ట్రింగ్ నిజంగా ఖాళీగా ఉంటే అవి నిజమైనవిగా తిరిగి వస్తాయి. అదనంగా, స్ట్రింగ్‌లో ఖాళీలు మాత్రమే ఉన్నట్లయితే isBlank() కూడా నిజాన్ని అందిస్తుంది .

వారు తమ స్వంత విలోమ పద్ధతులను కూడా కలిగి ఉన్నారు: isNotEmpty() మరియు isNotBlank() .

మీరు java.lang.String.isEmpty() ప్రతిరూపంతో పాటు 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");
}

ఇక్కడ స్ట్రింగ్ టైప్ యొక్క మూడు వేరియబుల్స్ ఉన్నాయి . ఒక పాయింట్ శూన్యం , రెండవది శూన్యం కాదు కానీ కంటెంట్ (ఖాళీ స్ట్రింగ్) లేదు మరియు మూడవది ఖాళీగా లేదు కానీ ఖాళీ ఫలితాన్ని ముద్రిస్తుంది.

ఈ కోడ్‌ని అమలు చేయడం వలన ఫలితాలు:

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 పద్ధతులు శూన్యం సురక్షితమైనవి మరియు అవి శూన్యంగా ఆమోదించబడినప్పటికీ ఆశించిన ఫలితాన్ని అందిస్తాయి .

StringUtils.equals()

ఈ పద్ధతి రెండు స్ట్రింగ్‌లను పోల్చి చూస్తుంది మరియు అవి ఒకేలా ఉంటే లేదా రెండు రిఫరెన్స్‌లు శూన్యాన్ని సూచిస్తే నిజమని చూపుతుంది , అయితే ఈ పద్ధతి కేస్ సెన్సిటివ్ అని గుర్తుంచుకోండి.

ఇది ఎలా పని చేస్తుందో చూద్దాం:

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 నుండి సమాన () పద్ధతిని 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 పద్ధతులను కలిగి ఉంది:

• కలిగి ()
• ఇగ్నోర్కేస్()ని కలిగి ఉంటుంది
• కలిగి ఏదైనా()
• ఏదీ లేదు()
• కలిగి మాత్రమే()

సెర్చ్ సీక్వెన్స్ మరొక సీక్వెన్స్‌లో ఉందా లేదా అనేదానిపై ఆధారపడి కలిగి() పద్ధతి ఒప్పు లేదా తప్పుని అందిస్తుంది .

అటువంటి పద్ధతికి శూన్యం పాస్ చేయబడితే , అది తప్పుగా తిరిగి వస్తుంది . నాన్- నల్ పాస్ అయినట్లయితే , ఈ పద్ధతి కేవలం పాస్ చేసిన వస్తువుపై 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)

ఈ పద్ధతులు స్ట్రింగ్ str నుండి సబ్‌స్ట్రింగ్‌ను తిరిగి అందిస్తాయి . స్ట్రింగ్ రెండు సూచికల ద్వారా ఇవ్వబడింది: ప్రారంభం మరియు ముగింపు . మరియు జావాలో ఎప్పటిలాగే, శ్రేణి యొక్క చివరి అక్షరం ముగింపు-1 . ఈ పద్ధతుల ప్రయోజనం ఏమిటి?

మీరు అటువంటి పద్ధతికి శూన్యాన్ని పాస్ చేస్తే, అది మినహాయింపును విసిరే బదులు శూన్యతను అందిస్తుంది . ఈ పద్ధతులు ప్రతికూల సూచిక విలువలకు మద్దతు ఇస్తాయి. ఈ సందర్భంలో, స్ట్రింగ్ క్లోజ్డ్ లూప్‌గా పరిగణించబడుతుంది. చివరి పాత్ర మొదటిది, మరియు మొదలైనవి.

దీన్ని ఎలా ఉపయోగించవచ్చో చూద్దాం:

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

ప్రత్యేక డీలిమిటర్ అక్షరాన్ని ఉపయోగించి స్ట్రింగ్‌ను సబ్‌స్ట్రింగ్‌లుగా విభజించడానికి మిమ్మల్ని అనుమతించే పద్ధతి. లక్ష్య స్ట్రింగ్‌లో ఒకటి ఉంటే, ఆ పద్ధతి సబ్‌స్ట్రింగ్‌ల శ్రేణిని అందిస్తుంది. అక్షరం లేకపోతే, ఖాళీ శ్రేణి తిరిగి ఇవ్వబడుతుంది. సరే, శూన్యాన్ని పద్ధతికి పంపినట్లయితే, అది శూన్యతను తిరిగి ఇస్తుంది . ఈ కోడ్ మరియు పద్ధతి ఎలా పనిచేస్తుందో చూద్దాం:

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() పద్ధతి మీరు స్ట్రింగ్‌ల శ్రేణిని ఒకే స్ట్రింగ్‌గా కలపడానికి అనుమతిస్తుంది. అదే సమయంలో, ఒక ప్రత్యేక సెపరేటర్ అక్షరాన్ని దానికి పంపవచ్చు, ఇది ఫలిత స్ట్రింగ్‌లోని సబ్‌స్ట్రింగ్‌ల మధ్య జోడించబడుతుంది. మరియు శూన్య పద్ధతికి పాస్ అయినట్లయితే , అది శూన్యతను తిరిగి ఇస్తుంది .

ఈ పద్ధతి స్ప్లిట్() పద్ధతికి ఖచ్చితమైన వ్యతిరేకం . ఈ సాధారణ ఉదాహరణను చూద్దాం:

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)

టెక్స్ట్‌లో శోధన స్ట్రింగ్ కనుగొనబడకపోతే, ఏమీ జరగదు మరియు వచనం అలాగే ఉంటుంది. అదే లాజిక్‌ని అనుసరించి, టెక్స్ట్ శూన్యంగా ఉంటే , ఈ పద్ధతి శూన్యతను అందిస్తుంది . మీరు శూన్య స్ట్రింగ్ కోసం వెతుకుతున్నట్లయితే లేదా సబ్‌స్ట్రింగ్‌ను శూన్యంతో భర్తీ చేస్తుంటే , ఆ పద్ధతి అసలు స్ట్రింగ్‌ను తిరిగి ఇస్తుంది.

ఈ పద్ధతిని ప్రయత్నిద్దాం:

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

ఫలితం:

CodeGym is the cool

• జావాలో అపాచీ కామన్స్ స్ట్రింగ్ యుటిల్స్ క్లాస్‌కు గైడ్
• Apache Commons Java StringUtils క్లాస్ గైడ్