Strengesammenkobling i Java

Java-strengsammenkobling er en operasjon for å slå sammen to eller flere strenger og returnere en ny. Sammenkoblingsoperasjonen kan også brukes til å kaste typer til strenger. Du kan sette sammen strenger i Java på to forskjellige måter.

concat()-metoden

Concat()- metoden legger til den angitte strengen på slutten av den gitte strengen og returnerer deretter og returnerer deretter en ny streng dannet. Klart vi kan bruke concat()- metoden for å koble sammen tre eller flere strenger.

Concat()-metodesignaturen

public String concat(String str)

Metoden kobler sammen strengen str på slutten av gjeldende streng. For eksempel:

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

returnerer en ny streng "Hello World".

Eksempel på Concat()-metoden

La oss sette sammen to strenger etter initialiseringen, og deretter sette sammen flere strenger. Og enda et interessant eksempel: vi skal lage en metode som vil returnere forskjellige meldinger i henhold til 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");
    }

}

Utgangen er: Det er viktig å vite at concat()- metoden ikke endrer strengen, men oppretter en ny som et resultat av å slå sammen den nåværende og den som sendes som en parameter. Så metoden returnerer et nytt String -objekt, det er derfor du kan lage så lange kjeder av String Concat.

Sammenkobling med overbelastede operatorer "+" og "+="

Du kan bruke disse to operatorene på samme måte som med tall. De fungerer akkurat som concat() . La oss sette sammen strengen "Code" og strengen "Gym".

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

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

Vanligvis tillater ikke Java overbelastningsoperasjoner for brukerklasser, men disse to operatørene fungerer som overbelastet. Du tror kanskje at inne i + -operatoren skjuler det seg concat() , men faktisk brukes en annen mekanisme her. Hvis vi ser på Java-programmet bytecode, vil vi se at StringBuilder ble opprettet og dens append() metode brukes. Java-kompilatoren ser "+"-operatoren og innser at operander er strenger, 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 bare trenger å slå sammen strenger én gang, bruk concat()- metoden. For alle andre tilfeller er det bedre å bruke enten + eller Stringbuffer / StringBuilder- operatoren. Operatoren + brukes også til å konvertere typer. Hvis en av operandene er lik, for eksempel tallet og den andre er en streng, vil vi ved utgangen få 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 brukte instanceof for å sjekke om (myInt + myString) er en streng. Her er resultatet av dette programmet: Merk også at + -operatoren og concat() fungerer annerledes hvis en av strengene er null. Hvis en av operandene ved bruk av + eller +=- operatoren bare er én — en streng, så skjer, som vi allerede har sagt, typekonvertering. Det samme gjelder null. Vi får bare 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);
   }
}

Utgangen er: Hvis vi bruker concat() -metoden for samme operasjon, vil vi få en NullPointerException .

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

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

   }
}

Utgangen er: