Java: convert List <String> ke String

JavaScript memiliki Array.join()

js>["Bill","Bob","Steve"].join(" and ")
Bill and Bob and Steve

Apakah Java punya yang seperti ini? Saya tahu saya dapat memperbaiki sesuatu sendiri dengan StringBuilder:

static public String join(List<String> list, String conjunction)
{
   StringBuilder sb = new StringBuilder();
   boolean first = true;
   for (String item : list)
   {
      if (first)
         first = false;
      else
         sb.append(conjunction);
      sb.append(item);
   }
   return sb.toString();
}

... tapi tidak ada gunanya melakukan ini jika sesuatu seperti itu sudah menjadi bagian dari JDK.

Dengan Java 8 Anda dapat melakukan ini tanpa perpustakaan pihak ketiga.

Jika Anda ingin bergabung dengan Kumpulan String, Anda dapat menggunakan metode String.join () baru :

List<String> list = Arrays.asList("foo", "bar", "baz");
String joined = String.join(" and ", list); // "foo and bar and baz"

Jika Anda memiliki Koleksi dengan tipe selain String, Anda dapat menggunakan Stream API dengan Collector yang bergabung :

List<Person> list = Arrays.asList(
  new Person("John", "Smith"),
  new Person("Anna", "Martinez"),
  new Person("Paul", "Watson ")
);

String joinedFirstNames = list.stream()
  .map(Person::getFirstName)
  .collect(Collectors.joining(", ")); // "John, Anna, Paul"

The StringJoinerkelas juga mungkin berguna.

Semua referensi ke Apache Commons baik-baik saja (dan itulah yang kebanyakan orang gunakan) tapi saya pikir setara Guava , Joiner , memiliki API yang jauh lebih baik.

Anda dapat melakukan kasing sederhana dengan

Joiner.on(" and ").join(names)

tetapi juga dengan mudah menangani nulls:

Joiner.on(" and ").skipNulls().join(names);

atau

Joiner.on(" and ").useForNull("[unknown]").join(names);

dan (cukup berguna sejauh yang saya kehendaki untuk menggunakannya dalam preferensi untuk commons-lang), kemampuan untuk berurusan dengan Maps:

Map<String, Integer> ages = .....;
String foo = Joiner.on(", ").withKeyValueSeparator(" is ").join(ages);
// Outputs:
// Bill is 25, Joe is 30, Betty is 35

yang sangat berguna untuk debugging dll.

Bukan di luar kotak, tetapi banyak perpustakaan memiliki kesamaan:

Commons Lang:

org.apache.commons.lang.StringUtils.join(list, conjunction);

Musim semi:

org.springframework.util.StringUtils.collectionToDelimitedString(list, conjunction);

Di Android Anda bisa menggunakan kelas TextUtils .

TextUtils.join(" and ", names);

Tidak, tidak ada metode kenyamanan seperti itu di API Java standar.

Tidak mengherankan, Apache Commons menyediakan hal semacam itu di kelas StringUtils mereka jika Anda tidak ingin menulisnya sendiri.

Tiga kemungkinan di Jawa 8:

List<String> list = Arrays.asList("Alice", "Bob", "Charlie")

String result = String.join(" and ", list);

result = list.stream().collect(Collectors.joining(" and "));

result = list.stream().reduce((t, u) -> t + " and " + u).orElse("");

Dengan kolektor java 8, ini dapat dilakukan dengan kode berikut:

Arrays.asList("Bill", "Bob", "Steve").stream()
.collect(Collectors.joining(" and "));

Juga, solusi paling sederhana di java 8:

String.join(" and ", "Bill", "Bob", "Steve");

atau

String.join(" and ", Arrays.asList("Bill", "Bob", "Steve"));

Saya menulis ini (saya menggunakannya untuk kacang dan mengeksploitasi toString, jadi jangan menulis Collection<String>):

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

tetapi Collectiontidak didukung oleh JSP, jadi untuk TLD 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 dimasukkan 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 menggunakannya dalam file JSP sebagai:

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

Kode yang Anda miliki adalah cara yang benar untuk melakukannya jika Anda ingin menggunakan JDK tanpa pustaka eksternal. Tidak ada "satu garis" sederhana yang dapat Anda gunakan di JDK.

