Konkatenacja ciągów znaków w Javie

Konkatenacja łańcuchów Java to operacja łączenia dwóch lub więcej łańcuchów i zwracania nowego. Ponadto operacja konkatenacji może służyć do rzutowania typów na łańcuchy. Możesz łączyć łańcuchy w Javie na dwa różne sposoby.

metoda concat().

Metoda Concat() dołącza określony ciąg na końcu podanego ciągu, a następnie zwraca, a następnie zwraca utworzony nowy ciąg. Jasne, że możemy użyć metody concat() do połączenia trzech lub więcej łańcuchów.

Sygnatura metody concat().

public String concat(String str)

Metoda łączy ciąg str na końcu bieżącego ciągu. Na przykład:

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

zwraca nowy ciąg „Hello World”.

Przykład metody Concat().

Połączmy dwa łańcuchy po ich inicjalizacji, a następnie połączmy więcej ciągów. I jeszcze jeden ciekawy przykład: stworzymy metodę, która zwracałaby różne komunikaty w zależności od argumentu.

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

}

Dane wyjściowe to: Warto wiedzieć, że metoda concat() nie zmienia łańcucha, ale tworzy nowy w wyniku połączenia bieżącego i przekazanego jako parametr. Więc metoda zwraca nowy obiekt String , dlatego możesz tworzyć tak długie łańcuchy konkatowania String.

Konkatenacja przy użyciu przeciążonych operatorów „+” i „+=”

Możesz używać tych dwóch operatorów w taki sam sposób, jak w przypadku liczb. Działają podobnie jak concat() . Połączmy ciąg „Kod” i ciąg „Siłownia”.

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

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

Zwykle Java nie pozwala na operacje przeciążania klas użytkowników, ale te dwa operatory działają jako przeciążone. Można by pomyśleć, że wewnątrz operatora + kryje się concat() , ale w rzeczywistości zastosowano tutaj inny mechanizm. Jeśli spojrzymy na kod bajtowy programu Java, zobaczymy, że utworzono StringBuilder i użyto jego metody append() . Kompilator Java widzi operator „+” i zdaje sobie sprawę, że operandy są ciągami znaków, a nie typami pierwotnymi. Więc to działa jak 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) lub +?

Jeśli chcesz scalić łańcuchy tylko raz, użyj metody concat() . We wszystkich innych przypadkach lepiej jest użyć operatora + lub Stringbuffer / StringBuilder . Ponadto operator + służy do konwersji typów. Jeśli jeden z operandów jest równy, np. liczba, a drugi jest napisem, to na wyjściu otrzymamy napis. Przykład:

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

Użyliśmy instanceof, aby sprawdzić, czy (myInt + myString) jest ciągiem. Oto wynik działania tego programu: Zauważ również, że operator + i concat() działają inaczej, jeśli jeden z łańcuchów ma wartość null. Jeśli jednym z operandów przy użyciu operatora + lub += jest tylko jeden — ciąg znaków, to, jak już powiedzieliśmy, następuje konwersja typu. To samo dotyczy wartości zerowej. Po prostu otrzymamy nowy ciąg:

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

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

Dane wyjściowe to: Jeśli zastosujemy metodę concat() dla tej samej operacji, otrzymamy wyjątek NullPointerException .

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

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

   }
}

Dane wyjściowe to: