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:
Jag lär mig sammanlänkning i Java CodeGym.cc/quest Jag har det Jag har det inte
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:
5 dagar sant
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:
bok null sant
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:
Undantag i tråden "main" java.lang.NullPointerException på java.base/java.lang.String.concat(String.java:1972) på StringConcat.main(StringConcat.java:6)
GO TO FULL VERSION