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

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

Especificamente, estou falando sobre String.Format e String.Join .

O object Java String possui um método format (a partir de 1.5), mas nenhum método join .

Para obter um monte de methods úteis do utilitário String que ainda não estão incluídos, você pode usar org.apache.commons.lang.StringUtils .

String.format . Quanto ao join, 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 acima vem de http://snippets.dzone.com/posts/show/91

Goiaba vem com a class Joiner .

 import com.google.common.base.Joiner; Joiner.on(separator).join(data); 

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

Você pode passar CharSequence s individuais como argumentos adicionais :

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

Ou você pode passar um Iterable< ? extends CharSequence> Iterable< ? extends CharSequence> :

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

O Java 8 também adiciona uma nova class, 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 variables ​​para seqüências de caracteres 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 a participar, acredito que isso possa parecer um pouco menos complicado:

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

Eu não consigo usar a syntax do Java 5 tanto quanto eu gostaria (Acredite ou não, eu tenho usado 1.0.x ultimamente) então eu posso estar um pouco enferrujado, mas tenho certeza que o conceito está correto .

add de edição: Os acréscimos de strings podem ser lentos, mas se você estiver trabalhando com código GUI ou alguma rotina de execução curta, não importa se você toma 0,005 segundo ou 0,006, então se você tivesse uma coleção chamada “joinMe” que você deseja append a uma string existente “target”, não seria horrível apenas inserir isso:

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

É bastante ineficiente (e um mau hábito), mas não é algo que você será capaz de perceber a menos que existam milhares de strings ou isso esteja dentro de um loop enorme ou 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 bem simples. Use += já que é menos código e deixe o otimizador convertê-lo em um StringBuilder para você. Usando esse método, você não precisa fazer nenhuma verificação “última” em seu loop (melhoria de desempenho) e não precisa se preocupar em remover delimitadores no final.

  Iterator 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 function de junit simples, então aqui está meu hack.

  public String join(String delim, List 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 conquista de desempenho sobre o StringBuffer, já que o StringBuilder não usa synchronization.

Para um método utilitário de uso geral como este, ele (eventualmente) será chamado muitas vezes em muitas situações, portanto, você deve torná-lo eficiente e não alocar muitos objects temporários. Analisamos muitos, muitos aplicativos Java diferentes e quase sempre descobrimos que as alocações de concatenação de strings e de strings / char [] ocupam uma quantidade significativa de tempo / memory.

Nosso método reutilizável collection -> string primeiro calcula o tamanho do resultado requerido e então cria um StringBuilder com aquele tamanho inicial; isso evita a duplicação / cópia desnecessária do char interno [] usado ao append strings.

Eu escrevi possui:

 public static String join(Collection col, String delim) { StringBuilder sb = new StringBuilder(); Iterator 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 a Collection não é suportada pelo JSP, então para a function tag eu 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 colocar no arquivo .tld :

 < ?xml version="1.0" encoding="UTF-8"?>  join com.core.util.ReportUtil java.lang.String join(java.util.List, java.lang.String)   

e usá-lo em arquivos JSP como:

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

StringUtils é uma class bastante útil na biblioteca Apache Commons Lang.

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

Eu vejo muitas implementações excessivamente complexas de String.Junte 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 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 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 da coleção inteira com separadores de vírgulas e colchetes.

Eu usaria apenas o operador de concatenação de strings “+” para unir duas strings. s1 += s2;