జావాలో స్ట్రింగ్ సంయోగం

Java String concatenation అనేది రెండు లేదా అంతకంటే ఎక్కువ స్ట్రింగ్‌లను కలపడానికి మరియు కొత్తదాన్ని తిరిగి ఇచ్చే ఆపరేషన్. అలాగే, స్ట్రింగ్‌లకు రకాలను ప్రసారం చేయడానికి సంగ్రహణ ఆపరేషన్‌ను ఉపయోగించవచ్చు. మీరు రెండు విభిన్న మార్గాల్లో జావాలో స్ట్రింగ్‌లను కలపవచ్చు.

concat() పద్ధతి

Concat() మెథడ్ ఇచ్చిన స్ట్రింగ్ చివరిలో పేర్కొన్న స్ట్రింగ్‌ను జోడించి, ఆపై తిరిగి వచ్చి, ఆపై ఏర్పడిన కొత్త స్ట్రింగ్‌ను అందిస్తుంది. ఖచ్చితంగా మేము మూడు లేదా అంతకంటే ఎక్కువ స్ట్రింగ్‌లను చేరడానికి concat() పద్ధతిని ఉపయోగించవచ్చు .

concat() పద్ధతి సంతకం

public String concat(String str)

ఈ పద్ధతి ప్రస్తుత స్ట్రింగ్ చివరిలో స్ట్రింగ్ స్ట్రింగ్‌ను సంగ్రహిస్తుంది. ఉదాహరణకి:

String s1 = “Hello ”; 
s1.concat("World")

"హలో వరల్డ్" అనే కొత్త స్ట్రింగ్‌ను అందిస్తుంది.

Concat() పద్ధతి ఉదాహరణ

రెండు స్ట్రింగ్‌లను ప్రారంభించిన తర్వాత వాటిని కలుపుదాం, ఆపై మరిన్ని స్ట్రింగ్‌లను కలుపుదాం. మరియు మరొక ఆసక్తికరమైన ఉదాహరణ: మేము వాదన ప్రకారం వేర్వేరు సందేశాలను అందించే పద్ధతిని సృష్టించబోతున్నాము.

public class ConcatTest {

    public static void main(String[] args) {
        //String concat with concat() method 
        String string1 = "I learn ";
        String string2 = "concatenation in Java";
        //here we use concat() method to join the two strings above
        String result = string1.concat(string2);
        System.out.println(result);
        //concat() method to join 4 strings
        String myWebSite = "Code".concat("Gym").concat(".cc").concat("/quest");
        System.out.println(myWebSite); // here we've got  "CodeGym.cc/quest"

        System.out.println(myMessage(true));
        System.out.println(myMessage(false));
    }

    private static String myMessage(boolean b) {   //concat() method with selection statement 
        return "I have".concat(b ? " " : "n't ").concat("got it");
    }

}

అవుట్‌పుట్: concat() పద్ధతి స్ట్రింగ్‌ను మార్చదని తెలుసుకోవడం ముఖ్యం , కానీ ప్రస్తుత మరియు పారామీటర్‌గా ఆమోదించబడిన దాన్ని విలీనం చేయడం వల్ల కొత్తదాన్ని సృష్టిస్తుంది. కాబట్టి ఈ పద్ధతి కొత్త స్ట్రింగ్ ఆబ్జెక్ట్‌ను తిరిగి ఇస్తుంది, అందుకే మీరు స్ట్రింగ్ కాన్‌కాట్ యొక్క పొడవైన గొలుసులను సృష్టించవచ్చు.

ఓవర్‌లోడ్ చేయబడిన ఆపరేటర్‌లు "+" మరియు "+=" ఉపయోగించి సంయోగం

మీరు ఈ రెండు ఆపరేటర్లను సంఖ్యల మాదిరిగానే ఉపయోగించవచ్చు. అవి concat() లాగానే పని చేస్తాయి . స్ట్రింగ్ “కోడ్” మరియు స్ట్రింగ్ “జిమ్”ని కలుపుదాం.

public class StringConcat {
   public static void main(String[] args) {

       String myString = "Code" + "Gym";
       myString+= ".cc";
       System.out.println(myString);
   }
}

సాధారణంగా Java వినియోగదారు తరగతుల కోసం ఓవర్‌లోడింగ్ కార్యకలాపాలను అనుమతించదు, కానీ ఈ రెండు ఆపరేటర్‌లు ఓవర్‌లోడ్‌గా పని చేస్తాయి. + ఆపరేటర్ లోపల concat() దాగి ఉందని మీరు అనుకోవచ్చు , కానీ నిజానికి, ఇక్కడ మరొక మెకానిజం ఉపయోగించబడుతుంది. మేము జావా ప్రోగ్రామ్ బైట్‌కోడ్‌ను పరిశీలిస్తే, స్ట్రింగ్‌బిల్డర్ సృష్టించబడిందని మరియు దాని అనుబంధం() పద్ధతిని ఉపయోగించినట్లు చూస్తాము . జావా కంపైలర్ “+” ఆపరేటర్‌ని చూస్తుంది మరియు ఒపెరాండ్‌లు స్ట్రింగ్‌లని, ఆదిమ రకాలు కాదని తెలుసుకుంటుంది. కనుక ఇది concat లాగా పనిచేస్తుంది.

public class StringTest2 {

   public static void main(String[] args) {

       String hello = "hello";
       String world = " world!";

       String helloworld = (new StringBuilder().append(hello).append(world).toString());
       System.out.println(helloworld);
       //this is the same as:
       String result = hello + world;
   }
}

Concat(0) లేదా + ?

మీరు ఒక్కసారి మాత్రమే స్ట్రింగ్‌లను విలీనం చేయాలనుకుంటే, concat() పద్ధతిని ఉపయోగించండి. అన్ని ఇతర సందర్భాలలో, + లేదా స్ట్రింగ్‌బఫర్ / స్ట్రింగ్‌బిల్డర్ ఆపరేటర్‌ని ఉపయోగించడం మంచిది . అలాగే, + ఆపరేటర్ రకాలను మార్చడానికి ఉపయోగించబడుతుంది. ఒపెరాండ్‌లలో ఒకటి సమానంగా ఉంటే, ఉదాహరణకు, సంఖ్య మరియు రెండవది స్ట్రింగ్, అప్పుడు నిష్క్రమణ వద్ద మనకు స్ట్రింగ్ వస్తుంది. ఉదాహరణ:

public class StringConcat {
   public static void main(String[] args) {
       int myInt = 5;
       String myString = " days";

       System.out.println(myInt + myString);
       boolean b = (myInt + myString) instanceof String;
       System.out.println(b);
   }
}

(myInt + myString) స్ట్రింగ్‌ని తనిఖీ చేయడానికి మేము ఉదాహరణను ఉపయోగించాము. ఈ ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ ఇక్కడ ఉంది: స్ట్రింగ్‌లలో ఒకటి శూన్యంగా ఉంటే + ఆపరేటర్ మరియు concat() వేర్వేరుగా పనిచేస్తాయని కూడా గమనించండి . + లేదా += ఆపరేటర్‌ను ఉపయోగిస్తున్నప్పుడు ఒపెరాండ్‌లలో ఒకటి మాత్రమే ఒకటి — స్ట్రింగ్ అయితే, మేము ఇప్పటికే చెప్పినట్లుగా, టైప్ మార్పిడి జరుగుతుంది. అదే శూన్యానికి వర్తిస్తుంది. మేము కొత్త స్ట్రింగ్‌ని పొందుతాము:

public class StringConcat {
   public static void main(String[] args) {

       String myString = "book ";
       System.out.println(myString + null);
       System.out.println((myString + null) instanceof String);
   }
}

అవుట్‌పుట్: మేము అదే ఆపరేషన్ కోసం concat() పద్ధతిని వర్తింపజేస్తే , అప్పుడు మనకు NullPointerException వస్తుంది .

public class StringConcat {
   public static void main(String[] args) {

       String myString = "book ";
       System.out.println(myString.concat(null));

   }
}

అవుట్‌పుట్: