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

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

Específicamente, estoy hablando de String.Formaty String.Join.

El objeto String de Java tiene un formatmétodo (a partir de la 1.5), pero ningún joinmétodo.

Para obtener un montón de métodos de utilidad String útiles que aún no están incluidos, puede usar org.apache.commons.lang.StringUtils .

String.format . En cuanto a unirse, debe escribir el suyo propio:

 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

Guava viene con la Joinerclase .

import com.google.common.base.Joiner;

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

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 CharSequences individuales como argumentos adicionales :

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

O puede pasar unIterable<? 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"

TextUtils.join está disponible en Android

También puede utilizar 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();
  }

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 puedo usar la sintaxis de Java 5 tanto como me gustaría (lo crea o no, he estado usando 1.0.x últimamente), así que puede que esté un poco oxidado, pero estoy seguro de que el concepto es correcto .

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

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

Es bastante ineficiente (y un mal hábito), pero no es nada que pueda percibir a menos que haya miles de cadenas o esto esté dentro de un bucle enorme o su código sea realmente crítico para el rendimiento.

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

Aquí hay una respuesta bastante simple. Úselo +=ya que es menos código y deje que el optimizador lo convierta a StringBuilderpor usted. Con este método, no tiene que hacer ninguna comprobación "es la última" en su ciclo (mejora del rendimiento) y no tiene que preocuparse por eliminar los delimitadores al final.

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

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

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

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 ventaja de rendimiento sobre StringBuffer, ya que StringBuilder no usa la 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 perfilado muchas, muchas aplicaciones Java diferentes y casi siempre encontramos que la concatenación de cadenas y las asignaciones de cadenas / caracteres [] consumen una cantidad significativa de tiempo / memoria.

Nuestra colección reutilizable -> método string 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 [] que se usa al agregar cadenas.

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 Collectionno 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 .tldarchivar:

<?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 utilícelo en archivos JSP como:

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

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

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

Veo muchas implementaciones demasiado complejas de String. Únete aquí. Si no tiene Java 1.8 y no desea importar una nueva biblioteca, la siguiente implementació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();
}

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.

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