Mycket kodning involverar textmanipulation, från språköversättning till att helt enkelt sammanfoga ord. Java har, precis som de flesta andra språk, utmärkt inbyggt stöd för att hjälpa dig att arbeta med strängar.
Java stöder det enkla fallet att sammanfoga - eller sammanfoga - strängar mycket bra. Faktum är att det finns tillräckligt många olika sätt att sammanfoga text så att du vill veta deras skillnader och varför du kan använda varje metod.
Använd +-tecknet
Av allt sakerna du bör veta om Strings i Java, grundläggande sammanlänkning med hjälp av + operatör är en av de mest grundläggande. När du har två eller flera strängar kan du använda +-tecknet för att sammanfoga dem.
Så här kan du göra det:
offentligklassStringConcat_Java{
offentligstatisktomhethuvud(String[] args)
{
String var1 = "Hej,";
String var2 = "Mitt namn är";
String var3 = "Advait";
System.out.println (var1 + " " + var2 + " " + var3);
}
}
Slutresultatet är som följer:
I ovanstående kod har du strängvärden i tre olika variabler (var1, var2 och var3), som du sammanfogar med +-tecknet.
De tomma citattecken omsluter mellanslag, som du kan referera till som avgränsare. I det här fallet fungerar de som mellanslag mellan ord i den sista meningen. De println funktionen skriver ut den slutliga utskriften som det sista steget.
Sammanfoga flera rader av strängar med +-tecknet
Du kan sammanfoga flera strängar även om de är spridda över olika linjer. För att göra det, använd bara a + tecken mellan varje sträng:
offentligklassStringConcat_Java{
offentligstatisktomhethuvud(String[] args)
{
String var1 = "Hej, " +
"Jag heter Advait." +
" " +
"Jag är författare på MUO.";
System.out.println (var1);
}
}
Här är resultatet av ovanstående kod:
När du kör ovanstående kod sammanfogar den alla strängarna för att skapa ett enda stycke text.
Använd en StringBuilder
Du kan också använda klassen StringBuilder för att sammanfoga strängar i Java.
En omedelbar nackdel med denna metod är att den använder en helt annan klass: StringBuilder, inte String. Du kan dock enkelt hämta ett String-objekt från en StringBuilder genom att anropa dess toString()-metod. Detta sker som standard i många sammanhang.
Du kan använda bifoga metod för att lägga till en sträng i slutet av StringBuilders nuvarande innehåll.
offentligklassStringConcat_Java{
offentligstatisktomhethuvud(String[] args)
{
StringBuilder strn_builder = ny StringBuilder();strn_builder.append("Hej,");
strn_builder.append("Jag är");
strn_builder.append(" Advait Singh");
System.out.println (strn_builder.toString());
}
}
Så här ser utgången ut:
Som namnet antyder sammanfogar funktionen append() värden i slutet av StringBuilders interna sträng.
Lär dig att använda Concat()-funktionen i Java
Denna funktion är enkel och gör jobbet utan krångel. Innan du börjar använda den här funktionen måste du notera följande:
- Du kan använda konkatfunktionen endast med strängar.
- Du kan bara sammanfoga två strängar med denna funktion. Du kan dock kedja metoden eftersom den returnerar en sträng, så kod som str1.concat (str2).concat (str3) kommer att fungera som du förväntar dig.
Så här kan du använda funktionen concat() i Java:
offentligklassStringconcat_Java{
offentligstatisktomhethuvud(String[] args)
{
// Definiera strängvärdena i var1 och var2
String var1 = "Hej,";
String var2 = "Mitt namn är Advait Singh";// var3 innehåller det sammanlänkade värdet, där var1 är sammanfogat med var2
Sträng var3 = var1.concat (var2);
// Skriv ut den slutliga versionen lagrad i var3
System.out.println (var3);
}
}
Variablerna var1 och var2 lagrar strängarna medan var3 lagrar resultatet av att sammanfoga dem. Concat-metoden förenar den andra variabeln, var2, till var1. Koden tilldelar resultatet från concat till den tredje variabeln, var3, och skriver ut det:
Använda formateringsfunktionen i Java
En annan metod är formatera funktion, vilket är ganska användbart för att sammanfoga strängar. Detta är en vanlig funktion, tillgänglig på många programmeringsspråk. Pythons formatmetodt.ex. är väldigt lika.
Den grundläggande syntaxen för denna funktion är string.format(), följt av formatspecifikationen (t.ex. %s) och strängvärdena/objekten.
offentligklassStringconcat_Java{
offentligstatisktomhethuvud(String[] args)
{
// Definiera strängvärdena i den första och andra variabeln
String var1 = "Hej,";
String var2 = "Mitt namn är Advait Singh";// Använd formatfunktionen för att sammanfoga strängar
String var3 = String.format("%s%s", var1, var2);
// Skriv ut utskriften lagrad i var3
System.out.println (var3);
}
}
Det här exemplet använder formatspecifikationen %s som fungerar som en platshållare för en sträng. Eftersom formatargumentet innehåller två strängar måste du följa det med exakt två strängargument: var1 och var2 i det här fallet. Resultatet är sedan den formaterade strängen som koden skriver ut till konsolen:
Använda String.join()-metoden
Det finns många metoder som fungerar med strängar i Java. En annan användbar funktion är String.join() metod, som sammanfogar två strängar. Observera att detta är en klassmetod, inte en instans. Du kallar det på String-klassen själv, inte ett enskilt String-objekt.
Du är inte begränsad till att bara sammanfoga två strängar med joinmetoden. Du kan skicka valfritt antal strängparametrar och join kombinerar dem alla med den första parametern, avgränsaren:
offentligklassStringconcat_Java{
offentligstatisktomhethuvud(String[] args)
{
// Skapa nya strängar och lagra dem i var1- och var2-variabler
String var1 = "Hej,";
String var2 = "Mitt namn är Advait";// Använd metoden String.join för att kombinera strängarna
String var3 = String.join(" ", var1, var2);
System.out.println (var3);
}
}
Den här koden kombinerar två strängliteraler, lagrar resultatet i var3 och skriver det sedan ut till konsolen:
Javas multi-facetterade strängsammansättningsfunktioner
Javas praktiska funktioner ger dig många alternativ att tänka på när du utför den enkla uppgiften att sammanfoga strängar. Det är en bra idé att öva på att använda dessa alternativa tillvägagångssätt så att du förstår hur de fungerar och vad deras skillnader är.
Det finns många likheter mellan att sammanfoga strängar i Java och att göra det i Python. Du kan ofta överföra kunskap om strängsammansättning mellan språk. Ett bra exempel är syntaxen för formatspecifikationer som String.format använder. Språk som Python, C och PHP återanvänder detta koncept och åtminstone några av dess detaljer.