Jika Anda dapat menggunakan libs eksternal, saya sarankan Anda melihat ke kelas org.apache.commons.lang.StringUtils di pustaka Apache Commons.

Contoh penggunaan:

List<String> list = Arrays.asList("Bill", "Bob", "Steve");
String joinedResult = StringUtils.join(list, " and ");

Cara ortodoks untuk mencapainya, adalah dengan mendefinisikan fungsi baru:

public static String join(String joinStr, String... strings) {
    if (strings == null || strings.length == 0) {
        return "";
    } else if (strings.length == 1) {
        return strings[0];
    } else {
        StringBuilder sb = new StringBuilder(strings.length * 1 + strings[0].length());
        sb.append(strings[0]);
        for (int i = 1; i < strings.length; i++) {
            sb.append(joinStr).append(strings[i]);
        }
        return sb.toString();
    }
}

Sampel:

String[] array = new String[] { "7, 7, 7", "Bill", "Bob", "Steve",
        "[Bill]", "1,2,3", "Apple ][","~,~" };

String joined;
joined = join(" and ","7, 7, 7", "Bill", "Bob", "Steve", "[Bill]", "1,2,3", "Apple ][","~,~");
joined = join(" and ", array); // same result

System.out.println(joined);

Keluaran:

7, 7, 7 dan Bill dan Bob dan Steve dan [Bill] dan 1,2,3 dan Apple] [dan ~, ~

Solusi Java 8 dengan java.util.StringJoiner

Java 8 telah mendapat StringJoinerkelas. Tetapi Anda masih perlu menulis sedikit boilerplate, karena itu Java.

StringJoiner sj = new StringJoiner(" and ", "" , "");
String[] names = {"Bill", "Bob", "Steve"};
for (String name : names) {
   sj.add(name);
}
System.out.println(sj);

Anda bisa menggunakan pustaka apache commons yang memiliki kelas StringUtils dan metode bergabung.

Periksa tautan ini: https://commons.apache.org/proper/commons-lang/javadocs/api.2.0/org/apache/commons/lang/StringUtils.html

Perhatikan bahwa tautan di atas dapat menjadi usang seiring waktu, dalam hal ini Anda bisa mencari "apache commons StringUtils" di web, yang memungkinkan Anda menemukan referensi terbaru.

(dirujuk dari utas ini) Java equivalents dari C # String.Format () dan String.Join ()

Kamu bisa melakukan ini:

String aToString = java.util.Arrays.toString(anArray);
// Do not need to do this if you are OK with '[' and ']'
aToString = aToString.substring(1, aToString.length() - 1);

Atau satu-liner (hanya ketika Anda tidak ingin '[' dan ']')

String aToString = java.util.Arrays.toString(anArray).substring(1).replaceAll("\\]$", "");

Semoga ini membantu.

Cara yang menyenangkan untuk melakukannya dengan JDK murni, dalam satu tugas:

String[] array = new String[] { "Bill", "Bob", "Steve","[Bill]","1,2,3","Apple ][" };
String join = " and ";

String joined = Arrays.toString(array).replaceAll(", ", join)
        .replaceAll("(^\\[)|(\\]$)", "");

System.out.println(joined);

Keluaran:

Bill dan Bob dan Steve dan [Bill] dan 1,2,3 dan Apple] [

Cara yang tidak terlalu sempurna & tidak terlalu menyenangkan!

String[] array = new String[] { "7, 7, 7","Bill", "Bob", "Steve", "[Bill]",
        "1,2,3", "Apple ][" };
String join = " and ";

for (int i = 0; i < array.length; i++) array[i] = array[i].replaceAll(", ", "~,~");
String joined = Arrays.toString(array).replaceAll(", ", join)
        .replaceAll("(^\\[)|(\\]$)", "").replaceAll("~,~", ", ");

System.out.println(joined);

Keluaran:

7, 7, 7 dan Bill dan Bob dan Steve dan [Bill] dan 1,2,3 dan Apple] [

Anda mungkin ingin mencoba metode bergabung bersama Apache Commons StringUtils:

http://commons.apache.org/lang/api/org/apache/commons/lang/StringUtils.html#join(java.util.Iterator , java.lang.String)

Saya telah menemukan bahwa Apache StringUtils mengambil slack jdk ;-)

Jika Anda menggunakan Eclipse Collections (sebelumnya GS Collections ), Anda dapat menggunakan makeString()metode ini.

List<String> list = Arrays.asList("Bill", "Bob", "Steve");

String string = ListAdapter.adapt(list).makeString(" and ");

Assert.assertEquals("Bill and Bob and Steve", string);

Jika Anda dapat mengonversi Anda Listke jenis Koleksi Eclipse, maka Anda dapat menyingkirkan adaptor.

MutableList<String> list = Lists.mutable.with("Bill", "Bob", "Steve");
String string = list.makeString(" and ");

Jika Anda hanya ingin string yang dipisahkan koma, Anda dapat menggunakan versi makeString()yang tidak menggunakan parameter.

Assert.assertEquals(
    "Bill, Bob, Steve", 
    Lists.mutable.with("Bill", "Bob", "Steve").makeString());

Catatan: Saya pengendara untuk Eclipse Collections.

Dengan java 1.8 stream dapat digunakan,

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
List<String> list = Arrays.asList("Bill","Bob","Steve").
String str = list.stream().collect(Collectors.joining(" and "));

EDIT

Saya juga memperhatikan toString()masalah implementasi yang mendasarinya, dan tentang elemen yang mengandung pemisah tetapi saya pikir saya sedang paranoid.

Karena saya punya dua komentar tentang hal itu, saya mengubah jawaban saya ke:

static String join( List<String> list , String replacement  ) {
    StringBuilder b = new StringBuilder();
    for( String item: list ) { 
        b.append( replacement ).append( item );
    }
    return b.toString().substring( replacement.length() );
}

Yang terlihat sangat mirip dengan pertanyaan aslinya.

Jadi, jika Anda tidak ingin menambahkan seluruh toples ke proyek Anda, Anda dapat menggunakan ini.

Saya pikir tidak ada yang salah dengan kode asli Anda. Sebenarnya, alternatif yang disarankan semua orang terlihat hampir sama (meskipun ia melakukan sejumlah validasi tambahan)

Ini dia, bersama dengan lisensi Apache 2.0.

public static String join(Iterator iterator, String separator) {
    // handle null, zero and one elements before building a buffer
    if (iterator == null) {
        return null;
    }
    if (!iterator.hasNext()) {
        return EMPTY;
    }
    Object first = iterator.next();
    if (!iterator.hasNext()) {
        return ObjectUtils.toString(first);
    }

    // two or more elements
    StringBuffer buf = new StringBuffer(256); // Java default is 16, probably too small
    if (first != null) {
        buf.append(first);
    }

    while (iterator.hasNext()) {
        if (separator != null) {
            buf.append(separator);
        }
        Object obj = iterator.next();
        if (obj != null) {
            buf.append(obj);
        }
    }
    return buf.toString();
}

Sekarang kami tahu, terima kasih open source

Google Guava API juga memiliki .join (), walaupun (seperti yang seharusnya jelas dengan balasan lainnya), Apache Commons cukup standar di sini.

Java 8 memang membawa

Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

metode, yaitu nullsafe dengan menggunakan prefix + suffixnilai null.

Itu dapat digunakan dengan cara berikut:

String s = stringList.stream().collect(Collectors.joining(" and ", "prefix_", "_suffix"))

The Collectors.joining(CharSequence delimiter)Metode hanya panggilan joining(delimiter, "", "")internal.

Anda dapat menggunakan ini dari StringUtils Spring Framework. Saya tahu ini sudah disebutkan, tetapi Anda benar-benar bisa mengambil kode ini dan langsung berfungsi, tanpa perlu Spring untuk itu.

// from https://github.com/spring-projects/spring-framework/blob/master/spring-core/src/main/java/org/springframework/util/StringUtils.java

/*
 * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
public class StringUtils {
    public static String collectionToDelimitedString(Collection<?> coll, String delim, String prefix, String suffix) {
        if(coll == null || coll.isEmpty()) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        Iterator<?> it = coll.iterator();
        while (it.hasNext()) {
            sb.append(prefix).append(it.next()).append(suffix);
            if (it.hasNext()) {
                sb.append(delim);
            }
        }
        return sb.toString();
    }
}

Coba ini:

java.util.Arrays.toString(anArray).replaceAll(", ", ",")
                .replaceFirst("^\\[","").replaceFirst("\\]$","");