pretty - print json java

¿Maneras más claras de delimitar las comas de una lista?

Question

¿Cuál es la forma más clara de delimitar las comas de una lista en Java?

Conozco varias maneras de hacerlo, pero me pregunto cuál es la mejor manera (donde "mejor" significa más claro y / o más corto, no el más eficiente.

Tengo una lista y quiero recorrerla, imprimiendo cada valor. Quiero imprimir una coma entre cada elemento, pero no después de la última (ni antes de la primera).

List --> Item ( , Item ) *
List --> ( Item , ) * Item

Solución de muestra 1:

boolean isFirst = true;
for (Item i : list) {
  if (isFirst) {
    System.out.print(i);        // no comma
    isFirst = false;
  } else {
    System.out.print(", "+i);   // comma
  }
}

Solución de muestra 2: crea una sublista:

if (list.size()>0) {
  System.out.print(list.get(0));   // no comma
  List theRest = list.subList(1, list.size());
  for (Item i : theRest) {
    System.out.print(", "+i);   // comma
  }
}

Solución de muestra 3:

  Iterator<Item> i = list.iterator();
  if (i.hasNext()) {
    System.out.print(i.next());
    while (i.hasNext())
      System.out.print(", "+i.next());
  }

Estos tratan el primer artículo especialmente; uno podría en cambio tratar al último especialmente.

Por cierto, así es como se implementa List toString (se hereda de AbstractCollection ), en Java 1.6:

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

Sale del ciclo temprano para evitar la coma después del último elemento. Por cierto: esta es la primera vez que recuerdo haber visto "(esta Colección)"; aquí está el código para provocarlo:

List l = new LinkedList();
l.add(l);
System.out.println(l);

Doy la bienvenida a cualquier solución, incluso si usan bibliotecas inesperadas (¿regular?); y también soluciones en otros lenguajes además de Java (por ejemplo, creo que Python / Ruby tienen una función intercalada , ¿cómo se implementa?).

Aclaración : por bibliotecas, me refiero a las bibliotecas estándar de Java. Para otras bibliotecas, las considero con otros idiomas y me interesa saber cómo se implementan.

El kit de herramientas EDIT mencionó una pregunta similar: Última iteración del bucle for mejorado en java

Y otro: ¿el último elemento en un ciclo merece un tratamiento separado?

Answer 1

Método

String join(List<Object> collection, String delimiter){
    StringBuilder stringBuilder = new StringBuilder();
    int size = collection.size();
    for (Object value : collection) {
        size --;
        if(size > 0){
            stringBuilder.append(value).append(delimiter);
        }
    }

    return stringBuilder.toString();
}

Uso

Dado el conjunto de [1,2,3]

join(myArray, ",") // 1,2,3

Answer 2

(Copie y pegue mi propia respuesta desde here .) Muchas de las soluciones descritas aquí son un poco exageradas, en mi humilde opinión, especialmente aquellas que dependen de bibliotecas externas. Hay una agradable y clara expresión idiomática para lograr una lista separada por comas que siempre he usado. Se basa en el operador condicional (?):

Editar : solución original correcta, pero no óptima según los comentarios. Probando por segunda vez:

int[] array = {1, 2, 3};
StringBuilder builder = new StringBuilder();
for (int i = 0 ;  i < array.length; i++)
       builder.append(i == 0 ? "" : ",").append(array[i]);

Ahí va, en 4 líneas de código que incluyen la declaración de la matriz y el StringBuilder.

2da edición : si se trata de un iterador:

    List<Integer> list = Arrays.asList(1, 2, 3);
    StringBuilder builder = new StringBuilder();
    for (Iterator it = list.iterator(); it.hasNext();)
        builder.append(it.next()).append(it.hasNext() ? "," : "");

Answer 3

Basado en la implementación List toString de Java:

Iterator i = list.iterator();
for (;;) {
  sb.append(i.next());
  if (! i.hasNext()) break;
  ab.append(", ");
}

Utiliza una gramática como esta:

List --> (Item , )* Item

Al ser basado en el último lugar en lugar de en el primero, puede buscar saltos de coma con la misma prueba para verificar el final de la lista. Creo que este es muy elegante, pero no estoy seguro acerca de la claridad.

Answer 4

Como su delimitador es "," puede usar cualquiera de los siguientes:

public class StringDelim {

    public static void removeBrackets(String string) {
        System.out.println(string.substring(1, string.length() - 1));
    }

    public static void main(String... args) {
        // Array.toString() example
        String [] arr = {"Hi" , "My", "name", "is", "br3nt"};
        String string = Arrays.toString(arr);
        removeBrackets(string);

        // List#toString() example
        List<String> list = new ArrayList<String>();
        list.add("Hi");
        list.add("My");
        list.add("name");
        list.add("is");
        list.add("br3nt");
        string = list.toString();
        removeBrackets(string);

        // Map#values().toString() example
        Map<String, String> map = new LinkedHashMap<String, String>();
        map.put("1", "Hi");
        map.put("2", "My");
        map.put("3", "name");
        map.put("4", "is");
        map.put("5", "br3nt");
        System.out.println(map.values().toString());
        removeBrackets(string);

        // Enum#toString() example
        EnumSet<Days> set = EnumSet.allOf(Days.class);
        string = set.toString();
        removeBrackets(string);
    }

    public enum Days {
        MON("Monday"),
        TUE("Tuesday"),
        WED("Wednesday"),
        THU("Thursday"),
        FRI("Friday"),
        SAT("Saturday"),
        SUN("Sunday");

        private final String day;

        Days(String day) {this.day = day;}
        public String toString() {return this.day;}
    }
}

Si su delimitador es CUALQUIER COSA, entonces esto no va a funcionar para usted.

Answer 5

En Python es fácil

",". únete (tu lista)

En C # hay un método estático en la clase String

String.Join (",", yourlistofstrings)

Lo siento, no estoy seguro acerca de Java, pero pensé en conectarme mientras preguntaba sobre otros idiomas. Estoy seguro de que habría algo similar en Java.

Answer 6

En mi opinión, este es el más simple de leer y entender:

StringBuilder sb = new StringBuilder();
for(String string : strings) {
    sb.append(string).append('','');
}
sb.setLength(sb.length() - 1);
String result = sb.toString();

Answer 7

Esto es muy breve, muy claro, pero le da a mi sensibilidad los horrores progresivos. También es un poco incómodo adaptarse a diferentes delimitadores, especialmente si es un String (no char).

for (Item i : list)
  sb.append('','').append(i);
if (sb.charAt(0)=='','') sb.deleteCharAt(0);

Inspirado por: Última iteración de Enhanced for loop in java

Answer 8

Hay una manera bonita de lograr esto usando Java 8:

List<String> list = Arrays.asList(array);
String joinedString = String.join(",", list);

Answer 9

Java 8 proporciona varias formas nuevas de hacer esto:

• El método de join en String .
• Un colector de joining para transmisiones de la clase de Collectors .
• La clase StringJoiner .

Ejemplo:

// Util method for strings and other char sequences
List<String> strs = Arrays.asList("1", "2", "3");
String listStr1 = String.join(",", strs);

// For any type using streams and collectors
List<Object> objs = Arrays.asList(1, 2, 3);
String listStr2 = objs.stream().map(i -> i.toString()).collect(joining(",", "[", "]"));

// Using the new StringJoiner class
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.setEmptyValue("<empty>");
for (Integer i : objs) {
  joiner.add(i.toString());
}
String listStr3 = joiner.toString();

El enfoque que usa streams supone que import static java.util.stream.Collectors.joining; .

Answer 10

Me gusta esta solución:

String delim = " - ", string = "";

for (String item : myCollection)
    string += delim + item;

string = string.substring(delim.length());

Supongo que también puede usar StringBuilder.

Answer 11

Me gusta un poco este enfoque, que encontré en un blog hace algún tiempo. Lamentablemente, no recuerdo el nombre / URL del blog.

Puede crear una clase de utilidad / ayudante que se vea así:

private class Delimiter
{
    private final String delimiter;
    private boolean first = true;

    public Delimiter(String delimiter)
    {
        this.delimiter = delimiter;
    }

    @Override
    public String toString()
    {
        if (first) {
            first = false;
            return "";
        }

        return delimiter;
    }
}

Usar la clase de ayuda es simple como esto:

StringBuilder sb = new StringBuilder();
Delimiter delimiter = new Delimiter(", ");

for (String item : list) {
    sb.append(delimiter);
    sb.append(item);
}

Answer 12

Ninguna de las respuestas usa recursividad hasta ahora ...

public class Main {

    public static String toString(List<String> list, char d) {
        int n = list.size();
        if(n==0) return "";
        return n > 1 ? Main.toString(list.subList(0, n - 1), d) + d
                  + list.get(n - 1) : list.get(0);
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList(new String[]{"1","2","3"});
        System.out.println(Main.toString(list, '',''));
    }

}

Answer 13

No lo compilé ... pero debería funcionar (o estar cerca de trabajar).

public static <T> String toString(final List<T> list, 
                                  final String delim)
{
    final StringBuilder builder;

    builder = new StringBuilder();

    for(final T item : list)
    {
        builder.append(item);
        builder.append(delim);
    }

    // kill the last delim
    builder.setLength(builder.length() - delim.length());

    return (builder.toString());
}

Answer 14

Para pre Java-8:

Vea también #285523

String delim = "";
for (Item i : list) {
    sb.append(delim).append(i);
    delim = ",";
}

Actualización desde Java 8:

Usando StringJoiner :

StringJoiner joiner = new StringJoiner(",");
for (Item item : list) {
    joiner.add(item.toString());
}
return joiner.toString();

Usando Stream y Collectors :

return list.stream().
       map(Object::toString).
       collect(Collectors.joining(",")).toString();

Answer 15

Si puede usar Groovy (que se ejecuta en la JVM):

def list = [''a'', ''b'', ''c'', ''d'']
println list.join('','')

Answer 16

Si usa Spring Framework, puede hacerlo con StringUtils :

public static String arrayToDelimitedString(Object[] arr)
public static String arrayToDelimitedString(Object[] arr, String delim)
public static String collectionToCommaDelimitedString(Collection coll)
public static String collectionToCommaDelimitedString(Collection coll, String delim)

Answer 17

También puede agregar incondicionalmente la cadena delimitadora, y después del bucle eliminar el delimitador adicional al final. Entonces una "si la lista está vacía y luego devuelve esta cadena" al principio le permitirá evitar la verificación al final (ya que no puede eliminar los caracteres de una lista vacía)

Entonces la pregunta es realmente:

"Dado un ciclo y un si, ¿cuál crees que es la forma más clara de tenerlos juntos?"

Answer 18

Una opción para el ciclo foreach es:

StringBuilder sb = new StringBuilder();
for(String s:list){
  if (sb.length()>0) sb.append(",");
  sb.append(s);
}

Answer 19

Usualmente hago esto:

StringBuffer sb = new StringBuffer();
Iterator it = myList.iterator();
if (it.hasNext()) { sb.append(it.next().toString()); }
while (it.hasNext()) { sb.append(",").append(it.next().toString()); }

Aunque creo que voy a realizar este control a partir de ahora según la implementación de Java;)

Answer 20

Usualmente uso algo similar a la versión 3. Funciona bien c / c ++ / bash / ...: P

Answer 21

Joiner.on(",").join(myList)

Joiner .

Answer 22

String delimiter = ",";
StringBuilder sb = new StringBuilder();
for (Item i : list) {
    sb.append(delimiter).append(i);
}
sb.toString().replaceFirst(delimiter, "");

Answer 23

StringBuffer result = new StringBuffer();
for(Iterator it=list.iterator; it.hasNext(); ) {
  if (result.length()>0)
    result.append(", ");
  result.append(it.next());
}

Actualización : como Dave Webb mencionó en los comentarios, esto puede no producir resultados correctos si los primeros elementos de la lista son cadenas vacías.

Answer 24

StringBuffer sb = new StringBuffer();

for (int i = 0; i < myList.size(); i++)
{ 
    if (i > 0) 
    {
        sb.append(", ");
    }

    sb.append(myList.get(i)); 
}

Answer 25

for(int i=0, length=list.size(); i<length; i++)
  result+=(i==0?"":", ") + list.get(i);

Answer 26

if (array.length>0)          // edited in response Joachim''s comment
  sb.append(array[i]);
for (int i=1; i<array.length; i++)
  sb.append(",").append(array[i]);

¿Basado en una forma más clara de delimitar las comas de una lista (Java)?

Usando esta idea: ¿el último elemento en un ciclo merece un tratamiento separado?

Answer 27

org.apache.commons.lang3.StringUtils.join(list,",");

Answer 28

private String betweenComma(ArrayList<String> strings) {
    String united = "";
    for (String string : strings) {
        united = united + "," + string;
    }
    return united.replaceFirst(",", "");
}

Answer 29

public String toString(List<Item> items)
{
    StringBuilder sb = new StringBuilder("[");

    for (Item item : items)
    {
        sb.append(item).append(", ");
    }

    if (sb.length() >= 2)
    {
        //looks cleaner in C# sb.Length -= 2;
        sb.setLength(sb.length() - 2);
    }

    sb.append("]");

    return sb.toString();
}

Answer 30

public static String join (List<String> list, String separator) {
  String listToString = "";

  if (list == null || list.isEmpty()) {
   return listToString;
  }

  for (String element : list) {
   listToString += element + separator;
  }

  listToString = listToString.substring(0, separator.length());

  return listToString;
}