Java-Entsprechungen von C # String.Format () und String.Join ()

Ich weiß, das ist ein bisschen eine Neuling Frage, aber gibt es Entsprechungen zu C # ‘s String-Operationen in Java?

Genauer gesagt, ich spreche von String.Format und String.Join .

   

Das Java-String-Objekt hat eine format (ab 1.5), aber keine join Methode.

Um eine Reihe nützlicher String-Methoden zu erhalten, die nicht bereits enthalten sind, könnten Sie org.apache.commons.lang.StringUtils verwenden .

Zeichenfolge.format . Wie für Join, müssen Sie Ihre eigenen schreiben:

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

Das obige kommt von http://snippets.dzone.com/posts/show/91

Guava kommt mit der Joiner class .

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

Ab Java 8 ist join() jetzt als zwei classnmethoden für die String-class verfügbar. In beiden Fällen ist das erste Argument das Trennzeichen.

Sie können einzelne CharSequence s als zusätzliche Argumente übergeben :

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

Oder Sie können ein 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" 

Java 8 fügt auch eine neue class, StringJoiner , StringJoiner , die Sie folgendermaßen verwenden können:

 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 ist auf Android verfügbar

Sie können auch variable Argumente für Strings wie folgt verwenden:

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

Wie für Join, ich glaube, das könnte ein wenig weniger kompliziert aussehen:

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

Ich kann die Java 5-Syntax nicht so oft verwenden, wie ich möchte (glaube es oder nicht, ich habe in letzter Zeit 1.0.x benutzt), also mag ich ein bisschen eingerostet sein, aber ich bin mir sicher, dass das Konzept korrekt ist .

edit addition: String-Anhängen kann langsamer sein, aber wenn Sie an GUI-Code oder einer kurzen Routine arbeiten, spielt es keine Rolle, ob Sie .005 Sekunden oder .006 nehmen, also wenn Sie eine Sammlung namens “joinMe” haben dass Sie an eine vorhandene Zeichenfolge “Ziel” anhängen möchten, wäre es nicht entsetzlich, dies einfach inline zu machen:

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

Es ist ziemlich ineffizient (und eine schlechte Angewohnheit), aber nichts, was Sie wahrnehmen können, es sei denn, es gibt Tausende von Strings oder das ist in einer großen Schleife oder Ihr Code ist wirklich leistungskritisch.

Noch wichtiger ist, dass es leicht zu merken ist, kurz, schnell und gut lesbar. performance ist nicht immer der automatische Gewinner bei der Designauswahl.

Hier ist eine ziemlich einfache Antwort. Verwenden Sie += da es weniger Code ist, und lassen Sie es vom Optimierer für Sie in einen StringBuilder konvertieren. Mit dieser Methode müssen Sie in Ihrer Schleife keine “last last” -Prüfungen durchführen (performancesverbesserung) und Sie müssen sich nicht darum sorgen, am Ende irgendwelche Begrenzer zu entfernen.

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

Ich wollte nicht eine ganze Apache-Bibliothek importieren, um eine einfache Join-function hinzuzufügen, also hier ist mein 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(); } } 

Wenn Sie mehrere Strings zu einem zusammenfügen (verketten) möchten, sollten Sie einen StringBuilder verwenden. Es ist viel besser als zu verwenden

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

Es gibt auch einen leichten performancesgewinn gegenüber StringBuffer, da StringBuilder keine Synchronisation verwendet.

Für eine Allzweck-Utility-Methode wie diese wird sie in vielen Situationen (oft) viele Male aufgerufen, also sollten Sie sie effizient machen und nicht viele transiente Objekte zuweisen. Wir haben viele, viele verschiedene Java-Anwendungen profiliert und finden fast immer heraus, dass String-Verkettungen und string / char [] – Zuweisungen eine beträchtliche Menge an Zeit / Speicher beanspruchen.

Unsere wiederverwendbare Collection -> String-Methode berechnet zunächst die Größe des gewünschten Ergebnisses und erstellt dann einen StringBuilder mit dieser Anfangsgröße; Dies vermeidet unnötiges Verdoppeln / Kopieren des internen Zeichens [], das beim Anhängen von Zeichenfolgen verwendet wird.

Ich habe selbst geschrieben:

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

aber Collection wird nicht von JSP unterstützt, also für die Tag-function schrieb ich:

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

und in die .tld Datei .tld :

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

und verwende es in JSP-Dateien als:

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

StringUtils ist eine sehr nützliche class in der Apache Commons Lang-Bibliothek.

Es gibt MessageFormat.format() das wie C # ‘s String.Format() .

Ich sehe hier eine Menge übermäßig komplexer Implementierungen von String.Join. Wenn Sie Java 1.8 nicht haben und keine neue Bibliothek importieren möchten, sollte die folgende Implementierung ausreichen.

 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]" 

Im Grunde speichert der String ntop den Wert der gesamten Sammlung mit Kommatrennzeichen und Klammern.

Ich würde einfach den String-Verkettungsoperator “+” verwenden, um zwei Strings zu verbinden. s1 += s2;