Convierta una matriz de cadenas en una cadena en Java

Quiero el código Java para convertir una matriz de cadenas en una cadena.

Si solo desea un volcado de "estilo de depuración" de una matriz:

String str = Arrays.toString(arr);

o, para más control (antes de Java 8):

StringBuilder builder = new StringBuilder();
for(String s : arr) {
    builder.append(s);
}
String str = builder.toString();

(Java 8 y superior):

String str = String.join(",", arr);

Y si vienes desde el ángulo de Android:

String str = TextUtils.join(",", arr);

Puede modificar lo anterior dependiendo de qué caracteres, si los hay, desea entre cadenas.

Es posible que vea cerca de código idéntico al código de Java pre-8, pero usando StringBuffer- StringBuilderes una nueva clase que no es seguro para subprocesos, pero por lo tanto tiene un mejor rendimiento en un solo hilo, ya que elimina la sincronización innecesaria. En resumen, es mejor usarlo StringBuilderen el 99% de los casos: en cuanto a funcionalidad, los dos son idénticos.

NO use una cadena y simplemente agregue con + = como algunas de las respuestas que se muestran aquí. Esto envía el GC a través del techo porque está creando y tirando tantos objetos de cadena como elementos en su matriz. Para las matrices pequeñas, es posible que no note la diferencia, pero para las grandes puede ser mucho más lenta.

Usa los bienes comunes de Apache StringUtils.join(). Toma una matriz, como parámetro (y también tiene sobrecargas Iterabley Iteratorparámetros) y llama toString()a cada elemento (si no es nulo) para obtener la representación de cadena de cada elemento. Cada representación de cadena de elementos se une en una cadena con un separador en el medio si se especifica uno:

String joinedString = StringUtils.join(new Object[]{"a", "b", 1}, "-");
System.out.println(joinedString);

Produce:

a-b-1

Me gusta usar Guava Joiner de Google para esto, por ejemplo:

Joiner.on(", ").skipNulls().join("Harry", null, "Ron", "Hermione");

produciría la misma cadena que:

new String("Harry, Ron, Hermione");

ETA: Java 8 tiene soporte similar ahora:

String.join(", ", "Harry", "Ron", "Hermione");

No puedo ver el soporte para omitir valores nulos, pero eso es fácil de solucionar.

Podría hacer esto, dada una matriz ade tipo primitivo:

StringBuffer result = new StringBuffer();
for (int i = 0; i < a.length; i++) {
   result.append( a[i] );
   //result.append( optional separator );
}
String mynewstring = result.toString();

Desde Java 8, la forma más simple que creo es:

    String[] array = { "cat", "mouse" };
    String delimiter = "";
    String result = String.join(delimiter, array);

De esta manera, puede elegir un delimitador arbitrario.

Prueba el Arrays.deepToString método .

Devuelve una representación de cadena del "contenido profundo" de la matriz especificada. Si la matriz contiene otras matrices como elementos, la representación de cadena contiene su contenido, etc. Este método está diseñado para convertir matrices multidimensionales en cadenas

Pruebe los métodos sobrecargados de Arrays.toString .

O bien, pruebe esta implementación genérica a continuación:

public static void main(String... args) throws Exception {

    String[] array = {"ABC", "XYZ", "PQR"};

    System.out.println(new Test().join(array, ", "));
}

public <T> String join(T[] array, String cement) {
    StringBuilder builder = new StringBuilder();

    if(array == null || array.length == 0) {
        return null;
    }

    for (T t : array) {
        builder.append(t).append(cement);
    }

    builder.delete(builder.length() - cement.length(), builder.length());

    return builder.toString();
}

El siguiente es un ejemplo de conversión de matriz a cadena.

    clase pública ArrayToString
    {

        public static void main (String [] args)
        {
            String [] strArray = new String [] {"Java", "PHP", ".NET", "PERL", "C", "COBOL"};


        String newString = Arrays.toString(strArray);

        newString = newString.substring(1, newString.length()-1);

        System.out.println("New New String: " + newString);
    }
}

String[] strings = new String[25000];
for (int i = 0; i < 25000; i++) strings[i] = '1234567';

String result;
result = "";
for (String s : strings) result += s;
//linear +: 5s

result = "";
for (String s : strings) result = result.concat(s);
//linear .concat: 2.5s

result = String.join("", strings);
//Java 8 .join: 3ms

Public String join(String delimiter, String[] s)
{
    int ls = s.length;
    switch (ls)
    {
        case 0: return "";
        case 1: return s[0];
        case 2: return s[0].concat(delimiter).concat(s[1]);
        default:
            int l1 = ls / 2;
            String[] s1 = Arrays.copyOfRange(s, 0, l1); 
            String[] s2 = Arrays.copyOfRange(s, l1, ls); 
            return join(delimiter, s1).concat(delimiter).concat(join(delimiter, s2));
    }
}
result = join("", strings);
// Divide&Conquer join: 7ms

Si no tiene la opción, pero para usar Java 6 o 7, entonces debe usar Divide & Conquer join.

Desea código que produzca una cadena de arrayList,

Iterate through all elements in list and add it to your String result

puede hacer esto de 2 maneras: usando String como resultado o StringBuffer / StringBuilder.

Ejemplo:

String result = "";
for (String s : list) {
    result += s;
}

... pero esto no es una buena práctica por razones de rendimiento. Mejor es usar StringBuffer (hilos seguros) o StringBuilder que son más apropiados para agregar cadenas

Utilice el método de combinación de la biblioteca StringUtils de Apache Commons .

String[] stringArray = {"a","b","c"};
StringUtils.join(stringArray, ",");

String array[]={"one","two"};
String s="";

for(int i=0;i<array.length;i++)
{
  s=s+array[i];
}

System.out.print(s);

Si sabe cuántos elementos tiene la matriz, una manera simple es hacer esto:

String appendedString = "" + array[0] + "" + array[1] + "" + array[2] + "" + array[3];