Najbardziej wyrafinowany sposób tworzenia ciągów znaków oddzielonych przecinkami z kolekcji / tablicy / listy?

Podczas pracy z bazami danych zauważyłem, że piszę ciągi zapytań i muszę w nich umieścić kilka ograniczeń w klauzuli where z listy / tablicy / kolekcji. Powinien wyglądać tak:

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

Możesz to uprościć, redukując to do pytania, że ​​masz kolekcję ciągów i chcesz utworzyć listę tych ciągów oddzielonych przecinkami w jednym ciągu.

Moje podejście, które stosowałem do tej pory, jest takie:

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

Ale to jest, jak widać, bardzo brzydkie. Nie widać, co się tam dzieje na pierwszy rzut oka, zwłaszcza gdy konstruowane łańcuchy (jak każde zapytanie SQL) stają się skomplikowane.

Jaki jest Twój (bardziej) elegancki sposób?

Uwaga: te odpowiedzi były dobre, gdy zostały napisane 11 lat temu, ale teraz są znacznie lepsze opcje, aby zrobić to czysto w jednej linii, zarówno przy użyciu tylko wbudowanych klas Java, jak i biblioteki narzędziowej. Zobacz inne odpowiedzi poniżej.

Ponieważ ciągi są niezmienne, możesz chcieć użyć klasy StringBuilder, jeśli zamierzasz zmienić String w kodzie.

Klasę StringBuilder można postrzegać jako zmienny obiekt String, który przydziela więcej pamięci w przypadku zmiany zawartości.

Oryginalną sugestię w pytaniu można napisać jeszcze jaśniej i wydajniej, zwracając uwagę na zbędne końcowe przecinki :

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

Użyj Google guawy API „s joinmetody:

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

Właśnie spojrzałem na kod, który zrobił to dzisiaj. To jest wariacja na temat odpowiedzi AviewAnew.

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

W StringUtils (<- commons.lang 2.x lub commons.lang Link 3.x ) użyliśmy jest z Apache Commons .

Sposób, w jaki piszę tę pętlę, to:

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

Nie martw się o wydajność września. Zadanie jest bardzo szybkie. Hotspot i tak ma tendencję do zrywania pierwszej iteracji pętli (ponieważ często ma do czynienia z dziwactwami, takimi jak zerowe i mono / bimorficzne wbudowane kontrole).

Jeśli używasz go dużo (więcej niż raz), umieść go w wspólnej metodzie.

Jest jeszcze jedno pytanie dotyczące stackoverflow, dotyczące wstawiania listy identyfikatorów do instrukcji SQL.

Od wersji Java 8 możesz używać:

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

• Jeśli chcesz wziąć non- Strings i dołączyć je do a String, możesz użyć Collectors.joining(CharSequence delimiter)np:

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

Uważam, że idiom iteratora jest elegancki, ponieważ ma test dla większej liczby elementów (pominięty test zerowy / pusty ze względu na zwięzłość):

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

Jest wiele ręcznych rozwiązań tego problemu, ale chciałem powtórzyć i zaktualizować powyższą odpowiedź Julie. Użyj kolekcji Google Joiner class .

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

Obsługuje zmienne argumenty, iterowalne i tablice oraz poprawnie obsługuje separatory więcej niż jednego znaku (w przeciwieństwie do odpowiedzi gimmela). Jeśli zajdzie taka potrzeba, będzie również obsługiwać wartości null na liście.

Oto niesamowicie ogólna wersja, którą stworzyłem na podstawie kombinacji poprzednich sugestii:

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)

dostępne w api Java8.

alternatywa dla (bez potrzeby dodawania zależności od google guava):

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

Możesz spróbować

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

Będzie to jak dotąd najkrótsze rozwiązanie, z wyjątkiem użycia Guava lub Apache Commons

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

Dobrze z listą elementów 0, 1 i n. Ale musisz sprawdzić listę zerową. Używam tego w GWT, więc jestem dobry bez StringBuildera. A w przypadku krótkich list zawierających tylko kilka elementów, gdzie indziej jest w porządku;)

Na wypadek, gdyby ktoś natknął się na to ostatnio, dodałem prostą odmianę za pomocą Java 8 reduce(). Zawiera również niektóre z wymienionych już rozwiązań innych:

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, ","));

  }
}

W Androidzie powinieneś użyć tego:

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

Myślę, że nie jest dobrym pomysłem tworzenie sql konkatenacji wartości klauzuli where, tak jak robisz:

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

Skąd valueXpochodzi lista ciągów znaków.

Po pierwsze, jeśli porównujesz ciągi znaków, muszą być cytowane, a to nie jest trywialne, jeśli ciągi mogą zawierać cudzysłów.

