Equivalenti Java di C # String.Format () e String.Join ()

So che questa è una domanda un po 'per principianti, ma ci sono equivalenti alle operazioni sulle stringhe di C # in Java?

Nello specifico, sto parlando di String.Formate String.Join.

L'oggetto Java String ha un formatmetodo (dalla 1.5), ma nessun joinmetodo.

Per ottenere una serie di utili metodi di utilità String non già inclusi, è possibile utilizzare org.apache.commons.lang.StringUtils .

String.format . Per quanto riguarda l'iscrizione, devi scrivere il tuo:

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

Quanto sopra proviene da http://snippets.dzone.com/posts/show/91

Guava arriva con la Joinerclasse .

import com.google.common.base.Joiner;

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

A partire da Java 8, join()è ora disponibile come due metodi di classe sulla classe String. In entrambi i casi il primo argomento è il delimitatore.

Puoi passare singoli messaggi di posta CharSequenceelettronica come argomenti aggiuntivi :

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

Oppure puoi passare 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 aggiunge anche una nuova classe StringJoiner, che puoi usare in questo modo:

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 è disponibile su Android

È inoltre possibile utilizzare argomenti variabili per le stringhe come segue:

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

Per quanto riguarda l'adesione, credo che questo potrebbe sembrare un po 'meno complicato:

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

Non riesco a usare la sintassi di Java 5 quanto vorrei (che ci crediate o no, ho usato 1.0.x ultimamente) quindi potrei essere un po 'arrugginito, ma sono sicuro che il concetto sia corretto .

modifica aggiunta: le aggiunte di stringhe possono essere lente, ma se stai lavorando sul codice della GUI o su qualche routine a esecuzione breve, non importa se impieghi .005 secondi o .006, quindi se hai una raccolta chiamata "joinMe" che vuoi aggiungere a una stringa esistente "target" non sarebbe orribile semplicemente incorporare questo:

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

È abbastanza inefficiente (e una cattiva abitudine), ma non qualcosa che sarai in grado di percepire a meno che non ci siano migliaia di stringhe o questo è all'interno di un ciclo enorme o il tuo codice è davvero critico per le prestazioni.

Ancora più importante, è facile da ricordare, breve, veloce e molto leggibile. Le prestazioni non sono sempre il vincitore automatico nelle scelte di design.

Ecco una risposta piuttosto semplice. Usalo +=poiché contiene meno codice e lascia che l'ottimizzatore lo converta in un file StringBuilderper te. Usando questo metodo, non devi fare alcun controllo "è ultimo" nel tuo ciclo (miglioramento delle prestazioni) e non devi preoccuparti di rimuovere i delimitatori alla fine.

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

Non volevo importare un'intera libreria Apache per aggiungere una semplice funzione di join, quindi ecco il mio trucco.

    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 desideri unire (concatenare) più stringhe in una, dovresti usare StringBuilder. È molto meglio che usare

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

C'è anche un leggero vantaggio in termini di prestazioni su StringBuffer, poiché StringBuilder non utilizza la sincronizzazione.

Per un metodo di utilità generale come questo, verrà (eventualmente) chiamato molte volte in molte situazioni, quindi dovresti renderlo efficiente e non allocare molti oggetti temporanei. Abbiamo profilato molte, molte app Java diverse e quasi sempre abbiamo scoperto che la concatenazione di stringhe e le allocazioni string / char [] occupano una notevole quantità di tempo / memoria.

La nostra raccolta riutilizzabile -> il metodo stringa prima calcola la dimensione del risultato richiesto e poi crea uno StringBuilder con quella dimensione iniziale; questo evita il raddoppio / la copia non necessari del carattere interno [] utilizzato quando si aggiungono stringhe.

Ho scritto proprio:

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

ma Collectionnon è supportato da JSP, quindi per la funzione tag ho scritto:

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 mettere in .tldarchivio:

<?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 usalo nei file JSP come:

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

StringUtils è una classe piuttosto utile nella libreria Apache Commons Lang.

C'è MessageFormat.format()che funziona come C # String.Format().

Vedo molte implementazioni eccessivamente complesse di String.Join qui. Se non si dispone di Java 1.8 e non si desidera importare una nuova libreria, l'implementazione seguente dovrebbe essere sufficiente.

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

Quindi, in pratica, String ntop memorizza il valore dell'intera raccolta con separatori di virgole e parentesi.

Vorrei solo usare l'operatore di concatenazione di stringhe "+" per unire due stringhe. s1 += s2;