Diferencia entre concat() y + operador en Java

Las strings se definen como una array de caracteres. La diferencia entre una array de caracteres y una string es que la string termina con un carácter especial ‘\0’. Dado que las arrays son inmutables (no pueden crecer), las strings también son inmutables. Cada vez que se realiza un cambio en una String, se crea una String completamente nueva. La concatenación es el proceso de unión de extremo a extremo.

Método concat()

El método Java String concat() de la clase String ha estado presente dentro del paquete java.util que concatena una string al final de otra string. Este método devuelve una string con el valor de la string pasado al método, anexado al final de la string.

Ilustración:

Input:  String 1   : abc
        String 2   : def
        String n-1 : ...
        String n   : xyz
Output: abcdef...xyz  

Ejemplo:

// Java Program to Demonstrate Working of concat() method
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Custom input string 1
        String s = "Geeks ";
 
        // Custom input string 2 is passed as in arguments
        // Here we are adding it to end of same string
        s = s.concat("for Geeks");
 
        // Printing the concatenated string
        System.out.println(s);
    }
}

Geeks for Geeks

Ahora, detengámonos en el siguiente concepto en el que discutiremos 

 Operador ‘+’

El operador + se usa para concatenar strings en cualquier lado y es probable que estemos sumando dos números, lo que nos brinda la flexibilidad de agregar en cualquier lado. 

Ejemplo:

// Java Program to Demonstrate Working of + Operator
// over Strings
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Custom input strings
        String s1 = " Geeks ";
        String s2 = " for Geeks ";
 
        // Now using + operator over string where
        // flexibility is provided to add on either side
        String s3 = s1 + s2;
        String s4 = s2 + s1;
 
        // Printing strings formed after
        // using + operator
        System.out.println(s3);
        System.out.println(s4);
    }
}

 Geeks  for Geeks 
 for Geeks  Geeks 

Aunque el método concat() de la clase Strings y el operador + se usan para la concatenación de strings, existen algunas diferencias entre ellos que se muestran a continuación en el formato tabular de la siguiente manera:

Factor 1: Número de argumentos que toma el método concat() y el operador +

• El método concat() toma solo un argumento de string y lo concatena con otra string.
• El operador + toma cualquier número de argumentos y concatena todas las strings.

Ejemplo

// Java Program to Illustrate concat() method
// vs + operator in Strings
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        String s = "Geeks", t = "for", g = "geeks";
 
        // Printing combined string using + operator
        System.out.println(s + t + g);
 
        // Printing combined string using concat() method
        System.out.println(s.concat(t));
    }
}

Geeksforgeeks
Geeksfor

Factor 2: Tipo de argumentos

• El método string concat() solo toma argumentos de string, si hay algún otro tipo en los argumentos, generará un error.
• El operador + toma cualquier tipo y lo convierte en tipo de string y luego concatena las strings.

Factor 3: el método concat() genera la excepción java.lang.NullPointer

• El método concat() arroja una excepción NullPointer cuando una string se concatena con nulo
• El operador + no generó ninguna excepción cuando la string se concatena con nulo.

Ejemplo

// Java Program to Illustrate Raise of NullPointer Exception
// in case of concat() Method
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Input string 1
        String s = "Geeks";
        // Input string 2
        String r = null;
 
        // Combining above strings using + operator and
        //  printing resultant string
        System.out.println(s + r);
 
        // Combining above strings using concat() method and
        // printing resultant string
        // It raises an NullPointer Exception
        System.out.println(s.concat(r));
    }
}

Producción:

Factor 4: crea un nuevo objeto String

• El método concat() toma concatena dos strings y devuelve un nuevo objeto de string, solo que la longitud de la string es mayor que 0; de lo contrario, devuelve el mismo objeto.
• El operador + crea un nuevo objeto String cada vez, independientemente de la longitud de la string.

Ejemplo

// Java Program to Illustrate Creation of New String object
// in concat() method and + Operator
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Input strings
        String s = "Geeks", g = "";
 
        // Using concat() method over strings
        String f = s.concat(g);
 
        // Checking if both strings are equal
 
        // Case 1
        if (f == s)
 
            // Identical strings
            System.out.println("Both are same");
 
        else
 
            // Non-identical strings
            System.out.println("not same");
 
        // Case 2
        String e = s + g;
 
        // Again checking if both strings are equal
        if (e == s)
 
            // Identical strings
            System.out.println("Both are same");
        else
 
            // Non-identical strings
            System.out.println("not same");
    }
}

Both are same
not same

Factor 5: Rendimiento

El método concat() es mejor que el operador + porque crea un nuevo objeto solo cuando la longitud de la string es mayor que cero (0), pero el operador + siempre crea una nueva string independientemente de la longitud de la string.

Conclusión: De los dos programas anteriores, vemos que ambos están sumando de alguna manera dos strings directa o indirectamente. En el método concat, estamos obligados al agregar strings, ya que tenemos que pasar la string en el parámetro, mientras que en otro caso del operador ‘+’, es simplemente sumar strings probablemente matemáticas, por lo que no hay límite que podamos agregar a ambos lados.

A continuación se muestra la tabla para mostrar las principales diferencias entre ambos métodos: