స్ట్రింగ్ మరొక స్ట్రింగ్‌ను కలిగి ఉందో లేదో తనిఖీ చేయడానికి ఈ ఫంక్షన్ ప్రత్యేకంగా రూపొందించబడింది. మీరు దీనికి కొత్త అయితే 'అక్షరాన్ని' కనుగొనడానికి దాన్ని ఉపయోగించడం ముగించవచ్చు. కానీ అది ప్రయోజనం చేకూర్చదు. ఈ కథనంలో, java.lang.String.contains() ఎలా ఉపయోగించబడుతుందో, అమలు చేయబడిందో మరియు జాగ్రత్తగా ఉపయోగించకపోతే ఎలాంటి మినహాయింపులు తలెత్తవచ్చో తెలియజేస్తాము .
![జావా స్ట్రింగ్ () పద్ధతిని కలిగి ఉంటుంది - 1]()
కలిగి () పద్ధతి ఏమిటి?
నిర్దిష్ట స్ట్రింగ్‌లో నిర్దిష్ట స్ట్రింగ్ “ కీ ” ఉన్నట్లయితే లేదా “ కనుగొనడానికి ” మీరు కలిగి(స్ట్రింగ్ కీ) పద్ధతిని ఉపయోగించవచ్చు . "కీ" కనుగొనబడితే, "నిజం" తిరిగి ఇవ్వబడుతుంది. లేకపోతే మీరు "తప్పుడు" పొందుతారు.
అంతర్గత అమలు
ఈ పద్ధతి ఇప్పటికే java.lang.String ద్వారా అమలు చేయబడింది . మీరు దీన్ని మీరే అమలు చేయవలసిన అవసరం లేదు. మీ అవగాహన కోసం ఇక్కడ శీఘ్ర వివరణ ఉంది.
public class ContainsMethod
{
public boolean contains(CharSequence key)
{
return indexOf(key.toString()) > -1;
}
}
కోడ్ వివరణ
() పద్ధతిని కలిగి ఉంటుంది, చార్‌సీక్వెన్స్‌ను ఇన్‌పుట్ పారామీటర్‌గా తీసుకుంటుంది. ఇది తరువాత "స్ట్రింగ్" గా మార్చబడుతుంది. అప్పుడు ఈ వ్యక్తీకరణ గణించబడుతుంది indexOf(key.toString()) > -1; . అంటే, ఆ “కీ” ఏదైనా ఇండెక్స్‌లో (“0” లేదా అంతకంటే ఎక్కువ) కనుగొనబడితే, “నిజం” అందించబడుతుంది. మరియు కీ కనుగొనబడకపోతే, "తప్పుడు" తిరిగి ఇవ్వబడుతుంది.కలిగి() పద్ధతిని ఎలా ఉపయోగించాలి?
మీరు దీన్ని ఎలా ఉపయోగించవచ్చో ఇక్కడ ఉంది.
public class ContainsMethod {
public static void main(String[] args) {
String input = "A brown fox jumped over a lazy dog.";
// check the containing strings
System.out.println("input.contains(bro) = " + input.contains("bro"));
System.out.println("input.contains(brown) = " + input.contains("brown"));
System.out.println("input.contains(Brown) = " + input.contains("Brown"));
System.out.println("input.contains(fox) = " + input.contains("fox"));
System.out.println("input.contains(xof) = " + input.contains("xof"));
System.out.println("input.contains(dog) = " + input.contains("dog"));
System.out.println("input.contains(lazyy) = " + input.contains("lazyy"));
System.out.println("input.contains(jumping) = " + input.contains("jumping"));
}
}
input.contains(bro) = true input.contains(brown) = true input.contains(Brown) = false // false ఎందుకంటే case-sensitive input.contains(fox) = true input.contains(xof) = తప్పు // తప్పు ఎందుకంటే ఆర్డర్ అదే ఇన్‌పుట్‌గా ఉండాలి.contains(కుక్క) = true input.contains(lazyy) = తప్పు // తప్పు ఎందుకంటే మొత్తం సబ్‌స్ట్రింగ్ కనుగొనబడలేదు input.contains(జంపింగ్) = తప్పు
కోడ్ వివరణ
దయచేసి గమనించండి, ఈ పద్ధతి ఇన్‌పుట్ పారామితుల కోసం కేస్-సెన్సిటివ్ . కాబట్టి పై స్నిప్పెట్‌లో, మీరు “బ్రౌన్” అని శోధించినప్పుడు నిజమైన రిటర్న్ అవుతుందని, అయితే “బ్రౌన్” కోసం ఫాల్స్ రిటర్న్ అవుతుందని మీరు గమనించవచ్చు . అలాగే, మీరు "ఫాక్స్" మరియు "xof" లేదా "oxf" కోసం తప్పు అని కనుగొంటే మీరు నిజం అవుతారు ఎందుకంటే అక్షరాల క్రమం ఒకేలా ఉండాలి. చివరగా, మీరు "జంప్" లేదా "జంప్డ్"ని కనుగొంటే, " ఇన్‌పుట్ " స్ట్రింగ్‌లో మొత్తం పరామితి ఉన్నందున మీరు నిజం పొందుతారు . అయితే, మీరు "జంపింగ్" కోసం తనిఖీ చేస్తే, మొత్తం కీ ("జంపింగ్") కనుగొనబడనందున తప్పు అందించబడుతుంది.మినహాయింపులను చూసుకోవడం
java.lang.String.contains() పద్ధతి మీరు కొంత నిర్దిష్ట విలువతో పరామితి స్ట్రింగ్‌ని ప్రారంభించడం మర్చిపోతే శూన్య పాయింటర్ మినహాయింపును అందిస్తుంది.
public class ContainsMethod {
public static void main(String[] args) {
String input = "Here is a test string.";
String test = null;
// check what happens if you look for a null string
System.out.println("input.contains(test) = " + input.contains(test));
}
}
Exception in thread "main" java.lang.NullPointerException
at java.lang.String.contains(String.java:2133)
at ContainsMethod.main(ContainsMethod.java:8)
GO TO FULL VERSION