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

Eu sei que esta é uma pergunta um pouco para iniciantes, mas existem equivalentes às operações de string do C # em Java?

Especificamente, estou falando sobre String.Formate String.Join.

O objeto Java String tem um formatmétodo (a partir de 1.5), mas nenhum joinmétodo.

Para obter vários métodos de utilitário String úteis ainda não incluídos, você pode usar org.apache.commons.lang.StringUtils .

String.format . Para participar, você precisa escrever o seu próprio:

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

O texto acima vem de http://snippets.dzone.com/posts/show/91

A goiaba vem com a Joineraula .

import com.google.common.base.Joiner;

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

A partir do Java 8, join()agora está disponível como dois métodos de classe na classe String. Em ambos os casos, o primeiro argumento é o delimitador.

Você pode passar CharSequences individuais como argumentos adicionais :

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

Ou você pode passar umIterable<? 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 também adiciona uma nova classe StringJoiner, que você pode usar assim:

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á disponível no Android

Você também pode usar argumentos variáveis ​​para strings da seguinte maneira:

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

Quanto à adesão, acredito que isso possa parecer um pouco menos complicado:

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

Não consigo usar a sintaxe Java 5 tanto quanto gostaria (acredite ou não, tenho usado 1.0.x ultimamente), então posso estar um pouco enferrujado, mas tenho certeza de que o conceito está correto .

adição de edição: acréscimos de string podem ser lentos, mas se você estiver trabalhando em código GUI ou alguma rotina de execução curta, realmente não importa se você leva 0,005 segundos ou 0,006, então se você tinha uma coleção chamada "joinMe" que você deseja anexar a uma string existente "target", não seria horrível apenas embutir isto:

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

É bastante ineficiente (e um mau hábito), mas não é nada que você seja capaz de perceber, a menos que haja milhares de strings ou que esteja dentro de um loop enorme ou que seu código seja realmente crítico para o desempenho.

Mais importante, é fácil de lembrar, curto, rápido e muito legível. O desempenho nem sempre é o vencedor automático nas escolhas de design.

Aqui está uma resposta muito simples. Use +=uma vez que tem menos código e deixe o otimizador convertê-lo em um StringBuilderpara você. Usando esse método, você não precisa fazer nenhuma verificação "é a última" em seu loop (melhoria de desempenho) e não precisa se preocupar em remover quaisquer delimitadores no final.

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

Eu não queria importar uma biblioteca Apache inteira para adicionar uma função de junção simples, então aqui está meu 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();
        }
    }

Se você deseja unir (concatenar) várias strings em uma, você deve usar um StringBuilder. É muito melhor do que usar

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

Há também uma pequena vitória de desempenho sobre StringBuffer, já que StringBuilder não usa sincronização.

Para um método utilitário de propósito geral como este, ele (eventualmente) será chamado muitas vezes em muitas situações, portanto, você deve torná-lo eficiente e não alocar muitos objetos transitórios. Fizemos o perfil de muitos aplicativos Java diferentes e quase sempre descobrimos que a concatenação de string e as alocações de string / char [] ocupam uma quantidade significativa de tempo / memória.

Nossa coleção reutilizável -> método string primeiro calcula o tamanho do resultado necessário e, em seguida, cria um StringBuilder com esse tamanho inicial; isso evita duplicação / cópia desnecessária do char interno [] usado ao anexar strings.

Eu escrevi:

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

mas Collectionnão é compatível com JSP, portanto, para a função de tag, escrevi:

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

e .tldarquivado:

<?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>

e usá-lo em arquivos JSP como:

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

StringUtils é uma classe muito útil na biblioteca Apache Commons Lang.

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

Vejo muitas implementações excessivamente complexas de String.Join aqui. Se você não tiver o Java 1.8 e não quiser importar uma nova biblioteca, a implementação abaixo deve 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]" 

Então, basicamente, o String ntop armazena o valor de toda a coleção com separadores de vírgula e colchetes.

Eu usaria apenas o operador de concatenação de string "+" para juntar duas strings. s1 += s2;