Konwertuj tablicę ciągów na ciąg w Javie

Chcę kodu Java do konwersji tablicy ciągów na ciąg.

Jeśli chcesz tylko zrzutu tablicy w stylu „debugowania”:

String str = Arrays.toString(arr);

lub, dla większej kontroli (przed Java 8):

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

(Java 8 i nowsze):

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

A jeśli pochodzisz z Androida:

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

Możesz zmodyfikować powyższe w zależności od tego, jakie znaki, jeśli jakieś, chcesz pomiędzy ciągami.

Możesz zobaczyć prawie identyczny kod z kodem wcześniejszym niż Java 8, ale używając StringBuffer- StringBuilderto nowsza klasa, która nie jest bezpieczna dla wątków, ale dlatego ma lepszą wydajność w jednym wątku, ponieważ eliminuje niepotrzebną synchronizację. Krótko mówiąc, lepiej jest używaćStringBuilder w 99% przypadków - pod względem funkcjonalności oba są identyczne.

NIE używaj ciągu znaków i po prostu dołącz do niego znak + =, tak jak pokazano niektóre odpowiedzi. To wysyła GC przez dach, ponieważ tworzysz i wyrzucasz tyle obiektów łańcuchowych, ile masz elementów w tablicy. W przypadku małych tablic różnica może nie być zauważalna, ale w przypadku dużych tablice mogą być wolniejsze o rząd wielkości.

Użyj wspólnego Apache StringUtils.join(). Pobiera tablicę jako parametr (a także przeciążenia Iterablei Iteratorparametry) i wywołuje toString()każdy element (jeśli nie jest pusty), aby uzyskać reprezentację ciągu każdego elementu. Reprezentacja ciągu każdego elementu jest następnie łączona w jeden ciąg z separatorem pomiędzy nimi, jeśli jest określony:

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

Produkuje:

a-b-1

Lubię do tego używać Google Guava Joiner , np .:

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

wytworzy taki sam ciąg znaków jak:

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

ETA: Java 8 ma teraz podobne wsparcie:

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

Nie widzę obsługi pomijania wartości zerowych, ale łatwo to obejść.

Możesz to zrobić, biorąc pod uwagę tablicę atypu pierwotnego:

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

W Javie 8 najprostszym sposobem jest:

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

W ten sposób możesz wybrać dowolny ogranicznik.

Wypróbuj Arrays.deepToString metodę .

Zwraca ciąg znaków reprezentujący „głęboką zawartość” określonej tablicy. Jeśli tablica zawiera inne tablice jako elementy, reprezentacja ciągu zawiera ich zawartość i tak dalej. Ta metoda jest przeznaczona do konwertowania wielowymiarowych tablic na ciągi

Wypróbuj metody przeciążone Arrays.toString .

Albo spróbuj tego poniżej ogólnej implementacji:

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

Poniżej znajduje się przykład konwersji z tablicy na ciąg znaków.

    ArrayToString klasy publicznej
    {

        public static void main (Argumenty String [])
        {
            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

Jeśli nie masz wyboru, ale używasz Java 6 lub 7, powinieneś użyć łączenia Divide & Conquer.

Chcesz kodu, który tworzy ciąg znaków z arrayList,

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

możesz to zrobić na 2 sposoby: używając String jako wyniku lub StringBuffer / StringBuilder.

Przykład:

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

... ale nie jest to dobra praktyka ze względu na wydajność. Lepiej jest używać StringBuffer (wątki bezpieczne) lub StringBuilder, które są bardziej odpowiednie do dodawania ciągów

Użyj metody łączenia biblioteki StringUtils 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);

Jeśli wiesz, ile elementów ma tablica, możesz to zrobić w prosty sposób:

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