Po drugie, jeśli wartości pochodzą od użytkownika lub innego systemu, możliwy jest atak typu SQL injection.

Jest o wiele bardziej rozwlekły, ale powinieneś stworzyć taki łańcuch:

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

a następnie powiąż zmienne z Statement.setString(nParameter,parameterValue).

Kolejna metoda radzenia sobie z tym problemem. Nie jest to najkrótsze, ale jest wydajne i wykonuje swoją pracę.

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

Istnieją biblioteki Java innych firm, które zapewniają metodę łączenia ciągów, ale prawdopodobnie nie chcesz rozpoczynać korzystania z biblioteki tylko do czegoś takiego. Po prostu stworzyłbym pomocniczą metodę taką jak ta, która moim zdaniem jest nieco lepsza niż twoja wersja, używa StringBuffer, który będzie bardziej wydajny, jeśli będziesz musiał łączyć wiele ciągów, i działa na kolekcjach dowolnego typu.

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

Inna sugestia dotycząca używania Collection.toString () jest krótsza, ale polega na tym, że Collection.toString () zwraca ciąg w bardzo specyficznym formacie, na którym osobiście nie chciałbym polegać.

Jeśli używasz Spring, możesz:

StringUtils.arrayToCommaDelimitedString(
    collectionOfStrings.toArray()
)

(pakiet org.springframework.util)

Nie jestem pewien, jak to jest „wyrafinowane”, ale z pewnością jest trochę krótsze. Będzie działać z różnymi typami kolekcji, np. Set <Integer>, List <String> itp.

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) + ")";
}

Ćwiczenie dla czytelnika : zmodyfikuj tę metodę, aby poprawnie obsługiwała zerową / pustą kolekcję :)

To, co sprawia, że ​​kod jest brzydki, to specjalna obsługa pierwszego przypadku. Większość wierszy w tym małym fragmencie poświęcona jest nie rutynowej pracy kodu, ale obsłudze tego specjalnego przypadku. I to właśnie są alternatywy, takie jak rozwiązanie Gimela, poprzez przeniesienie specjalnej obsługi poza pętlę. Jest jeden przypadek specjalny (cóż, można zobaczyć zarówno początek, jak i koniec jako przypadki specjalne - ale tylko jeden z nich wymaga specjalnego traktowania), więc obsługa go wewnątrz pętli jest niepotrzebnie skomplikowana.

Właśnie zarejestrowałem test na dolara z biblioteki :

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

stworzy biegle otoki wokół lists / tablice / sznurki / etc przy użyciu tylko jednej statyczny import : $.

Uwaga :

przy użyciu zakresów poprzednia lista może zostać ponownie zapisana jako $(1, 5).join(",")

Zaletą wyrażenia IN jest to, że jeśli masz powtarzające się wartości, nie zmienia to wyniku. Więc po prostu zduplikuj pierwszy element i przetwórz całą listę. Zakłada się, że na liście znajduje się co najmniej jedna pozycja. Jeśli nie ma żadnych elementów, sugerowałbym najpierw sprawdzenie tego, a następnie całkowite powstrzymanie się od wykonywania kodu SQL.

To wystarczy, jest oczywiste w tym, co robi i nie polega na żadnych zewnętrznych bibliotekach:

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

Chociaż myślę, że najlepszym rozwiązaniem jest użycie Joinera z Guava, gdybym miał kodować go ręcznie, uważam, że to podejście jest bardziej eleganckie niż „pierwsza” flaga lub odcięcie ostatniego przecinka.

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

jeśli masz tablicę, możesz zrobić:

Arrays.asList(parameters).toString()

Inna opcja, na podstawie tego, co tu widzę (z niewielkimi modyfikacjami).

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

„Metody” łączenia są dostępne w tablicach i klasach, które rozszerzają metodę, AbstractCollectionsale jej nie zastępują toString()(podobnie jak praktycznie wszystkie kolekcje w java.util).

Na przykład:

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

To dość dziwny sposób, ponieważ działa tylko dla liczb podobnych do danych w języku SQL.

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

StringUtils z springframeowrk: sprężynowy rdzeń

Możesz być w stanie użyć LINQ (to SQL) i możesz być w stanie skorzystać z przykładu Dynamic Query LINQ z MS. 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

Reprezentacja łańcuchowa składa się z listy elementów kolekcji w kolejności, w jakiej są zwracane przez iterator, ujętej w nawiasy kwadratowe („[]”). Sąsiednie elementy oddzielone są znakami „,” (przecinek i spacja).

AbstractCollection javadoc

List token = new ArrayList (result); końcowy konstruktor 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 ();