Java: berfungsi untuk array seperti gabungan PHP ()?

Saya ingin bergabung String[]dengan lem. Apakah ada fungsi untuk ini?

Mulai dari Java8 dimungkinkan untuk digunakan String.join().

String.join(", ", new String[]{"Hello", "World", "!"})

Menghasilkan:

Hello, World, !

Jika tidak, Apache Commons Lang memiliki StringUtilskelas yang memiliki joinfungsi yang akan bergabung dengan array untuk membuat String.

Sebagai contoh:

StringUtils.join(new String[] {"Hello", "World", "!"}, ", ")

Menghasilkan yang berikut String:

Hello, World, !

Jika Anda mencari apa yang harus digunakan di Android, itu adalah:

String android.text.TextUtils.join(CharSequence delimiter, Object[] tokens)

sebagai contoh:

String joined = TextUtils.join(";", MyStringArray);

Di Java 8 Anda bisa menggunakan

1) Aliran API:

String[] a = new String[] {"a", "b", "c"};
String result = Arrays.stream(a).collect(Collectors.joining(", "));

2) metode String.join baru: https://stackoverflow.com/a/21756398/466677

3) kelas java.util.StringJoiner: http://docs.oracle.com/javase/8/docs/api/java/util/StringJoiner.html

Anda dapat dengan mudah menulis fungsi seperti itu di sekitar sepuluh baris kode:

String combine(String[] s, String glue)
{
  int k = s.length;
  if ( k == 0 )
  {
    return null;
  }
  StringBuilder out = new StringBuilder();
  out.append( s[0] );
  for ( int x=1; x < k; ++x )
  {
    out.append(glue).append(s[x]);
  }
  return out.toString();
}

Mod kecil alih-alih menggunakan substring ():

//join(String array,delimiter)
public static String join(String r[],String d)
{
        if (r.length == 0) return "";
        StringBuilder sb = new StringBuilder();
        int i;
        for(i=0;i<r.length-1;i++){
            sb.append(r[i]);
            sb.append(d);
        }
        sb.append(r[i]);
        return sb.toString();
}

Seperti banyak pertanyaan belakangan ini, Java 8 menyelamatkan:

Java 8 menambahkan metode statis baru java.lang.Stringyang melakukan persis apa yang Anda inginkan:

public static String join(CharSequence delimeter, CharSequence... elements);

Menggunakannya:

String s = String.join(", ", new String[] {"Hello", "World", "!"});

Hasil dalam:

"Hello, World, !"

Perpustakaan Google jambu biji juga memiliki kemampuan semacam ini . Anda dapat melihat contoh String [] dari API.

Seperti yang sudah dijelaskan dalam api, berhati-hatilah terhadap ketidakmampuan metode pembangun.

Itu dapat menerima berbagai objek sehingga itu akan berfungsi dalam kasus Anda. Dalam pengalaman saya sebelumnya, saya mencoba bergabung dengan Stack yang merupakan iterable dan berfungsi dengan baik.

Contoh dari saya:

Deque<String> nameStack = new ArrayDeque<>();
nameStack.push("a coder");
nameStack.push("i am");
System.out.println("|" + Joiner.on(' ').skipNulls().join(nameStack) + "|");

mencetak: |i am a coder|

Diberikan:

String[] a = new String[] { "Hello", "World", "!" };

Kemudian sebagai alternatif untuk jawaban coobird, di mana lemnya adalah ",":

Arrays.asList(a).toString().replaceAll("^\\[|\\]$", "")

Atau untuk digabungkan dengan string yang berbeda, seperti "& amp;".

Arrays.asList(a).toString().replaceAll(", ", " & ").replaceAll("^\\[|\\]$", "")

Namun ... ini HANYA berfungsi jika Anda tahu bahwa nilai-nilai dalam array atau daftar JANGAN berisi string karakter ",".

Jika Anda menggunakan Spring Framework maka Anda memiliki kelas StringUtils :

import static org.springframework.util.StringUtils.arrayToDelimitedString;

arrayToDelimitedString(new String[] {"A", "B", "C"}, "\n");

Tidak pada intinya, tidak. Pencarian untuk "java array join string lem" akan memberi Anda beberapa cuplikan kode tentang cara mencapai ini.

misalnya

public static String join(Collection s, String delimiter) {
    StringBuffer buffer = new StringBuffer();
    Iterator iter = s.iterator();
    while (iter.hasNext()) {
        buffer.append(iter.next());
        if (iter.hasNext()) {
            buffer.append(delimiter);
        }
    }
    return buffer.toString();
}

Jika Anda mendarat di sini mencari konversi array-ke-string cepat, coba Array.toString () .

Membuat representasi String dari yang Object[]berlalu. Hasilnya dikelilingi oleh tanda kurung ( "[]"), setiap elemen dikonversi ke String melalui String.valueOf(Object)dan dipisahkan oleh ", ". Jika arraynya null, maka "null"dikembalikan.

Hanya untuk tantangan "Saya yang terpendek" , berikut adalah tambang;)

Berulang:

public static String join(String s, Object... a) {
    StringBuilder o = new StringBuilder();
    for (Iterator<Object> i = Arrays.asList(a).iterator(); i.hasNext();)
        o.append(i.next()).append(i.hasNext() ? s : "");
    return o.toString();
}

Rekursif:

public static String join(String s, Object... a) {
    return a.length == 0 ? "" : a[0] + (a.length == 1 ? "" : s + join(s, Arrays.copyOfRange(a, 1, a.length)));
}

Tidak ada built-in yang saya ketahui.

Apache Commons Lang memiliki kelas yang disebut StringUtilsyang berisi banyak fungsi bergabung.

Beginilah cara saya melakukannya.

private String join(String[] input, String delimiter)
{
    StringBuilder sb = new StringBuilder();
    for(String value : input)
    {
        sb.append(value);
        sb.append(delimiter);
    }
    int length = sb.length();
    if(length > 0)
    {
        // Remove the extra delimiter
        sb.setLength(length - delimiter.length());
    }
    return sb.toString();
}

Alternatif serupa

/**
 * @param delimiter 
 * @param inStr
 * @return String
 */
public static String join(String delimiter, String... inStr)
{
    StringBuilder sb = new StringBuilder();
    if (inStr.length > 0)
    {
        sb.append(inStr[0]);
        for (int i = 1; i < inStr.length; i++)
        {
            sb.append(delimiter);                   
            sb.append(inStr[i]);
        }
    }
    return sb.toString();
}

Putaran saya.

public static String join(Object[] objects, String delimiter) {
  if (objects.length == 0) {
    return "";
  }
  int capacityGuess = (objects.length * objects[0].toString().length())
      + ((objects.length - 1) * delimiter.length());
  StringBuilder ret = new StringBuilder(capacityGuess);
  ret.append(objects[0]);
  for (int i = 1; i < objects.length; i++) {
    ret.append(delimiter);
    ret.append(objects[i]);
  }
  return ret.toString();
}

public static String join(Object... objects) {
  return join(objects, "");
}

Apakah Anda suka cara 3-baris saya hanya menggunakan metode kelas String?

static String join(String glue, String[] array) {
    String line = "";
    for (String s : array) line += s + glue;
    return (array.length == 0) ? line : line.substring(0, line.length() - glue.length());
}

Untuk mendapatkan "str1, str2" dari "str1", "str2", "":

Stream.of("str1", "str2", "").filter(str -> !str.isEmpty()).collect(Collectors.joining(", ")); 

Anda juga dapat menambahkan cek-nol tambahan

Jika Anda menggunakan perpustakaan Java Fungsional dan karena alasan tertentu tidak dapat menggunakan Streaming dari Java 8 (yang mungkin terjadi saat menggunakan plugin Android + Retrolambda), berikut adalah solusi fungsional untuk Anda:

String joinWithSeparator(List<String> items, String separator) {
    return items
            .bind(id -> list(separator, id))
            .drop(1)
            .foldLeft(
                    (result, item) -> result + item,
                    ""
            );
}

Perhatikan bahwa ini bukan pendekatan yang paling efisien, tetapi berhasil untuk daftar kecil.

Saya melakukannya dengan cara ini menggunakan StringBuilder:

public static String join(String[] source, String delimiter) {
    if ((null == source) || (source.length < 1)) {
        return "";
    }

    StringBuilder stringbuilder = new StringBuilder();
    for (String s : source) {
        stringbuilder.append(s + delimiter);
    }
    return stringbuilder.toString();
} // join((String[], String)

Ada teknik tulisan cepat sederhana yang saya gunakan sebagian besar kali ..

String op = new String;
for (int i : is) 
{
    op += candidatesArr[i-1]+",";
}
op = op.substring(0, op.length()-1);

java.util.Arrays memiliki metode 'asList'. Bersama dengan java.util.List / ArrayList API ini memberi Anda semua yang Anda butuhkan:;

private static String[] join(String[] array1, String[] array2) {

    List<String> list = new ArrayList<String>(Arrays.asList(array1));
    list.addAll(Arrays.asList(array2));
    return list.toArray(new String[0]);
}