목록을 쉼표로 구분하는 가장 간단한 방법?

목록을 쉼표로 구분하는 가장 간단한 방법?

Java에서 목록을 쉼표로 구분하는 가장 명확한 방법은 무엇입니까?

저는 몇 가지 방법을 알고 있지만, 가장 효과적인 방법이 무엇인지 궁금합니다('최고'는 가장 명확하거나 가장 짧다는 의미이며, 가장 효율적이지 않다는 의미).

리스트가 있고, 각 값을 인쇄하여 루프하고 싶습니다.각 항목 사이에 콤마를 인쇄하고 싶은데, 마지막 항목 뒤에는 인쇄하지 않습니다(첫 번째 항목 앞에도 인쇄하지 않습니다.

List --> Item ( , Item ) *
List --> ( Item , ) * Item

솔루션 예시 1:

boolean isFirst = true;
for (Item i : list) {
  if (isFirst) {
    System.out.print(i);        // no comma
    isFirst = false;
  } else {
    System.out.print(", "+i);   // comma
  }
}

솔루션 2 예시 - 서브리스트 작성:

if (list.size()>0) {
  System.out.print(list.get(0));   // no comma
  List theRest = list.subList(1, list.size());
  for (Item i : theRest) {
    System.out.print(", "+i);   // comma
  }
}

솔루션 3의 예:

  Iterator<Item> i = list.iterator();
  if (i.hasNext()) {
    System.out.print(i.next());
    while (i.hasNext())
      System.out.print(", "+i.next());
  }

이것들은 첫 번째 아이템을 특별하게 취급한다.대신 마지막 아이템을 특별하게 취급할 수 있다.

하겠습니다.List toString 구현되어 있다(에서 상속됨)AbstractCollection 1.: Java 1.6의 경우:

public String toString() {
    Iterator<E> i = iterator();
    if (! i.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = i.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! i.hasNext())
            return sb.append(']').toString();
        sb.append(", ");
    }
}

마지막 항목 뒤의 쉼표를 피하기 위해 루프를 조기에 종료합니다.BTW: (이 컬렉션을) 본 것은 이번이 처음입니다.이것을 자극하는 코드는 다음과 같습니다.

List l = new LinkedList();
l.add(l);
System.out.println(l);

예상치 못한 라이브러리를 사용하더라도 어떤 솔루션이라도 환영합니다(regexp).또한 Java 이외의 언어로 된 솔루션도 있습니다(예를 들어 Python/Ruby는 인터스페스 함수가 있다고 생각합니다만, 어떻게 구현됩니까?).

설명: 라이브러리란 표준 Java 라이브러리를 말합니다.다른 라이브러리의 경우 다른 언어를 사용하는 것을 고려하고 구현 방법을 알고 싶습니다.

EDIT 툴킷은 유사한 질문을 언급했습니다.java의 루프를 위한 확장의 마지막 반복입니다.

그리고 또 하나:루프의 마지막 요소는 별도로 취급할 필요가 있습니까?

Java 8 이후

클래스 및 메서드 사용:

StringJoiner joiner = new StringJoiner(",");
list.forEach(item -> joiner.add(item.toString());
return joiner.toString();

및 을 사용하는 경우:

return list.stream().
       map(Object::toString).
       collect(Collectors.joining(",")).toString();

Java 7 이전 버전

'#285523'도 참조해 주세요.

String delim = "";
for (Item i : list) {
    sb.append(delim).append(i);
    delim = ",";
}

org.apache.commons.lang3.StringUtils.join(list,",");

Java 8은 이를 위한 몇 가지 새로운 방법을 제공합니다.

• 의 방법String.
• 로부터의 스트림 수집기Collectors를 누릅니다
• 학급.

예:

// Util method for strings and other char sequences
List<String> strs = Arrays.asList("1", "2", "3");
String listStr1 = String.join(",", strs);

// For any type using streams and collectors
List<Object> objs = Arrays.asList(1, 2, 3);
String listStr2 = objs.stream()
    .map(Object::toString)
    .collect(joining(",", "[", "]"));

// Using the new StringJoiner class
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.setEmptyValue("<empty>");
for (Integer i : objs) {
  joiner.add(i.toString());
}
String listStr3 = joiner.toString();

은 스트음음음음음음음음음음음 the the the the the the the the the the the the the the the 를 상정하고 있다.import static java.util.stream.Collectors.joining;.

Joiner.on(",").join(myList)

조이너

Spring Framework를 사용하는 경우 String Utils를 사용하여 실행할 수 있습니다.

public static String arrayToDelimitedString(Object[] arr)
public static String arrayToDelimitedString(Object[] arr, String delim)
public static String collectionToCommaDelimitedString(Collection coll)
public static String collectionToCommaDelimitedString(Collection coll, String delim)

Java의 List toString 구현을 기반으로 합니다.

Iterator i = list.iterator();
for (;;) {
  sb.append(i.next());
  if (! i.hasNext()) break;
  ab.append(", ");
}

다음과 같은 문법을 사용합니다.

List --> (Item , )* Item

퍼스트 베이스가 아닌 라스트 베이스가 되면, 같은 테스트로 skip-comma 를 체크해, 리스트의 종료를 체크할 수 있습니다.이것은 매우 우아한 것 같습니다만, 명확성은 잘 모르겠습니다.

Java 8을 사용하여 이를 실현하는 좋은 방법이 있습니다.

List<String> list = Arrays.asList(array);
String joinedString = String.join(",", list);

for(int i=0, length=list.size(); i<length; i++)
  result+=(i==0?"":", ") + list.get(i);

String delimiter = ",";
StringBuilder sb = new StringBuilder();
for (Item i : list) {
    sb.append(delimiter).append(i);
}
sb.toString().replaceFirst(delimiter, "");

foreach 루프의 1가지 옵션은 다음과 같습니다.

StringBuilder sb = new StringBuilder();
for(String s:list){
  if (sb.length()>0) sb.append(",");
  sb.append(s);
}

StringBuffer result = new StringBuffer();
for(Iterator it=list.iterator; it.hasNext(); ) {
  if (result.length()>0)
    result.append(", ");
  result.append(it.next());
}

업데이트: Dave Web이 코멘트에서 언급했듯이 목록의 첫 번째 항목이 빈 문자열일 경우 올바른 결과가 나오지 않을 수 있습니다.

저는 보통 이렇게 해요.

StringBuffer sb = new StringBuffer();
Iterator it = myList.iterator();
if (it.hasNext()) { sb.append(it.next().toString()); }
while (it.hasNext()) { sb.append(",").append(it.next().toString()); }

앞으로는 Java 실장에 따라 이 체크에 임할 예정입니다.

Groovy(JVM에서 실행)를 사용할 수 있는 경우:

def list = ['a', 'b', 'c', 'd']
println list.join(',')

(여기서 제 답변 복사 붙여넣기)여기서 설명하는 솔루션의 대부분은 IMHO, 특히 외부 라이브러리에 의존하는 솔루션보다 약간 과장되어 있습니다.쉼표로 구분된 목록을 작성하기 위한 깨끗하고 명확한 관용구가 있습니다.조건 연산자(?)에 의존합니다.

편집: 원래 솔루션은 올바르지만 코멘트에 따르면 최적은 아닙니다.두 번째 시도:

int[] array = {1, 2, 3};
StringBuilder builder = new StringBuilder();
for (int i = 0 ;  i < array.length; i++)
       builder.append(i == 0 ? "" : ",").append(array[i]);

어레이 선언과 String Builder를 포함한 4줄의 코드로 구성됩니다.

두 번째 편집:반복기를 취급하는 경우:

    List<Integer> list = Arrays.asList(1, 2, 3);
    StringBuilder builder = new StringBuilder();
    for (Iterator it = list.iterator(); it.hasNext();)
        builder.append(it.next()).append(it.hasNext() ? "," : "");

저는 원래 버전 3과 비슷한 걸 써요.c/c++/bash/...:P는 정상적으로 동작합니다.

내가 컴파일한 게 아니라...(또는 거의) 동작해야 합니다.

public static <T> String toString(final List<T> list, 
                                  final String delim)
{
    final StringBuilder builder;

    builder = new StringBuilder();

    for(final T item : list)
    {
        builder.append(item);
        builder.append(delim);
    }

    // kill the last delim
    builder.setLength(builder.length() - delim.length());

    return (builder.toString());
}

이것은 매우 짧고, 매우 명확하지만, 나의 감성을 소름끼치게 한다.다른 딜리미터에 적응하는 것도 조금 곤란합니다.특히 문자열(문자 이외)의 경우는 더욱 그렇습니다.

for (Item i : list)
  sb.append(',').append(i);
if (sb.charAt(0)==',') sb.deleteCharAt(0);

영감을 받아: Java에서 루프를 확장한 최신 버전

StringBuffer sb = new StringBuffer();

for (int i = 0; i < myList.size(); i++)
{ 
    if (i > 0) 
    {
        sb.append(", ");
    }

    sb.append(myList.get(i)); 
}

얼마 전 블로그에서 찾은 이 접근법이 마음에 듭니다.아쉽게도 블로그 이름/URL이 기억나지 않습니다.

다음과 같은 유틸리티/도움말 클래스를 만들 수 있습니다.

private class Delimiter
{
    private final String delimiter;
    private boolean first = true;

    public Delimiter(String delimiter)
    {
        this.delimiter = delimiter;
    }

    @Override
    public String toString()
    {
        if (first) {
            first = false;
            return "";
        }

        return delimiter;
    }
}

도우미 클래스의 사용은 다음과 같이 간단합니다.

StringBuilder sb = new StringBuilder();
Delimiter delimiter = new Delimiter(", ");

for (String item : list) {
    sb.append(delimiter);
    sb.append(item);
}

딜리미터는 ", "이므로 다음 중 하나를 사용할 수 있습니다.

public class StringDelim {

    public static void removeBrackets(String string) {
        System.out.println(string.substring(1, string.length() - 1));
    }

    public static void main(String... args) {
        // Array.toString() example
        String [] arr = {"Hi" , "My", "name", "is", "br3nt"};
        String string = Arrays.toString(arr);
        removeBrackets(string);

        // List#toString() example
        List<String> list = new ArrayList<String>();
        list.add("Hi");
        list.add("My");
        list.add("name");
        list.add("is");
        list.add("br3nt");
        string = list.toString();
        removeBrackets(string);

        // Map#values().toString() example
        Map<String, String> map = new LinkedHashMap<String, String>();
        map.put("1", "Hi");
        map.put("2", "My");
        map.put("3", "name");
        map.put("4", "is");
        map.put("5", "br3nt");
        System.out.println(map.values().toString());
        removeBrackets(string);

        // Enum#toString() example
        EnumSet<Days> set = EnumSet.allOf(Days.class);
        string = set.toString();
        removeBrackets(string);
    }

    public enum Days {
        MON("Monday"),
        TUE("Tuesday"),
        WED("Wednesday"),
        THU("Thursday"),
        FRI("Friday"),
        SAT("Saturday"),
        SUN("Sunday");

        private final String day;

        Days(String day) {this.day = day;}
        public String toString() {return this.day;}
    }
}

딜리미터가 그 외의 경우는, 이 조작을 실행할 수 없습니다.

이 솔루션이 마음에 듭니다.

String delim = " - ", string = "";

for (String item : myCollection)
    string += delim + item;

string = string.substring(delim.length());

String Builder도 사용할 수 있을 것 같습니다.

제 생각에는 이것이 읽고 이해하는 가장 간단한 방법입니다.

StringBuilder sb = new StringBuilder();
for(String string : strings) {
    sb.append(string).append(',');
}
sb.setLength(sb.length() - 1);
String result = sb.toString();

Python에서는 쉽다

"," . (( ( your list )

C#에는 String 클래스에 static 메서드가 있습니다.

String.Join("", your list ofstrings)

미안해요, 자바에 대해서는 잘 모르겠지만 당신이 다른 언어에 대해 물어봤을 때 제가 좀 과장하려고 했어요.자바에도 분명히 비슷한 게 있을 거예요.

딜리미터 문자열을 무조건 추가할 수도 있습니다.루프 후에 마지막에 추가 딜리미터를 삭제할 수도 있습니다.그러면 처음에 "목록이 비어 있으면 이 문자열을 반환"하면 빈 목록에서 문자를 제거할 수 없으므로 마지막에 체크하지 않아도 됩니다.

그래서 정말 궁금한 건

"루프와 if를 고려할 때, 이것들을 조합하는 가장 명확한 방법은 무엇이라고 생각하십니까?"

public static String join (List<String> list, String separator) {
  String listToString = "";

  if (list == null || list.isEmpty()) {
   return listToString;
  }

  for (String element : list) {
   listToString += element + separator;
  }

  listToString = listToString.substring(0, separator.length());

  return listToString;
}

if (array.length>0)          // edited in response Joachim's comment
  sb.append(array[i]);
for (int i=1; i<array.length; i++)
  sb.append(",").append(array[i]);

목록을 쉼표로 구분하는 가장 명확한 방법(Java)을 기반으로 합니다.

이 아이디어를 사용하여:루프의 마지막 요소는 별도로 취급할 필요가 있습니까?

public String toString(List<Item> items)
{
    StringBuilder sb = new StringBuilder("[");

    for (Item item : items)
    {
        sb.append(item).append(", ");
    }

    if (sb.length() >= 2)
    {
        //looks cleaner in C# sb.Length -= 2;
        sb.setLength(sb.length() - 2);
    }

    sb.append("]");

    return sb.toString();
}

지금까지 어떤 답도 재귀를 사용하지 않았습니다...

public class Main {

    public static String toString(List<String> list, char d) {
        int n = list.size();
        if(n==0) return "";
        return n > 1 ? Main.toString(list.subList(0, n - 1), d) + d
                  + list.get(n - 1) : list.get(0);
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList(new String[]{"1","2","3"});
        System.out.println(Main.toString(list, ','));
    }

}

private String betweenComma(ArrayList<String> strings) {
    String united = "";
    for (String string : strings) {
        united = united + "," + string;
    }
    return united.replaceFirst(",", "");
}

방법

String join(List<Object> collection, String delimiter){
    StringBuilder stringBuilder = new StringBuilder();
    int size = collection.size();
    for (Object value : collection) {
        size --;
        if(size > 0){
            stringBuilder.append(value).append(delimiter);
        }
    }

    return stringBuilder.toString();
}

사용.

[1, 2, 3] 배열이 지정되면

join(myArray, ",") // 1,2,3

언급URL : https://stackoverflow.com/questions/668952/the-simplest-way-to-comma-delimit-a-list