コレクション/配列/リストからカンマ区切りの文字列を作成する最も洗練された方法は？

データベースでの作業中に、クエリ文字列を記述していることに気付きました。この文字列には、リスト/配列/コレクションのwhere句にいくつかの制限を課す必要があります。次のようになります。

select * from customer 
where customer.id in (34, 26, ..., 2);

これを、文字列のコレクションがあり、この文字列のコンマ区切りのリストを1つの文字列だけで作成したいという質問に減らすことで、これを簡略化できます。

これまでに使用した私のアプローチは次のようなものです。

String result = "";
boolean first = true;
for(String string : collectionOfStrings) {
    if(first) {
        result+=string;
        first=false;
    } else {
        result+=","+string;
    }
}

しかし、これは非常に醜いものです。特に、（すべてのSQLクエリのように）構築された文字列が複雑になっている場合、最初の外観で何が起こるかはわかりません。

あなたの（より）エレガントな方法は何ですか？

注：この答えは11年前に書かれたときは良かったですが、Java組み込みクラスのみを使用するか、ユーティリティライブラリを使用するかのどちらかで、1行でこれをよりきれいに行うためのはるかに優れたオプションがあります。以下の他の回答を参照してください。

文字列は不変なので、コード内の文字列を変更する場合は、StringBuilderクラスを使用できます。

StringBuilderクラスは、内容が変更されたときにより多くのメモリを割り当てる可変のStringオブジェクトと見なすことができます。

質問の元の提案は、冗長な末尾のカンマを処理することにより、さらに明確かつ効率的に記述できます。

    StringBuilder result = new StringBuilder();
    for(String string : collectionOfStrings) {
        result.append(string);
        result.append(",");
    }
    return result.length() > 0 ? result.substring(0, result.length() - 1): "";

Google Guava APIのjoinメソッドを使用します。

Joiner.on(",").join(collectionOfStrings);

今日これを行ったコードを見ただけです。これはAviewAnewの回答のバリエーションです。

collectionOfStrings = /* source string collection */;
String csList = StringUtils.join(collectionOfStrings.toArray(), ",");

使用したStringUtils（<-commons.lang 2.x、またはcommons.lang 3.xリンク）は、Apache Commonsのものです。

そのループの記述方法は次のとおりです。

StringBuilder buff = new StringBuilder();
String sep = "";
for (String str : strs) {
    buff.append(sep);
    buff.append(str);
    sep = ",";
}
return buff.toString();

9月のパフォーマンスについて心配する必要はありません。割り当ては非常に高速です。とにかく、ホットスポットはループの最初の反復をはがす傾向があります（ヌルやモノ/バイモルフィックインラインチェックなどの奇妙な要素に対処する必要があるため）。

何度も使用する場合は、共有メソッドに入れてください。

IDのリストをSQLステートメントに挿入する方法を扱う、stackoverflowに関する別の質問があります。

Java 8以降、以下を使用できます。

• String String.join(CharSequence delimiter, CharSequence... elements)
• String String.join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

• 非Strings を取得してに結合したい場合はString、を使用できますCollectors.joining(CharSequence delimiter)。例：

  String joined = anyCollection.stream().map(Object::toString).collect(Collectors.joining(","));

イテレータのイディオムは、より多くの要素のテストがあるため簡潔であることがわかりました（簡潔にするためにnull /空のテストは省略されています）。

public static String convert(List<String> list) {
    String res = "";
    for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
        res += iterator.next() + (iterator.hasNext() ? "," : "");
    }
    return res;
}

これには多くの手動による解決策がありますが、私は上記のジュリーの答えを繰り返し、更新したいと思いました。グーグルコレクションのジョイナークラスを使用してください。

Joiner.on(", ").join(34, 26, ..., 2)

これは変数引数、反復可能オブジェクト、および配列を処理し、複数の文字のセパレータを適切に処理します（ギンメルの答えとは異なります）。必要に応じて、リスト内のnull値も処理します。

ここに私が以前の提案の組み合わせから構築した信じられないほど一般的なバージョンがあります：

public static <T> String buildCommaSeparatedString(Collection<T> values) {
    if (values==null || values.isEmpty()) return "";
    StringBuilder result = new StringBuilder();
    for (T val : values) {
        result.append(val);
        result.append(",");
    }
    return result.substring(0, result.length() - 1);
}

String.join(", ", collectionOfStrings)

Java8 APIで利用できます。

の代わりに（グーグルグアバ依存関係を追加する必要なしに）：

Joiner.on(",").join(collectionOfStrings);

あなたは試すことができます

List collections = Arrays.asList(34, 26, "...", 2);
String asString = collection.toString();
// justValues = "34, 26, ..., 2"
String justValues = asString.substring(1, asString.length()-1);

これは、GuavaまたはApache Commonsを使用することを除いて、これまでのところ最短のソリューションになります

String res = "";
for (String i : values) {
    res += res.isEmpty() ? i : ","+i;
}

0、1、nの要素リストで良好です。ただし、nullリストを確認する必要があります。これをGWTで使用しているので、StringBuilderがなくても問題ありません。そして、要素の数が少ない短いリストの場合、他の場所でも問題ありません;）

最近誰かがこれに遭遇した場合に備えて、Java 8を使用した簡単なバリエーションを追加しましたreduce()。また、他の人がすでに言及したソリューションのいくつかも含まれています。

import java.util.Arrays;
import java.util.List;

import org.apache.commons.lang.StringUtils;    

import com.google.common.base.Joiner;

public class Dummy {
  public static void main(String[] args) {

    List<String> strings = Arrays.asList("abc", "de", "fg");
    String commaSeparated = strings
        .stream()
        .reduce((s1, s2) -> {return s1 + "," + s2; })
        .get();

    System.out.println(commaSeparated);

    System.out.println(Joiner.on(',').join(strings));

    System.out.println(StringUtils.join(strings, ","));

  }
}

Androidでは、これを使用する必要があります。

TextUtils.join(",",collectionOfStrings.toArray());

私はあなたがしているようにwhere句の値を連結するsqlを構築するのは良い考えではないと思います：

SELECT.... FROM.... WHERE ID IN( value1, value2,....valueN)

valueX文字列のリストはどこから来ますか。

まず、文字列を比較する場合は、引用符で囲む必要があります。これは、文字列に引用符を含めることができる場合は簡単ではありません。

次に、値がユーザーまたは他のシステムからのものである場合、SQLインジェクション攻撃が可能です。

これはもっと冗長ですが、次のような文字列を作成する必要があります。

SELECT.... FROM.... WHERE ID IN( ?, ?,....?)

変数をでバインドしますStatement.setString(nParameter,parameterValue)。

この問題に対処するためのもう1つの方法。最も短いわけではありませんが、それは効率的で、仕事を成し遂げます。

/**
 * Creates a comma-separated list of values from given collection.
 * 
 * @param <T> Value type.
 * @param values Value collection.
 * @return Comma-separated String of values.
 */
public <T> String toParameterList(Collection<T> values) {
   if (values == null || values.isEmpty()) {
      return ""; // Depending on how you want to deal with this case...
   }
   StringBuilder result = new StringBuilder();
   Iterator<T> i = values.iterator();
   result.append(i.next().toString());
   while (i.hasNext()) {
      result.append(",").append(i.next().toString());
   }
   return result.toString();
}

文字列結合メソッドを提供するサードパーティのJavaライブラリがいくつかありますが、そのような単純な目的のためだけにライブラリの使用を開始したくない場合があります。私はこのようなヘルパーメソッドを作成しますが、これはあなたのバージョンより少し優れていると思います。StringBufferを使用します。これは、多くの文字列を結合する必要がある場合により効率的で、あらゆるタイプのコレクションで機能します。

public static <T> String join(Collection<T> values)
{
    StringBuffer ret = new StringBuffer();
    for (T value : values)
    {
        if (ret.length() > 0) ret.append(",");
        ret.append(value);
    }
    return ret.toString();
}

Collection.toString（）を使用する別の提案はより短いですが、Collection.toString（）が非常に特定の形式で文字列を返すことに依存しています。

Springを使用すると、次のことができます。

StringUtils.arrayToCommaDelimitedString(
    collectionOfStrings.toArray()
)

（パッケージorg.springframework.util）

これがどれほど「高度」であるかはわかりませんが、確かに少し短いです。Set <Integer>、List <String>など、さまざまな種類のコレクションで機能します。

public static final String toSqlList(Collection<?> values) {

    String collectionString = values.toString();

    // Convert the square brackets produced by Collection.toString() to round brackets used by SQL
    return "(" + collectionString.substring(1, collectionString.length() - 1) + ")";
}

読者のための演習：このメソッドを変更して、null /空のコレクションを正しく処理するようにしてください:)

コードを醜くするのは、最初のケースの特別な処理です。この小さなスニペットのほとんどの行は、コードのルーチンジョブを実行するためではなく、その特殊なケースを処理するために費やされています。そして、それは特別な処理をループの外に移動することによって、ギメルのような代替手段が解決するものです。特別なケースが1つあります（まあ、開始と終了の両方を特別なケースとして見ることができますが、特別に処理する必要があるのは1つだけです）。そのため、ループ内での処理は不必要に複雑です。

ライブラリのドルのテストをチェックインしたところです。

@Test
public void join() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    String string = $(list).join(",");
}

それは使用など/リスト/配列/文字列の周りに流暢なラッパーを作成する唯一の静的インポートを：$。

注意：

範囲を使用すると、前のリストは次のように書き直すことができます $(1, 5).join(",")

IN式の良い点は、値を繰り返し使用しても結果が変化しないことです。したがって、最初のアイテムを複製してリスト全体を処理するだけです。これは、リストに少なくとも1つの項目があることを前提としています。アイテムがない場合は、まずチェックしてからSQLをまったく実行しないことをお勧めします。

これはトリックを実行し、それが何をしているのかは明らかであり、外部ライブラリに依存しません。

StringBuffer inString = new StringBuffer(listOfIDs.get(0).toString());
for (Long currentID : listOfIDs) {
  inString.append(",").append(currentID);
}

私はあなたの最善の策はグアバのジョイナーを使用することだと思いますが、私が手作業でコーディングした場合、このアプローチは「最初の」フラグまたは最後のカンマを切り取るよりもエレガントだと思います。

private String commas(Iterable<String> strings) {
    StringBuilder buffer = new StringBuilder();
    Iterator<String> it = strings.iterator();
    if (it.hasNext()) {
        buffer.append(it.next());
        while (it.hasNext()) {
            buffer.append(',');
            buffer.append(it.next());
        }
    }

    return buffer.toString();
}

配列がある場合は、次のことができます。

Arrays.asList(parameters).toString()

私がここで見るものに基づいた別のオプション（わずかな変更を加えて）。

public static String toString(int[] numbers) {
    StringBuilder res = new StringBuilder();
    for (int number : numbers) {
        if (res.length() != 0) {
            res.append(',');
        }
        res.append(number);
    }
    return res.toString();
}

結合 'メソッド'は、配列と、拡張するAbstractCollectionsがtoString()メソッドをオーバーライドしないクラスで使用できます（実質的にすべてのコレクションのようにjava.util）。

例えば：

String s= java.util.Arrays.toString(collectionOfStrings.toArray());
s = s.substing(1, s.length()-1);// [] are guaranteed to be there

SQLに関してはデータが同じような数値に対してのみ機能するため、これはかなり奇妙な方法です。

List<String> collectionOfStrings = // List of string to concat
String csvStrings = StringUtils.collectionToDelimitedString(collectionOfStrings, ",");

springframeowrk：spring-coreのStringUtils

LINQ（to SQL）を使用でき、MSのDynamic Query LINQサンプルを利用できる場合があります。http://weblogs.asp.net/scottgu/archive/2008/01/07/dynamic-linq-part-1-using-the-linq-dynamic-query-library.aspx

java.util.List<String> lista = new java.util.ArrayList<String>();
lista.add("Hola");
lista.add("Julio");
System.out.println(lista.toString().replace('[','(').replace(']',')'));

$~(Hola, Julio)

String commaSeparatedNames = namesList.toString().replaceAll( "[\\[|\\]| ]", "" );  // replace [ or ] or blank

文字列表現は、コレクションの要素のリストで構成され、イテレータによって返された順序で、角かっこ（ "[]"）で囲まれています。隣接する要素は、文字「、」（カンマとスペース）で区切られます。

AbstractCollection javadoc

List token = new ArrayList（result）; 最終的なStringBuilderビルダー= new StringBuilder（）;

    for (int i =0; i < tokens.size(); i++){
        builder.append(tokens.get(i));
        if(i != tokens.size()-1){
            builder.append(TOKEN_DELIMITER);
        }
    }

builder.toString（）;