Converter array de strings em um string em Java

Eu quero o código Java para converter uma matriz de strings em uma string.

Se você deseja apenas um despejo "de estilo de depuração" de uma matriz:

String str = Arrays.toString(arr);

ou, para mais controle (antes do Java 8):

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

(Java 8 e superior):

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

E se você vem do ângulo do Android:

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

Você pode modificar o acima, dependendo de quais caracteres, se houver, você deseja entre as strings.

Você pode ver um código quase idêntico ao código anterior ao Java 8, mas usando StringBuffer- StringBuilderé uma classe mais nova que não é segura para threads, mas, portanto, tem melhor desempenho em um único thread, pois elimina a sincronização desnecessária. Em resumo, é melhor usar StringBuilderem 99% dos casos - em termos de funcionalidade, os dois são idênticos.

NÃO use uma string e apenas a acrescente com + = como algumas das respostas mostradas aqui. Isso envia o GC para o alto porque você está criando e jogando fora tantos objetos de string quanto itens em sua matriz. Para matrizes pequenas, você pode não perceber a diferença, mas para matrizes grandes, pode ser uma ordem de magnitude mais lenta.

Use o Apache commons StringUtils.join(). Ele pega uma matriz como parâmetro (e também possui sobrecargas para Iterablee Iteratorparâmetros) e chama toString()cada elemento (se não for nulo) para obter a representação de sequência de cada elemento. Cada representação de sequência de elementos é unida em uma sequência com um separador entre eles se um for especificado:

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

Produz:

a-b-1

Eu gosto de usar o Guava Joiner do Google para isso, por exemplo:

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

produziria a mesma String que:

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

ETA: Java 8 tem suporte semelhante agora:

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

Não consigo ver o suporte para ignorar valores nulos, mas isso é facilmente contornado.

Você poderia fazer isso, considerando uma matriz ado 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();

No Java 8, a maneira mais simples que penso é:

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

Dessa forma, você pode escolher um delimitador arbitrário.

Experimente o método Arrays.deepToString .

Retorna uma representação de seqüência de caracteres do "conteúdo profundo" da matriz especificada. Se a matriz contiver outras matrizes como elementos, a representação da sequência conterá seu conteúdo e assim por diante. Este método foi projetado para converter matrizes multidimensionais em strings

Experimente os métodos sobrecarregados Arrays.toString .

Ou então, tente isso abaixo da implementação genérica:

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

A seguir, é apresentado um exemplo de conversão de matriz em cadeia.

    classe 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

Se você não tiver a opção de usar o Java 6 ou 7, use a junção Divide & Conquer.

Você deseja um código que produza string a partir de arrayList,

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

você pode fazer isso de duas maneiras: usando String como resultado ou StringBuffer / StringBuilder.

Exemplo:

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

... mas isso não é uma boa prática por motivos de desempenho. Melhor é usar StringBuffer (threads seguros) ou StringBuilder, que são mais apropriados para adicionar Strings

Use o método de junção da biblioteca StringUtils do 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);

Se você souber quantos elementos a matriz possui, uma maneira simples é fazer isso:

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