Strängsammansättning i Java

Java-strängsammansättning är en operation för att sammanfoga två eller flera strängar och returnera en ny. Sammankopplingsoperationen kan också användas för att gjuta typer till strängar. Du kan sammanfoga strängar i Java på två olika sätt.

concat() metod

Concat() -metoden lägger till den angivna strängen i slutet av den givna strängen och returnerar sedan och returnerar sedan en ny sträng som bildats. Visst kan vi använda metoden concat() för att sammanfoga tre eller fler strängar.

Concat()-metodens signatur

public String concat(String str)

Metoden sammanfogar strängen str i slutet av den aktuella strängen. Till exempel:

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

returnerar en ny sträng "Hello World".

Concat() metodexempel

Låt oss sammanfoga två strängar efter deras initialisering och sedan sammanfoga fler strängar. Och ytterligare ett intressant exempel: vi kommer att skapa en metod som skulle returnera olika meddelanden enligt argument.

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

}

Utgången är: Det är viktigt att veta att concat()- metoden inte ändrar strängen, utan skapar en ny som ett resultat av att slå samman den nuvarande och den som skickas som en parameter. Så metoden returnerar ett nytt String -objekt, det är därför du kan skapa så långa kedjor av String Concat.

Sammankoppling med överbelastade operatorer "+" och "+="

Du kan använda dessa två operatorer på samma sätt som med siffror. De fungerar precis som concat() . Låt oss sammanfoga strängen "Code" och strängen "Gym".

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

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

Vanligtvis tillåter Java inte överbelastningsoperationer för användarklasser, men dessa två operatörer fungerar som överbelastade. Du kanske tror att inuti operatorn + döljer sig concat() , men i själva verket används en annan mekanism här. Om vi ​​tittar på Java-programmet bytecode, ser vi att StringBuilder skapades och dess append()- metod används. Java-kompilatorn ser operatorn "+" och inser att operander är strängar, inte primitiva typer. Så det fungerar som 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) eller + ?

Om du bara behöver slå samman strängar en gång, använd metoden concat() . I alla andra fall är det bättre att använda antingen operatorn + eller Stringbuffer / StringBuilder . Operatorn + används också för att konvertera typer. Om en av operanderna är lika, till exempel talet och den andra är en sträng, så får vi vid utgången en sträng. Exempel:

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

Vi använde instanceof för att kontrollera om (myInt + myString) en String. Här är resultatet av detta program: Observera också att operatorn + och concat() fungerar annorlunda om en av strängarna är null. Om en av operanderna när du använder operatorn + eller += bara är en — en sträng, så sker, som vi redan har sagt, typkonvertering. Detsamma gäller null. Vi får bara en ny sträng:

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

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

Utgången är: Om vi ​​tillämpar concat() -metoden för samma operation kommer vi att få en NullPointerException .

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

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

   }
}

Utgången är: