Strengsammenkædning i Java

Java String-sammenkædning er en operation til at forbinde to eller flere strenge og returnere en ny. Sammenkædningsoperationen kan også bruges til at støbe typer til strenge. Du kan sammenkæde strenge i Java på to forskellige måder.

concat() metode

Concat()- metoden tilføjer den angivne streng i slutningen af ​​den givne streng og returnerer derefter og returnerer derefter en ny dannet streng. Selvfølgelig kan vi bruge concat() metoden til at forbinde tre eller flere strenge.

Concat()-metodesignaturen

public String concat(String str)

Metoden sammenkæder strengen str i slutningen af ​​den aktuelle streng. For eksempel:

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

returnerer en ny streng "Hello World".

Concat() metode eksempel

Lad os sammensætte to strenge efter deres initialisering, og derefter sammensætte flere strenge. Og endnu et interessant eksempel: vi skal skabe en metode, der ville returnere forskellige beskeder i henhold til argumentet.

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

}

Udgangen er: Det er vigtigt at vide, at concat()- metoden ikke ændrer strengen, men opretter en ny som et resultat af at flette den nuværende og den, der sendes som en parameter. Så metoden returnerer et nyt String- objekt, det er derfor, du kan oprette så lange kæder af String Concat.

Sammenkædning ved hjælp af overbelastede operatorer "+" og "+="

Du kan bruge disse to operatorer på samme måde som med tal. De fungerer ligesom concat() . Lad os sammenkæde strengen "Code" og strengen "Gym".

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

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

Normalt tillader Java ikke overbelastningsoperationer for brugerklasser, men disse to operatører fungerer som overbelastede. Du tror måske, at inde i + -operatoren gemmer sig concat() , men faktisk bruges en anden mekanisme her. Hvis vi ser på Java-programmet bytecode, vil vi se, at StringBuilder blev oprettet, og dens append() metode er brugt. Java-kompileren ser "+"-operatoren og indser, at operander er strenge, ikke primitive typer. Så det fungerer 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 + ?

Hvis du kun skal flette strenge én gang, skal du bruge concat()- metoden. I alle andre tilfælde er det bedre at bruge enten + eller Stringbuffer / StringBuilder operatoren. Operatoren + bruges også til at konvertere typer. Hvis en af ​​operanderne er lig, f.eks. tallet, og den anden er en streng, så får vi ved udgangen en streng. Eksempel:

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 brugte instanceof til at kontrollere, om (myInt + myString) er en streng. Her er output fra dette program: Bemærk også, at + operatoren og concat() fungerer anderledes, hvis en af ​​strengene er null. Hvis en af ​​operanderne, når du bruger + eller += operatoren, kun er én — en streng, så sker der, som vi allerede har sagt, typekonvertering. Det samme gælder null. Vi får lige en ny streng:

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

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

Udgangen er: Hvis vi anvender concat() -metoden for den samme operation, får vi en NullPointerException .

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

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

   }
}

Udgangen er: