Самый изощренный способ создания разделенных запятыми строк из коллекции / массива / списка?

Во время работы с базами данных я заметил, что пишу строки запроса, и в этих строках я должен поставить несколько ограничений в предложение where из списка / массива / коллекции. Должно получиться так:

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

Вы можете упростить это, сведя это к вопросу о том, что у вас есть набор строк и вы хотите создать список этих строк, разделенных запятыми, всего в одной строке.

Мой подход, который я использовал до сих пор, выглядит примерно так:

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

Но это как видите очень некрасиво. Вы не можете увидеть, что там происходит с первого взгляда, особенно когда построенные строки (как и каждый запрос SQL) усложняются.

Какой у вас (более) элегантный образ?

Примечание. Эти ответы были хорошими, когда они были написаны 11 лет назад, но теперь есть гораздо лучшие варианты сделать это более чисто в одной строке, как с использованием только встроенных классов Java, так и с использованием служебной библиотеки. См. Другие ответы ниже.

Поскольку строки неизменяемы, вы можете использовать класс StringBuilder, если собираетесь изменить String в коде.

Класс 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 гуавы 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();

Не беспокойтесь о производительности sep. Задание выполняется очень быстро. Hotspot имеет тенденцию откладывать первую итерацию цикла в любом случае (поскольку ему часто приходится иметь дело с такими странностями, как нулевые и моно / биморфные проверки встраивания).

Если вы используете его много (более одного раза), поместите его в общий метод.

Есть еще один вопрос о stackoverflow, касающийся того, как вставить список идентификаторов в оператор SQL.

Начиная с Java 8, вы можете использовать:

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

• Если вы хотите взять non- Strings и присоединить их к a String, вы можете использовать Collectors.joining(CharSequence delimiter), например:

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

Я нашел идиому итератора элегантной, потому что в ней есть тест на большее количество элементов (для краткости опущен нулевой / пустой тест):

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

Для этого есть много ручных решений, но я хотел повторить и обновить ответ Джули выше. Используйте Google Collections Joiner class .

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

Он обрабатывает аргументы var, итерации и массивы, а также правильно обрабатывает разделители более чем одного символа (в отличие от ответа Гиммеля). Он также будет обрабатывать нулевые значения в вашем списке, если вам это нужно.

Вот невероятно общая версия, которую я построил из комбинации предыдущих предложений:

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.

альтернатива (без необходимости добавлять зависимость google guava):

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. Но вам нужно будет проверить нулевой список. Я использую это в 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());

Я думаю, что это не лучшая идея создавать sql, объединяющий значения предложения where, как вы:

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

Откуда valueXберется из списка строк.

Во-первых, если вы сравниваете строки, они должны быть заключены в кавычки, и это нетривиально, если строки могут содержать кавычки внутри.

Во-вторых, если значения поступают от пользователя или другой системы, то возможна атака с использованием SQL-инъекции.

Он намного более подробный, но вам следует создать такую ​​строку:

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

а затем свяжите переменные с Statement.setString(nParameter,parameterValue) .

Еще один способ справиться с этой проблемой. Не самый короткий, но эффективный и выполняет свою работу.

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

Упражнение для читателя : измените этот метод, чтобы он правильно обрабатывал пустую / пустую коллекцию :)

Что делает код уродливым, так это особая обработка первого случая. Большинство строк в этом небольшом фрагменте посвящены не выполнению рутинной работы кода, а обработке этого особого случая. И это то, что решают альтернативы, такие как gimel's, перемещая специальную обработку за пределы цикла. Есть один особый случай (ну, вы можете видеть и начало, и конец как особые случаи, но только один из них требует особой обработки), поэтому обработка его внутри цикла излишне сложна.

Я только что зарегистрировал тест на свой библиотечный доллар :

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

это создать свободно обертку списков / массивы / строки / и т.д. , используя только один статический импорт : $.

NB :

используя диапазоны, предыдущий список можно переписать как $(1, 5).join(",")

Преимущество выражения IN заключается в том, что если у вас есть повторяющиеся значения, это не меняет результат. Итак, просто продублируйте первый элемент и обработайте весь список. Предполагается, что в списке есть хотя бы один элемент. Если элементов нет, я бы предложил сначала проверить это, а затем вообще не выполнять SQL.

Это поможет, очевидно, в том, что он делает, и не зависит от каких-либо внешних библиотек:

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

Хотя я думаю, что лучше всего использовать Joiner из Guava, если бы я закодировал его вручную, я считаю этот подход более элегантным, чем «первый» флаг или удаление последней запятой.

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

StringUtils из springframeowrk: spring-core

Возможно, вы сможете использовать LINQ (to SQL), и вы сможете использовать образец LINQ для динамических запросов от 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

Строковое представление состоит из списка элементов коллекции в том порядке, в котором они возвращаются ее итератором, заключенного в квадратные скобки («[]»). Смежные элементы разделяются символами «,» (запятая и пробел).

AbstractCollection javadoc

Токен списка = новый ArrayList (результат); окончательный строитель StringBuilder = новый 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 ();