Il modo migliore per concatenare Elenco di oggetti stringa?

Question

Qual è il modo migliore per concatenare un elenco di oggetti String? Sto pensando di fare in questo modo:

List<String> sList = new ArrayList<String>(); 

// add elements 

if (sList != null) 
{ 
    String listString = sList.toString(); 
    listString = listString.subString(1, listString.length() - 1); 
} 

in qualche modo trovato questo per essere più ordinato che utilizzare il metodo StringBuilder/StringBuffer.

Qualche idea/commento?

Answer 1

L'approccio dipende dall'implementazione di ArrayList # toString() di Java.

Mentre l'implementazione è documentata nell'API Java e molto improbabile da modificare, c'è una possibilità che potrebbe. È molto più affidabile implementarlo da solo (loop, StringBuilder, ricorsione qualunque cosa ti piaccia di più).

Sicuramente questo approccio può sembrare "più ordinato" o più "troppo dolce" o "denaro" ma è, a mio parere, un approccio peggiore.

Answer 2

in qualche modo trovato questo per essere più ordinato rispetto utilizzando l'approccio StringBuilder/StringBuffer .

Suppongo che dipenda dall'approccio scelto.

Il metodo AbstractCollection # toString() esegue semplicemente un'iterazione su tutti gli elementi e li aggiunge a uno StringBuilder. Quindi il tuo metodo potrebbe salvare poche righe di codice ma a costo di una manipolazione extra di String. Che il tradeoff sia buono dipende da te.

Answer 3

A seconda dell'esigenza di prestazioni e quantità di elementi da aggiungere, questa potrebbe essere una soluzione ok. Se la quantità di elementi è elevata, la ridistribuzione della memoria di Arraylist potrebbe essere leggermente più lenta di StringBuilder.

Answer 4

ArrayList eredita la sua toString() -Metodo da AbstractCollection, vale a dire:

public String toString() { 
    Iterator<E> i = iterator(); 
    if (! i.hasNext()) 
     return "[]"; 

    StringBuilder sb = new StringBuilder(); 
    sb.append('['); 
    for (;;) { 
     E e = i.next(); 
     sb.append(e == this ? "(this Collection)" : e); 
     if (! i.hasNext()) 
      return sb.append(']').toString(); 
     sb.append(", "); 
    } 
} 

Costruire la stringa da soli sarà molto più efficiente.

---

Se davvero si vuole aggregare le stringhe in anticipo in una sorta di lista, è necessario fornire il proprio metodo per accedere in modo efficiente loro, ad esempio, In questo modo:

static String join(Collection<?> items, String sep) { 
    if(items.size() == 0) 
     return ""; 

    String[] strings = new String[items.size()]; 
    int length = sep.length() * (items.size() - 1); 

    int idx = 0; 
    for(Object item : items) { 
     String str = item.toString(); 
     strings[idx++] = str; 
     length += str.length(); 
    } 

    char[] chars = new char[length]; 
    int pos = 0; 

    for(String str : strings) { 
     str.getChars(0, str.length(), chars, pos); 
     pos += str.length(); 

     if(pos < length) { 
      sep.getChars(0, sep.length(), chars, pos); 
      pos += sep.length(); 
     } 
    } 

    return new String(chars); 
} 

Answer 5

Hai visto questo articolo sul blog di Coding Horror?

The Sad Tragedy of Micro-Optimization Theater

Io non sono shure se sia o non è "più ordinato", ma da un punto di vista delle prestazioni, probabilmente non ha molta importanza.

Answer 6

Mi sembra che lo StringBuilder sia veloce ed efficiente.

La forma di base sarebbe simile a questa:

public static String concatStrings(List<String> strings) 
{ 
    StringBuilder sb = new StringBuilder(); 
    for(String s: strings) 
    { 
     sb.append(s); 
    } 
    return sb.toString();  
} 

Se questo è troppo semplicistico (e probabilmente lo è), è possibile utilizzare un approccio simile e aggiungere un separatore come questo:

public static String concatStringsWSep(List<String> strings, String separator) 
{ 
    StringBuilder sb = new StringBuilder(); 
    for(int i = 0; i < strings.size(); i++) 
    { 
     sb.append(strings.get(i)); 
     if(i < strings.size() - 1) 
      sb.append(separator); 
    } 
    return sb.toString();    
} 

Sono d'accordo con gli altri che hanno risposto a questa domanda quando dicono che non si deve fare affidamento sul metodo toString() di ArrayList di Java.

Answer 7

Una variante di risposta di codefin

public static String concatStringsWSep(Iterable<String> strings, String separator) { 
    StringBuilder sb = new StringBuilder(); 
    String sep = ""; 
    for(String s: strings) { 
     sb.append(sep).append(s); 
     sep = separator; 
    } 
    return sb.toString();       
} 

Answer 8

Utilizzare uno dei i StringUtils.join metodi di Apache Commons Lang.

import org.apache.commons.lang3.StringUtils; 

String result = StringUtils.join(list, ", "); 

Se siete abbastanza fortunati da essere utilizzando Java 8, quindi è ancora più facile ... basta usare String.join

String result = String.join(", ", list); 

Answer 9

Utilizzando la libreria Functional Java, importarli:

import static fj.pre.Monoid.stringMonoid; 
import static fj.data.List.list; 
import fj.data.List; 

... allora puoi fare questo:

List<String> ss = list("foo", "bar", "baz"); 
String s = stringMonoid.join(ss, ", "); 

In alternativa, la via generica, se non si dispone di una lista di stringhe:

public static <A> String showList(List<A> l, Show<A> s) { 
    return stringMonoid.join(l.map(s.showS_()), ", "); 
} 

Answer 10

Supponendo è più veloce per spostare solo un puntatore/set un byte null (o comunque Java implementa StringBuilder # setlength), piuttosto che verificare una condizione di volta in volta attraverso il ciclo di vedere quando per aggiungere il delimitatore, è possibile utilizzare questo metodo:

public static String Intersperse (Collection<?> collection, String delimiter) 
{ 
    StringBuilder sb = new StringBuilder(); 
    for (Object item : collection) 
    { 
     if (item == null) continue; 
     sb.append (item).append (delimiter); 
    } 
    sb.setLength (sb.length() - delimiter.length()); 
    return sb.toString(); 
}

Answer 11

Guava è una libreria piuttosto pulito da Google:

Joiner joiner = Joiner.on(", "); 
joiner.join(sList); 

Answer 12

variazione Avanti sulla risposta di Pietro Lawrey senza inizializzazione di una nuova stringa ogni ciclo girare

String concatList(List<String> sList, String separator) 
{ 
    Iterator<String> iter = sList.iterator(); 
    StringBuilder sb = new StringBuilder(); 

    while (iter.hasNext()) 
    { 
     sb.append(iter.next()).append(iter.hasNext() ? separator : ""); 
    } 
    return sb.toString(); 
} 

Answer 13

Utilizzo di Java 8+

String str = list.stream().collect(Collectors.joining()) 

o anche

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

Answer 14

preferisco string.join (elenco) in Java 8

Answer 15

Se si sta sviluppando per Android, ci sono s TextUtils.join fornito dall'SDK.

Answer 16

se avete problemi con le dipendenze.è possibile utilizzare new JSONArray(list).toString()

Answer 17

in Java 8 è possibile utilizzare anche un riduttore, qualcosa come:

public static String join(List<String> strings, String joinStr) { 
    return strings.stream().reduce("", (prev, cur) -> prev += (cur + joinStr)); 
} 

Answer 18

Piuttosto che a seconda ArrayList.toString() implementazione, si potrebbe scrivere un one-liner, se si utilizza Java 8:

String result = sList.stream() 
        .reduce("", String::concat); 

Se si preferisce usare StringBuffer invece di String dal String::concat ha un'autonomia di O(n^2), è possibile convertire tutti i String-StringBuffer prima.

StringBuffer result = sList.stream() 
          .map(StringBuffer::new) 
          .reduce(new StringBuffer(""), StringBuffer::append); 

Answer 19

Questo è il modo più elegante e pulito che ho trovato finora:

list.stream().collect(Collectors.joining(delimiter));