Java setara dengan C # String.Format () dan String.Join ()

Saya tahu ini sedikit pertanyaan pemula, tetapi apakah ada yang setara dengan operasi string C # di Java?

Secara khusus, saya sedang berbicara tentang String.Formatdan String.Join.

Objek Java String memiliki formatmetode (mulai 1.5), tetapi tidak ada joinmetode.

Untuk mendapatkan sekumpulan metode utilitas String berguna yang belum disertakan, Anda dapat menggunakan org.apache.commons.lang.StringUtils .

String.format . Untuk bergabung, Anda perlu menulis sendiri:

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

Di atas berasal dari http://snippets.dzone.com/posts/show/91

Jambu datang dengan yang Joinerkelas .

import com.google.common.base.Joiner;

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

Pada Java 8, join()sekarang tersedia sebagai dua metode kelas pada kelas String. Dalam kedua kasus, argumen pertama adalah pembatas.

Anda dapat memberikan individu CharSequencesebagai argumen tambahan :

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

Atau Anda bisa lulusIterable<? 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 juga menambahkan kelas baru StringJoiner, yang dapat Anda gunakan seperti ini:

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 tersedia di Android

Anda juga dapat menggunakan argumen variabel untuk string sebagai berikut:

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

Untuk bergabung, saya yakin ini mungkin terlihat sedikit lebih mudah:

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

Saya tidak bisa menggunakan sintaks Java 5 sebanyak yang saya inginkan (Percaya atau tidak, saya telah menggunakan 1.0.x akhir-akhir ini) jadi saya mungkin agak berkarat, tapi saya yakin konsepnya benar .

edit tambahan: Penambahan string bisa lambat, tetapi jika Anda bekerja pada kode GUI atau beberapa rutinitas yang berjalan singkat, tidak masalah jika Anda mengambil .005 detik atau .006, jadi jika Anda memiliki koleksi yang disebut "joinMe" yang ingin Anda tambahkan ke string "target" yang ada, tidak akan mengerikan jika hanya sebaris ini:

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

Ini cukup tidak efisien (dan kebiasaan buruk), tetapi tidak apa pun yang dapat Anda lihat kecuali ada ribuan string atau ini ada di dalam lingkaran besar atau kode Anda benar-benar penting untuk performa.

Lebih penting lagi, mudah diingat, singkat, cepat dan sangat mudah dibaca. Performa tidak selalu menjadi pemenang otomatis dalam pilihan desain.

Inilah jawaban yang cukup sederhana. Gunakan +=karena ini lebih sedikit kode dan biarkan pengoptimal mengubahnya menjadi StringBuilderuntuk Anda. Dengan menggunakan metode ini, Anda tidak perlu melakukan pemeriksaan "terakhir" di loop Anda (peningkatan kinerja) dan Anda tidak perlu khawatir tentang menghapus pembatas apa pun di akhir.

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

Saya tidak ingin mengimpor seluruh pustaka Apache untuk menambahkan fungsi gabungan sederhana, jadi inilah retasan saya.

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

Jika Anda ingin menggabungkan (menggabungkan) beberapa string menjadi satu, Anda harus menggunakan StringBuilder. Ini jauh lebih baik daripada menggunakan

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

Ada juga sedikit kinerja menang atas StringBuffer, karena StringBuilder tidak menggunakan sinkronisasi.

Untuk metode utilitas tujuan umum seperti ini, metode ini (pada akhirnya) akan dipanggil berkali-kali dalam banyak situasi, jadi Anda harus membuatnya efisien dan tidak mengalokasikan banyak objek sementara. Kami telah membuat profil banyak, banyak aplikasi Java yang berbeda dan hampir selalu menemukan bahwa penggabungan string dan alokasi string / char [] membutuhkan banyak waktu / memori.

Metode collection -> string kami yang dapat digunakan kembali pertama-tama menghitung ukuran hasil yang diperlukan dan kemudian membuat StringBuilder dengan ukuran awal tersebut; ini menghindari penggandaan / penyalinan karakter internal [] yang tidak perlu yang digunakan saat menambahkan string.

Saya menulis sendiri:

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

tetapi Collectiontidak didukung oleh JSP, jadi untuk fungsi tag saya menulis:

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

dan masukkan ke .tldfile:

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

dan gunakan dalam file JSP sebagai:

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

StringUtils adalah kelas yang sangat berguna di perpustakaan Apache Commons Lang.

Ada MessageFormat.format()yang bekerja seperti C # String.Format().

Saya melihat banyak implementasi String.Join yang terlalu kompleks di sini. Jika Anda tidak memiliki Java 1.8, dan Anda tidak ingin mengimpor pustaka baru, implementasi di bawah ini sudah cukup.

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

Jadi pada dasarnya, String ntop menyimpan nilai seluruh koleksi dengan pemisah koma dan tanda kurung.

Saya hanya akan menggunakan operator penggabungan string "+" untuk menggabungkan dua string. s1 += s2;