ஜாவாவில் சரம் இணைப்பு

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);
   }
}

பொதுவாக ஜாவா பயனர் வகுப்புகளுக்கு ஓவர்லோடிங் செயல்பாடுகளை அனுமதிப்பதில்லை, ஆனால் இந்த இரண்டு ஆபரேட்டர்களும் ஓவர்லோடுடன் வேலை செய்கின்றன. + ஆபரேட்டருக்குள் concat() ஐ மறைத்து வைத்திருப்பதாக நீங்கள் நினைக்கலாம் , ஆனால் உண்மையில், இங்கே மற்றொரு வழிமுறை பயன்படுத்தப்படுகிறது. ஜாவா புரோகிராம் பைட்கோடைப் பார்த்தால், StringBuilder உருவாக்கப்பட்டு அதன் append() முறை பயன்படுத்தப்பட்டிருப்பதைக் காண்போம். ஜாவா கம்பைலர் "+" ஆபரேட்டரைப் பார்க்கிறது மற்றும் ஓபராண்டுகள் சரங்கள், பழமையான வகைகள் அல்ல என்பதை உணர்ந்து கொள்கிறது. எனவே இது 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() முறையைப் பயன்படுத்தவும். மற்ற எல்லா நிகழ்வுகளுக்கும், + அல்லது Stringbuffer / StringBuilder ஆபரேட்டரைப் பயன்படுத்துவது நல்லது . மேலும், + ஆபரேட்டர் வகைகளை மாற்ற பயன்படுகிறது. செயல்களில் ஒன்று சமமாக இருந்தால், எடுத்துக்காட்டாக, எண் மற்றும் இரண்டாவது ஒரு சரம், பின்னர் வெளியேறும் போது ஒரு சரம் கிடைக்கும். உதாரணமாக:

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) ஒரு சரமா என்பதைச் சரிபார்க்க instanceof ஐப் பயன்படுத்தினோம் . இந்த திட்டத்தின் வெளியீடு இங்கே: சரங்களில் ஒன்று பூஜ்யமாக இருந்தால் + ஆபரேட்டர் மற்றும் கான்காட்() ஆகியவை வித்தியாசமாக செயல்படும் என்பதையும் நினைவில் கொள்ளவும் . + அல்லது += ஆபரேட்டரைப் பயன்படுத்தும் போது செயல்பாட்டில் ஒன்று மட்டுமே இருந்தால் - ஒரு சரம், நாம் ஏற்கனவே கூறியது போல், வகை மாற்றம் ஏற்படுகிறது. பூஜ்யத்திற்கும் இது பொருந்தும். நாங்கள் ஒரு புதிய சரத்தைப் பெறுவோம்:

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

   }
}

வெளியீடு: