Array List를 문자열로 변환하는 가장 좋은 방법

Array List를 문자열로 변환하는 가장 좋은 방법

이 질문의 답변은 지역사회의 노력입니다.기존 답변을 편집하여 이 게시물을 개선하십시오.현재 새로운 답변이나 상호작용을 받아들이지 않고 있습니다.

는 i i나 an an an i i i i i i i 。ArrayList스트링으로 완전히 출력합니다..toString탭으로 구분되어 있습니다.리리 할할 ?법 ??? ???루프를 통해 각 요소를 제거하고 String에 연결할 수 있지만 매우 느릴 것입니다.

Java 8 이후:

String listString = String.join(", ", list);

「 」의 listString 할 수 .접속 컬렉터를 사용할 수 있습니다.

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

Android에서 이 작업을 하게 된다면 TextUtils라는 멋진 유틸리티가 있습니다..join(String delimiter, Iterable)★★★★★★ 。

List<String> list = new ArrayList<String>();
list.add("Item 1");
list.add("Item 2");
String joined = TextUtils.join(", ", list);

Android 이외에는 그다지 쓸모가 없지만, 이 스레드에 추가하고 싶다고 생각했습니다.

은 Java 8™을 했습니다.String.join(separator, list)Vitalii Federenko의 답변을 참조하십시오.

8보다 버전에서는 Java 8에서 합니다.ArrayList유일한 옵션이었습니다.

이 코드를 사용하지 마십시오. 이 답변의 맨 아래까지 읽고 이 코드가 바람직하지 않은 이유와 대신 사용해야 하는 코드를 확인하십시오.

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

String listString = "";

for (String s : list)
{
    listString += s + "\t";
}

System.out.println(listString);

, 스트링 연결은 스트링 연결도 .javac로 최적화합니다.appendStringBuilder이 이 바이트 를 분해할 때 할 수 있습니다.for이치노

   61:  new #13; //class java/lang/StringBuilder
   64:  dup
   65:  invokespecial   #14; //Method java/lang/StringBuilder."<init>":()V
   68:  aload_2
   69:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  aload   4
   74:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   77:  ldc #16; //String \t
   79:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   82:  invokevirtual   #17; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;

와 같이 컴파일러는 이 합니다.StringBuilder퍼포먼스는 큰 문제가 되지 않습니다.

언뜻 , (OK, 핏면면)StringBuilder는 루프의 반복마다 인스턴스화되기 때문에 가장 효율적인 바이트코드가 아닐 수 있습니다.인 ""의 및 StringBuilder아마 퍼포먼스가 향상될 것입니다.)

사실, 어떤 종류의 출력(디스크든 화면이든)이라도 문자열 연결의 성능에 대해 걱정할 필요가 있는 것보다 훨씬 느리다고 생각합니다.

편집: 코멘트에서 지적한 바와 같이 위의 컴파일러 최적화에 의해 실제로 새로운 인스턴스가 생성되고 있습니다.StringBuilder을 사용법

사용하기에 가장 최적화된 기법은 Paul Tomblin의 응답일 것입니다. 왜냐하면 그것은 하나의 예만을 인스턴스화 하기 때문입니다.StringBuilder forloopsyslog.syslog..syslog.

위의 코드로 다시 쓰는 방법:

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder();
for (String s : list)
{
    sb.append(s);
    sb.append("\t");
}

System.out.println(sb.toString());

의 인스턴스화만 합니다.StringBuilder합니다.append 코드에서는 「」의 있습니다).StringBuilder★★★★★★★★★★★★★★★★★★=

   // Instantiation of the StringBuilder outside loop:
   33:  new #8; //class java/lang/StringBuilder
   36:  dup
   37:  invokespecial   #9; //Method java/lang/StringBuilder."<init>":()V
   40:  astore_2

   // [snip a few lines for initializing the loop]
   // Loading the StringBuilder inside the loop, then append:
   66:  aload_2
   67:  aload   4
   69:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  pop
   73:  aload_2
   74:  ldc #15; //String \t
   76:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   79:  pop

손 는 실제로 더. 즉, 손 최적화는 손 의 내부와 같이 더 잘 수행되어야 합니다.for에, 「일단」을 .StringBuilder각 반복마다.

Apache Commons Lang을 다운로드하여 다음 방법을 사용합니다.

 StringUtils.join(list)

 StringUtils.join(list, ", ") // 2nd param is the separator.

물론 직접 구현할 수도 있지만, 코드는 충분히 테스트되었으며 아마도 가장 적합한 구현일 것입니다.

저는 Apache Commons 라이브러리의 열렬한 팬이며 Java Standard Library의 훌륭한 추가라고 생각합니다.

이것은 꽤 오래된 질문이지만, 보다 현대적인 답변을 덧붙이는 것이 좋을 것 같습니다.Guava의 수업을 사용합니다.

String joined = Joiner.on("\t").join(list);

목록을 읽기 쉽고 의미 있는 문자열로 변경하는 것은 누구나 직면할 수 있는 일반적인 질문입니다.

사례 1. 클래스 경로에 아파치의 StringUtils가 있는 경우(Rogerdpack 및 Ravi Wallau에서 사용):

import org.apache.commons.lang3.StringUtils;
String str = StringUtils.join(myList);

케이스 2. JDK(7)의 방법만 사용하는 경우:

import java.util.Arrays;
String str = Arrays.toString(myList.toArray()); 

혼자서 바퀴를 만들지 말고, 이 한 줄짜리 작업에는 루프를 사용하지 마세요.

빠른 원라이너를 찾고 있다면 Java 5에서 다음을 수행할 수 있습니다.

myList.toString().replaceAll("\\[|\\]", "").replaceAll(", ","\t")

또, 컨텐츠의 인쇄만을 목적으로 하고 있어 「\t」에 대한 염려가 적은 경우는, 다음과 같이 간단하게 실시할 수 있습니다.

myList.toString()

다음과 같은 문자열을 반환합니다.

[str1, str2, str3]

어레이(ArrayList가 아님)가 있는 경우 다음과 같이 할 수 있습니다.

 Arrays.toString(myList).replaceAll("\\[|\\]", "").replaceAll(", ","\t")

루프를 통해 String을 호출합니다.마법의 방법은 없습니다. 만약 있다면, 이불 속에서 루프하는 것 말고는 무엇을 하고 있을까요?유일한 마이크로 최적화 방법은 String 대신 String Builder를 사용하는 것입니다.그것마저도 큰 성과는 아닙니다.문자열은 커버 아래 String Builder로 바뀝니다만, 적어도 그렇게 쓰면 무슨 일이 일어나고 있는지 알 수 있습니다.

StringBuilder out = new StringBuilder();
for (Object o : list)
{
  out.append(o.toString());
  out.append("\t");
}
return out.toString();

대부분의 Java 프로젝트에서는 apache-commons lang을 사용할 수 있습니다.String Utils.join() 메서드는 매우 훌륭하고 거의 모든 요구를 충족하는 여러 가지 맛이 있습니다.

public static java.lang.String join(java.util.Collection collection,
                                    char separator)


public static String join(Iterator iterator, String separator) {
    // handle null, zero and one elements before building a buffer 
    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();
}

파라미터:

collection - 결합할 값의 컬렉션은 null일 수 있습니다.

separator - 사용할 구분 문자

반환: 조인된 문자열, null 반복기 입력의 경우 null

이후: 2.3

Android에는 TextUtil 클래스가 있으며 http://developer.android.com/reference/android/text/TextUtils.html을 사용할 수 있습니다.

String implode = TextUtils.join("\t", list);

이 간단한 사용 예에서는 문자열을 쉼표로 간단히 결합할 수 있습니다.Java 8을 사용하는 경우:

String csv = String.join("\t", yourArray);

그렇지 않으면 commons-display에는 join() 메서드가 있습니다.

String csv = org.apache.commons.lang3.StringUtils.join(yourArray, "\t");

후행 구분 문자를 처리하는 우아한 방법은 클래스 구분 기호를 사용하는 것입니다.

StringBuilder buf = new StringBuilder();
Separator sep = new Separator("\t");
for (String each: list) buf.append(sep).append(each);
String s = buf.toString();

클래스 세퍼레이터의 toString 메서드는 첫 번째 콜을 제외하고 구분자를 반환합니다.따라서 후행(또는 이 경우) 선행 구분 기호 없이 목록을 인쇄합니다.

Java 8에서는 간단합니다.정수 리스트에 대해서는, 다음의 예를 참조해 주세요.

String result = Arrays.asList(1,2,3).stream().map(Object::toString).reduce((t, u) -> t + "\t" + u).orElse("");

또는 여러 줄 버전(읽기 쉬운 버전):

String result = Arrays.asList(1,2,3).stream()
    .map(Object::toString)
    .reduce((t, u) -> t + "\t" + u)
    .orElse("");

업데이트 - 더 짧은 버전

String result = Arrays.asList(1,2,3).stream()
                .map(Object::toString)
                .collect(Collectors.joining("\t"));

이건...O(n)(여러 서브리스트로 목록을 분할한 멀티스레드 솔루션을 실행한 경우를 제외하고) 어느 쪽이든 상관없습니다.

그냥 사용하다StringBuilder다음과 같습니다.

StringBuilder sb = new StringBuilder();

for (Object obj : list) {
  sb.append(obj.toString());
  sb.append("\t");
}

String finalString = sb.toString();

그StringBuilder. 스트링 연결은되지 않기 때문입니다.왜냐하면 재검증을 하지 않기 때문입니다.String각 연결의 객체.

Android에서 Jack을 아직 사용하지 않고 있는 경우(예를 들어 Instant Run을 아직 지원하지 않기 때문에), 결과 문자열의 포맷을 더 제어하고 싶은 경우(예를 들어 요소의 구분자로 newline 문자를 사용하고 싶은 경우), 스트림 지원 라이브러리(스트림 사용)를 사용하고 싶은 경우n Java 7 이전 버전의 컴파일러), 다음과 같은 것을 사용할 수 있습니다(이 메서드는 ListUtils 클래스에 넣습니다).

public static <T> String asString(List<T> list) {
    return StreamSupport.stream(list)
            .map(Object::toString)
            .collect(Collectors.joining("\n"));
}

또한 목록 객체의 클래스에 toString()을 구현해야 합니다.

한 줄 : [12,0,1,78,12]에서12 0 1 78 12

String srt= list.toString().replaceAll("\\[|\\]|,","");

마지막 요소 뒤에 마지막 \t를 사용하지 않으려면 인덱스를 사용하여 확인해야 합니다. 단, 목록에 Random Access가 구현되어 있을 때는 이 인덱스가 "작동"(즉, O(n))뿐입니다.

List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder(list.size() * apprAvg); // every apprAvg > 1 is better than none
for (int i = 0; i < list.size(); i++) {
    sb.append(list.get(i));
    if (i < list.size() - 1) {
        sb.append("\t");
    }
}
System.out.println(sb.toString());

아래 코드가 도움이 될 수 있습니다.

List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
String str = list.toString();
System.out.println("Step-1 : " + str);
str = str.replaceAll("[\\[\\]]", "");
System.out.println("Step-2 : " + str);

출력:

Step-1 : [1, 2, 3]
Step-2 : 1, 2, 3

가장 좋은 방법은 아니지만 우아한 방법이겠죠

Arrays.deepToString(Arrays.asList("테스트", "테스트2"))

import java.util.Arrays;

    public class Test {
        public static void main(String[] args) {
            System.out.println(Arrays.deepToString(Arrays.asList("Test", "Test2").toArray()));
        }
    }

산출량

[테스트, 테스트2]

다음과 같은 것이 좋습니까?

List<String> streamValues = new ArrayList<>();
Arrays.deepToString(streamValues.toArray()));   

Eclipse 컬렉션을 사용하는 경우makeString()★★★★★★ 。

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

Assert.assertEquals(
    "one\ttwo\tthree",
    ArrayListAdapter.adapt(list).makeString("\t"));

「 」를 할 수 ArrayList a까지FastList떼면

Assert.assertEquals(
    "one\ttwo\tthree",
    FastList.newListWith("one", "two", "three").makeString("\t"));

주의: 저는 Eclipse Collections의 커밋입니다.

List<String> stringList = getMyListOfStrings();
StringJoiner sj = new StringJoiner(" ");
stringList.stream().forEach(e -> sj.add(e));
String spaceSeparated = sj.toString()

에 패스합니다.new StringJoiner구분자로 사용할 문자 시퀀스를 지정합니다. CSV 를 :new StringJoiner(", ");

println 대신 탭을 사용하여 분리할 경우 print를 사용할 수 있습니다.

ArrayList<String> mylist = new ArrayList<String>();

mylist.add("C Programming");
mylist.add("Java");
mylist.add("C++");
mylist.add("Perl");
mylist.add("Python");

for (String each : mylist)
{       
    System.out.print(each);
    System.out.print("\t");
}

추가 자원에 따라 달라지는 예는 꽤 있습니다만, 이것이 가장 간단한 해결책인 것 같습니다.이것은 기본적으로 ArrayList에서 Array로 변환하고 다음으로 List로 변환하는 것입니다.

    List<Account> accounts = new ArrayList<>();

   public String accountList() 
   {
      Account[] listingArray = accounts.toArray(new Account[accounts.size()]);
      String listingString = Arrays.toString(listingArray);
      return listingString;
   }

이것은 꽤 오래된 대화이며 Apache Commons는 현재 내부적으로 String Builder를 사용하고 있습니다.http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line.3045

이렇게 하면 퍼포먼스가 향상되지만 퍼포먼스가 중요한 경우에는 사용하는 방법이 다소 비효율적일 수 있습니다.인터페이스는 유연하고 여러 컬렉션 유형 간에 일관된 동작을 허용하지만 원래 질문의 컬렉션 유형인 목록에는 다소 비효율적입니다.

이것은 기존의 for 루프에서 단순히 요소를 반복함으로써 피할 수 있는 오버헤드가 발생하고 있다는 것을 근거로 하고 있습니다.대신 동시 수정, 메서드 호출 등을 확인하는 몇 가지 추가 작업이 백그라운드에서 수행됩니다.반면 확장 for 루프는 반복기가 반복 가능한 개체(목록)에서 사용되므로 동일한 오버헤드가 발생합니다.

여기에는 정규식을 사용할 수 있습니다.이것은 매우 간결하다.

System.out.println(yourArrayList.toString().replaceAll("\\[|\\]|[,][ ]","\t"));

이 기능은 어떻습니까?

public static String toString(final Collection<?> collection) {
    final StringBuilder sb = new StringBuilder("{");
    boolean isFirst = true;
    for (final Object object : collection) {
        if (!isFirst)
            sb.append(',');
        else
            isFirst = false;
        sb.append(object);
    }
    sb.append('}');
    return sb.toString();
}

모든 종류의 컬렉션에 사용할 수 있습니다.

언급URL : https://stackoverflow.com/questions/599161/best-way-to-convert-an-arraylist-to-a-string