In Java vormt String-aaneenschakeling een nieuwe String die de combinatie is van meerdere strings. Er zijn twee manieren om tekenreeksen in Java samen te voegen:
- Door + (tekenreeksaaneenschakeling) operator
- Via concat() methode
1) Tekenreeksaaneenschakeling door + (String-aaneenschakeling) operator
Java String-samenvoegingsoperator (+) wordt gebruikt om tekenreeksen toe te voegen. Bijvoorbeeld:
TestStringConcatenation1.java
class TestStringConcatenation1{ public static void main(String args[]){ String s='Sachin'+' Tendulkar'; System.out.println(s);//Sachin Tendulkar } } Test het nu Uitgang:
Sachin Tendulkar
De Transformeert de Java-compiler bovenstaande code hierop:
String s=(new StringBuilder()).append('Sachin').append(' Tendulkar).toString();
In Java wordt String-samenvoeging geïmplementeerd via de klasse StringBuilder (of StringBuffer) en de append-methode. De string-aaneenschakelingsoperator produceert een nieuwe string door de tweede operand aan het einde van de eerste operand toe te voegen. De string-aaneenschakelingsoperator kan niet alleen String, maar ook primitieve waarden aaneenschakelen. Bijvoorbeeld:
TestStringConcatenation2.java
class TestStringConcatenation2{ public static void main(String args[]){ String s=50+30+'Sachin'+40+40; System.out.println(s);//80Sachin4040 } } Test het nu Uitgang:
80Sachin4040
Opmerking: na een letterlijke tekenreeks worden alle + behandeld als tekenreeksaaneenschakelingsoperator.
2) Tekenreeksaaneenschakeling met de concat()-methode
De methode String concat() voegt de opgegeven tekenreeks samen aan het einde van de huidige tekenreeks. Syntaxis:
public String concat(String another)
Laten we het voorbeeld van de String concat()-methode bekijken.
TestStringConcatenation3.java
class TestStringConcatenation3{ public static void main(String args[]){ String s1='Sachin '; String s2='Tendulkar'; String s3=s1.concat(s2); System.out.println(s3);//Sachin Tendulkar } } Test het nu Uitgang:
Sachin Tendulkar
Het bovenstaande Java-programma voegt twee String-objecten samen s1 En s2 gebruik makend van concat() methode en slaat het resultaat op s3 voorwerp.
bash als voorwaarde
Er zijn enkele andere mogelijke manieren om tekenreeksen in Java samen te voegen,
1. Tekenreeksaaneenschakeling met behulp van de StringBuilder-klasse
StringBuilder is een klasse die de append()-methode biedt om aaneenschakelingsbewerkingen uit te voeren. De methode append() accepteert argumenten van verschillende typen, zoals Objects, StringBuilder, int, char, CharSequence, boolean, float, double. StringBuilder is de populairste en snelste manier om strings in Java samen te voegen. Het is een veranderlijke klasse, wat betekent dat waarden die zijn opgeslagen in StringBuilder-objecten kunnen worden bijgewerkt of gewijzigd.
StrBuilder.java
public class StrBuilder { /* Driver Code */ public static void main(String args[]) { StringBuilder s1 = new StringBuilder('Hello'); //String 1 StringBuilder s2 = new StringBuilder(' World'); //String 2 StringBuilder s = s1.append(s2); //String 3 to store the result System.out.println(s.toString()); //Displays result } } Uitgang:
Hello World
In het bovenstaande codefragment, s1, s2 En S worden verklaard als voorwerp van StringBuilder klas. S slaat het resultaat op van de aaneenschakeling van s1 En s2 gebruik makend van toevoegen () methode.
2. Tekenreeksaaneenschakeling met behulp van de format()-methode
De methode String.format() maakt het mogelijk om meerdere tekenreeksen samen te voegen met behulp van een formaatspecificatie zoals %s, gevolgd door de tekenreekswaarden of objecten.
StrFormat.java
public class StrFormat { /* Driver Code */ public static void main(String args[]) { String s1 = new String('Hello'); //String 1 String s2 = new String(' World'); //String 2 String s = String.format('%s%s',s1,s2); //String 3 to store the result System.out.println(s.toString()); //Displays result } } Uitgang:
Hello World
Hier de String-objecten S krijgt het samengevoegde resultaat van Strings toegewezen s1 En s2 gebruik makend van Tekenreeks.format() methode. format() accepteert parameters als formaatspecificatie gevolgd door String-objecten of -waarden.
3. Tekenreeksaaneenschakeling met behulp van de String.join()-methode (Java versie 8+)
De methode String.join() is beschikbaar in Java versie 8 en alle bovenstaande versies. De methode String.join() accepteert eerst argumenten, een scheidingsteken en een array van String-objecten.
StrJoin.java:
public class StrJoin { /* Driver Code */ public static void main(String args[]) { String s1 = new String('Hello'); //String 1 String s2 = new String(' World'); //String 2 String s = String.join('',s1,s2); //String 3 to store the result System.out.println(s.toString()); //Displays result } } Uitgang:
Hello World
In het bovenstaande codefragment is het String-object S slaat het resultaat op van String.join('',s1,s2) methode. Er wordt een scheidingsteken opgegeven tussen aanhalingstekens, gevolgd door de String-objecten of een reeks String-objecten.
4. String-aaneenschakeling met behulp van de klasse StringJoiner (Java versie 8+)
De klasse StringJoiner heeft alle functionaliteiten van de methode String.join(). Van tevoren kan de constructor ook optionele argumenten, voor- en achtervoegsels accepteren.
StrJoiner.java
public class StrJoiner { /* Driver Code */ public static void main(String args[]) { StringJoiner s = new StringJoiner(', '); //StringeJoiner object s.add('Hello'); //String 1 s.add('World'); //String 2 System.out.println(s.toString()); //Displays result } } Uitgang:
Hello, World
In het bovenstaande codefragment het StringJoiner-object S wordt gedeclareerd en de constructor StringJoiner() accepteert een scheidingswaarde. Er wordt een scheidingsteken tussen aanhalingstekens opgegeven. De methode add() voegt tekenreeksen toe die als argumenten zijn doorgegeven.
5. Tekenreeksaaneenschakeling met behulp van de Collectors.joining()-methode (Java (Java versie 8+)
De klasse Collectors in Java 8 biedt de methode join() waarmee de invoerelementen in dezelfde volgorde worden samengevoegd als waarin ze voorkomen.
ColJoining.java
import java.util.*; import java.util.stream.Collectors; public class ColJoining { /* Driver Code */ public static void main(String args[]) { List liststr = Arrays.asList('abc', 'pqr', 'xyz'); //List of String array String str = liststr.stream().collect(Collectors.joining(', ')); //performs joining operation System.out.println(str.toString()); //Displays result } } Uitgang:
str naar int
abc, pqr, xyz
Hier wordt een lijst met String-arrays gedeclareerd. En een String-object str slaat het resultaat op van Verzamelaars.joining() methode.