String Concatenation sa Java

Ang Java String concatenation ay isang operasyon upang pagsamahin ang dalawa o higit pang mga string at magbalik ng bago. Gayundin, ang operasyon ng pagsasama-sama ay maaaring gamitin upang i-cast ang mga uri sa mga string. Maaari mong pagsamahin ang mga string sa Java sa dalawang magkaibang paraan.

concat() na pamamaraan

Ang paraan ng Concat() ay nagdaragdag ng tinukoy na string sa dulo ng ibinigay na string at pagkatapos ay nagbabalik at pagkatapos ay nagbabalik ng bagong string na nabuo. Tiyak na magagamit natin ang concat() na paraan upang sumali sa tatlo o higit pang mga string.

Ang lagda ng concat() method

public String concat(String str)

Pinagsasama ng pamamaraan ang string str sa dulo ng kasalukuyang string. Halimbawa:

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

nagbabalik ng bagong string na "Hello World".

Halimbawa ng paraan ng Concat().

Pagsamahin natin ang dalawang string pagkatapos ng kanilang pagsisimula, pagkatapos ay pagdugtungin ang higit pang mga string. At isa pang kawili-wiling halimbawa: gagawa tayo ng paraan na magbabalik ng iba't ibang mensahe ayon sa argumento.

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

}

Ang output ay: Mahalagang malaman na ang concat() na pamamaraan ay hindi nagbabago sa string, ngunit lumilikha ng bago bilang resulta ng pagsasama ng kasalukuyang isa at ang isa na ipinasa bilang isang parameter. Kaya't ang pamamaraan ay nagbabalik ng isang bagong String object, kaya't maaari kang lumikha ng napakahabang chain ng String concat.

Concatenation gamit ang mga overloaded na operator na "+" at "+="

Maaari mong gamitin ang dalawang operator na ito sa parehong paraan tulad ng sa mga numero. Gumagana sila tulad ng concat() . Pagsamahin natin ang string na “Code” at string na “Gym”.

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

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

Karaniwang hindi pinapayagan ng Java ang mga overloading na operasyon para sa mga klase ng user, ngunit gumagana ang dalawang operator na ito bilang overloaded. Maaari mong isipin na sa loob ng + operator ay nagtatago concat() , ngunit sa katunayan, isa pang mekanismo ang ginagamit dito. Kung titingnan natin ang Java program bytecode, makikita natin na ang StringBuilder ay nilikha at ang append() na paraan nito ay ginagamit. Nakikita ng Java Compiler ang operator na "+" at napagtanto na ang mga operand ay mga string, hindi mga primitive na uri. Kaya ito ay gumagana tulad ng 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) o + ?

Kung kailangan mong pagsamahin ang mga string nang isang beses lang, gamitin ang concat() method. Para sa lahat ng iba pang mga kaso, mas mainam na gamitin ang alinman sa + o Stringbuffer / StringBuilder operator. Gayundin, ang + operator ay ginagamit upang mag-convert ng mga uri. Kung ang isa sa mga operand ay pantay, halimbawa, ang numero at ang pangalawa ay isang string, pagkatapos ay sa exit makakakuha tayo ng isang string. Halimbawa:

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

Ginamit namin ang instanceof upang suriin kung ang (myInt + myString) ay isang String. Narito ang output ng program na ito: Tandaan din na ang + operator at concat() ay gumagana nang iba kung ang isa sa mga string ay null. Kung ang isa sa mga operand kapag ginagamit ang + o += operator ay isa lamang — isang string, kung gayon, gaya ng nasabi na natin, nangyayari ang uri ng conversion. Ang parehong naaangkop sa null. Makakakuha lang kami ng bagong string:

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

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

Ang output ay: Kung ilalapat namin ang concat() na pamamaraan para sa parehong operasyon, makakakuha kami ng NullPointerException .

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

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

   }
}

Ang output ay: