java - simples - ¿La mejor forma de concatenar los objetos List of String?

concatenar en programacion java

Question

Esta pregunta ya tiene una respuesta aquí:

• Java: convertir List <String> a String 21 respuestas

¿Cuál es la mejor forma de concatenar una lista de objetos String? Estoy pensando en hacer esto:

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

// add elements

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

De alguna manera, me pareció más ordenado que usar el enfoque StringBuilder / StringBuffer.

¿Alguna idea / comentario?

Answer 1

De alguna manera, me pareció más ordenado que usar el enfoque StringBuilder / StringBuffer.

Supongo que depende de qué enfoque tomaste.

El método AbstractCollection # toString () simplemente itera sobre todos los elementos y los agrega a un StringBuilder. Por lo tanto, su método puede estar guardando algunas líneas de código, pero a costa de una mayor manipulación de Cadenas. Si ese intercambio es bueno, depende de usted.

Answer 2

¿Has visto esta entrada del blog Coding Horror?

La triste tragedia del teatro de micro-optimización

No estoy seguro de si es o no más "ordenado", pero desde el punto de vista del rendimiento, probablemente no importará demasiado.

Answer 3

Asumiendo que es más rápido simplemente mover un puntero / establecer un byte en nulo (o como implemente Java StringBuilder # setLength), en lugar de verificar una condición cada vez que pasa el bucle para ver cuándo agregar el delimitador, puede usar este método:

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 4

Dependiendo de la necesidad de rendimiento y la cantidad de elementos que se agregarán, esta podría ser una buena solución. Si la cantidad de elementos es alta, la reasignación de la memoria del Arraylist puede ser un poco más lenta que StringBuilder .

Answer 5

En java 8 también puedes usar un reductor, algo así como:

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

Answer 6

En lugar de depender de la implementación de ArrayList.toString() , puede escribir una línea, si está utilizando Java 8:

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

Si prefiere usar StringBuffer lugar de String, ya que String::concat tiene un tiempo de ejecución de O(n^2) , primero puede convertir cada String a StringBuffer .

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

Answer 7

Esta es la forma más elegante y limpia que he encontrado hasta ahora:

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

Answer 8

Me parece que StringBuilder será rápido y eficiente.

La forma básica se vería así:

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

Si eso es demasiado simplista (y probablemente lo sea), puede usar un enfoque similar y agregar un separador como este:

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

Estoy de acuerdo con los demás que respondieron a esta pregunta cuando dicen que no deben confiar en el método toString () de ArrayList de Java.

Answer 9

Prefiero String.join (list) en Java 8

Answer 10

Si está desarrollando para Android, hay TextUtils.join proporcionado por el SDK.

Answer 11

Siguiente variación de la respuesta de Peter Lawrey sin inicialización de una nueva secuencia cada vuelta del ciclo

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 12

Su enfoque depende de la implementación de ArrayList # toString () de Java.

Si bien la implementación está documentada en la API de Java y es poco probable que cambie, existe la posibilidad de que así sea. Es mucho más confiable implementarlo usted mismo (bucles, StringBuilders, recursión lo que más le guste).

Claro que este enfoque puede parecer "más limpio" o más "demasiado dulce" o "dinero", pero es, en mi opinión, un enfoque peor.

Answer 13

Una variación en la respuesta del 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 14

Usando Java 8+

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

o incluso

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

Answer 15

Utilice uno de los métodos de StringUtils.join en Apache Commons Lang.

import org.apache.commons.lang3.StringUtils;

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

Si tienes la suerte de estar usando Java 8, entonces es aún más fácil ... solo usa String.join

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

Answer 16

Utilizando la biblioteca Java funcional , impórtalas:

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

... entonces puedes hacer esto:

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

O, de forma genérica, si no tiene una lista de cadenas:

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

Answer 17

si tiene json en sus dependencias. puede usar el new JSONArray(list).toString()

Answer 18

Guava es una biblioteca bastante ordenada de Google:

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

Answer 19

ArrayList hereda su método toString() de AbstractCollection , es decir:

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

Construir la cadena usted mismo será mucho más eficiente.

Si realmente desea agregar las cadenas de antemano en algún tipo de lista, debe proporcionar su propio método para unirlas de manera eficiente, por ejemplo, de esta manera:

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