జావా స్ట్రింగ్ () పద్ధతిని కలిగి ఉంటుంది

స్ట్రింగ్ మరొక స్ట్రింగ్‌ను కలిగి ఉందో లేదో తనిఖీ చేయడానికి ఈ ఫంక్షన్ ప్రత్యేకంగా రూపొందించబడింది. మీరు దీనికి కొత్త అయితే 'అక్షరాన్ని' కనుగొనడానికి దాన్ని ఉపయోగించడం ముగించవచ్చు. కానీ అది ప్రయోజనం చేకూర్చదు. ఈ కథనంలో, java.lang.String.contains() ఎలా ఉపయోగించబడుతుందో, అమలు చేయబడిందో మరియు జాగ్రత్తగా ఉపయోగించకపోతే ఎలాంటి మినహాయింపులు తలెత్తవచ్చో తెలియజేస్తాము .

కలిగి () పద్ధతి ఏమిటి?

నిర్దిష్ట స్ట్రింగ్‌లో నిర్దిష్ట స్ట్రింగ్ “ కీ ” ఉన్నట్లయితే లేదా “ కనుగొనడానికి ” మీరు కలిగి(స్ట్రింగ్ కీ) పద్ధతిని ఉపయోగించవచ్చు . "కీ" కనుగొనబడితే, "నిజం" తిరిగి ఇవ్వబడుతుంది. లేకపోతే మీరు "తప్పుడు" పొందుతారు.

అంతర్గత అమలు

ఈ పద్ధతి ఇప్పటికే 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"));
    }
}

అవుట్‌పుట్

కోడ్ వివరణ

దయచేసి గమనించండి, ఈ పద్ధతి ఇన్‌పుట్ పారామితుల కోసం కేస్-సెన్సిటివ్ . కాబట్టి పై స్నిప్పెట్‌లో, మీరు “బ్రౌన్” అని శోధించినప్పుడు నిజమైన రిటర్న్ అవుతుందని, అయితే “బ్రౌన్” కోసం ఫాల్స్ రిటర్న్ అవుతుందని మీరు గమనించవచ్చు . అలాగే, మీరు "ఫాక్స్" మరియు "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)

ముగింపు

కలిగి() పద్ధతి ఏదైనా చార్-సీక్వెన్స్ లేదా స్ట్రింగ్‌ని కనుగొనడానికి సులభ జావా యుటిలిటీని అందిస్తుంది. ఈ పోస్ట్ ముగిసే సమయానికి, దీని ఉపయోగం మరియు అమలు గురించి మీకు తెలిసి ఉంటుందని మేము ఆశిస్తున్నాము. మరింత మెరుగైన అవగాహన కోసం, మీరు మీ స్లీవ్‌లను పైకి చుట్టుకొని పని చేయమని ప్రోత్సహిస్తున్నారు. లోపం లేని కోడ్‌ని సృష్టించడం స్థిరమైన ప్రయత్నంతో వస్తుంది. కాబట్టి దాన్ని పొందండి అబ్బాయిలు! మీరు చిక్కుకున్నప్పుడు ఇక్కడికి తిరిగి రావడానికి మీకు ఎల్లప్పుడూ స్వాగతం ఉంటుంది. హ్యాపీ కోడింగ్. :)