Concatenación de cadenas en Java

La concatenación de cadenas Java es una operación para unir dos o más cadenas y devolver una nueva. Además, la operación de concatenación se puede usar para convertir tipos en cadenas. Puede concatenar cadenas en Java de dos maneras diferentes.

método concat()

El método Concat() agrega la cadena especificada al final de la cadena dada y luego regresa y luego regresa una nueva cadena formada. Seguro que podemos usar el método concat() para unir tres o más cadenas.

La firma del método concat()

public String concat(String str)

El método concatena la cadena str al final de la cadena actual. Por ejemplo:

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

devuelve una nueva cadena "Hello World".

Ejemplo del método Concat()

Concatenemos dos cadenas después de su inicialización, luego concatenemos más cadenas. Y un ejemplo más interesante: vamos a crear un método que devuelva diferentes mensajes según el argumento.

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

}

La salida es: Es importante saber que el método concat() no cambia la cadena, sino que crea una nueva como resultado de la fusión de la actual y la pasada como parámetro. Entonces, el método devuelve un nuevo objeto String , es por eso que puede crear cadenas tan largas de String concat.

Concatenación usando operadores sobrecargados "+" y "+="

Puede usar estos dos operadores de la misma manera que con los números. Funcionan igual que concat() . Concatenemos la cadena "Código" y la cadena "Gimnasio".

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

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

Por lo general, Java no permite operaciones de sobrecarga para clases de usuario, pero estos dos operadores funcionan como sobrecargados. Podrías pensar que dentro del operador + se esconde concat() , pero de hecho, aquí se usa otro mecanismo. Si observamos el código de bytes del programa Java, veremos que se creó StringBuilder y se utilizó su método append() . El compilador de Java ve el operador "+" y se da cuenta de que los operandos son cadenas, no tipos primitivos. Entonces funciona como 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) o + ?

Si necesita fusionar cadenas solo una vez, use el método concat() . Para todos los demás casos, es mejor usar el operador + o Stringbuffer / StringBuilder . Además, el operador + se usa para convertir tipos. Si uno de los operandos es igual, por ejemplo, el número y el segundo es una cadena, a la salida obtendremos una cadena. Ejemplo:

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

Usamos instanceof para verificar si (myInt + myString) es una cadena. Aquí está la salida de este programa: También tenga en cuenta que el operador + y concat() funcionan de manera diferente si una de las cadenas es nula. Si uno de los operandos cuando se usa el operador + o += es solo uno, una cadena, entonces, como ya dijimos, se produce la conversión de tipo. Lo mismo se aplica a nulo. Obtendremos una nueva cadena:

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

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

La salida es: Si aplicamos el método concat() para la misma operación, obtendremos una NullPointerException .

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

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

   }
}

La salida es: