example - lista join c#

Java equivalentes de C#String.Format() y String.Join()

Question

Sé que esta es una pregunta un poco nueva, ¿pero hay equivalentes a las operaciones de cadena de C # en Java?

Específicamente, estoy hablando de String.Format y String.Join .

Answer 1

A partir de Java 8, join() ahora está disponible como dos métodos de clase en la clase String. En ambos casos, el primer argumento es el delimitador.

Puede pasar CharSequence individual s como argumentos adicionales :

String joined = String.join(", ", "Antimony", "Arsenic", "Aluminum", "Selenium");
// "Antimony, Arsenic, Alumninum, Selenium"

O puede pasar un Iterable<? extends CharSequence> Iterable<? extends CharSequence> :

List<String> strings = new LinkedList<String>();
strings.add("EX");
strings.add("TER");
strings.add("MIN");
strings.add("ATE");

String joined = String.join("-", strings);
// "EX-TER-MIN-ATE"

Java 8 también agrega una nueva clase, StringJoiner , que puede usar así:

StringJoiner joiner = new StringJoiner("&");
joiner.add("x=9");
joiner.add("y=5667.7");
joiner.add("z=-33.0");

String joined = joiner.toString();
// "x=9&y=5667.7&z=-33.0"

Answer 2

Aquí hay una respuesta bastante simple. Use += ya que es menos código y permita que el optimizador lo convierta en un StringBuilder por usted. Al usar este método, no tiene que hacer ninguna verificación "is last" en su ciclo (mejora del rendimiento) y no tiene que preocuparse por eliminar ningún delimitador al final.

        Iterator<String> iter = args.iterator();
        output += iter.hasNext() ? iter.next() : "";
        while (iter.hasNext()) {
            output += "," + iter.next();
        }

Answer 3

El objeto Java String tiene un método de format (a partir de 1.5), pero no un método de join .

Para obtener una gran cantidad de útiles métodos de String no incluidos, puede usar org.apache.commons.lang.StringUtils .

Answer 4

En cuanto a unirse, creo que esto podría parecer un poco menos complicado:

public String join (Collection<String> c) {
    StringBuilder sb=new StringBuilder();
    for(String s: c)
        sb.append(s);
    return sb.toString();
}

No llego a utilizar la sintaxis de Java 5 tanto como me gustaría (lo crea o no, he estado usando 1.0.x últimamente) por lo que podría estar un poco oxidado, pero estoy seguro de que el concepto es correcto .

edición adicional: las cadenas añadidas pueden ralentizarse, pero si está trabajando en un código GUI o en alguna rutina de ejecución corta, realmente no importa si toma .005 segundos o .006, por lo que si tuviera una colección llamada "joinMe" que desea agregar a un "destino" de cadena existente, no sería horrible simplemente en línea esto:

for(String s : joinMe)
    target += s;

Es bastante ineficiente (y un mal hábito), pero no nada que puedas percibir a menos que haya miles de cadenas o que este se encuentre dentro de un gran bucle o que tu código sea realmente crítico para el rendimiento.

Más importante aún, es fácil de recordar, corto, rápido y muy legible. El rendimiento no siempre es el ganador automático en las elecciones de diseño.

Answer 5

Hay MessageFormat.format() que funciona como C # ''s String.Format() .

Answer 6

No quería importar una biblioteca completa de Apache para agregar una función de unión simple, así que aquí está mi hack.

    public String join(String delim, List<String> destinations) {
        StringBuilder sb = new StringBuilder();
        int delimLength = delim.length();

        for (String s: destinations) {
            sb.append(s);
            sb.append(delim);
        }

        // we have appended the delimiter to the end 
        // in the previous for-loop. Let''s now remove it.
        if (sb.length() >= delimLength) {
            return sb.substring(0, sb.length() - delimLength);
        } else {
            return sb.toString();
        }
    }

Answer 7

Si desea unir (concatenar) varias cadenas en una, debe usar un StringBuilder. Es mucho mejor que usar

for(String s : joinMe)
    target += s;

También hay una ligera ganancia de rendimiento sobre StringBuffer, ya que StringBuilder no usa sincronización.

Para un método de utilidad de propósito general como este, (eventualmente) se llamará muchas veces en muchas situaciones, por lo que debe hacerlo eficiente y no asignar muchos objetos transitorios. Hemos creado un perfil de muchas, muchas aplicaciones de Java diferentes y casi siempre encontramos que la concatenación de cadenas y las asignaciones de cadenas / caracteres [] ocupan una cantidad significativa de tiempo / memoria.

Nuestro método de colección reutilizable -> cadena primero calcula el tamaño del resultado requerido y luego crea un StringBuilder con ese tamaño inicial; esto evita la duplicación / copia innecesaria del carácter interno [] utilizado al agregar cadenas.

Answer 8

Solo usaría el operador de concatenación de cadenas "+" para unir dos cadenas. s1 += s2;

Answer 9

También puede usar argumentos variables para cadenas de la siguiente manera:

  String join (String delim, String ... data) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < data.length; i++) {
      sb.append(data[i]);
      if (i >= data.length-1) {break;}
      sb.append(delim);
    }
    return sb.toString();
  }

Answer 10

Veo muchas implementaciones demasiado complejas de String.Join aquí. Si no tiene Java 1.8 y no desea importar una nueva biblioteca, la implementación a continuación debería ser suficiente.

public String join(Collection<String> col, String delim) {
    StringBuilder sb = new StringBuilder();
    for ( String s : col ) {
        if ( sb.length() != 0 ) sb.append(delim);
        sb.append(s);
    }
    return sb.toString();
}

Answer 11

Yo escribí propio:

public static String join(Collection<String> col, String delim) {
    StringBuilder sb = new StringBuilder();
    Iterator<String> iter = col.iterator();
    if (iter.hasNext())
        sb.append(iter.next().toString());
    while (iter.hasNext()) {
        sb.append(delim);
        sb.append(iter.next().toString());
    }
    return sb.toString();
}

pero la Collection no es compatible con JSP, por lo que para la función de etiqueta escribí:

public static String join(List<?> list, String delim) {
    int len = list.size();
    if (len == 0)
        return "";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        sb.append(delim);
        sb.append(list.get(i).toString());
    }
    return sb.toString();
}

y ponerlo en el archivo .tld :

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.1" xmlns="http://java.sun.com/xml/ns/javaee"
    <function>
        <name>join</name>
        <function-class>com.core.util.ReportUtil</function-class>
        <function-signature>java.lang.String join(java.util.List, java.lang.String)</function-signature>
    </function>
</taglib>

y usarlo en archivos JSP como:

<%@taglib prefix="funnyFmt" uri="tag:com.core.util,2013:funnyFmt"%>
${funnyFmt:join(books, ", ")}

Answer 12

StringUtils es una clase bastante útil en la biblioteca de Apache Commons Lang.

Answer 13

TextUtils.join está disponible en Android

Answer 14

String.format . En cuanto a unirse, debes escribir el tuyo:

 static String join(Collection<?> s, String delimiter) {
     StringBuilder builder = new StringBuilder();
     Iterator<?> iter = s.iterator();
     while (iter.hasNext()) {
         builder.append(iter.next());
         if (!iter.hasNext()) {
           break;                  
         }
         builder.append(delimiter);
     }
     return builder.toString();
 }

Lo anterior proviene de http://snippets.dzone.com/posts/show/91

Answer 15

Guava viene con la clase Joiner .

import com.google.common.base.Joiner;

Joiner.on(separator).join(data);

Answer 16

ArrayList<Double> j=new ArrayList<>; 
j.add(1);
j.add(.92);
j.add(3); 
String ntop=j.toString(); //ntop= "[1, 0.92, 3]" 

Básicamente, String ntop almacena el valor de toda la colección con separadores de coma y corchetes.