Java 배열을 인쇄하는 가장 간단한 방법은 무엇입니까?

Java에서는 배열이 재정의되지 않으므로 toString()직접 인쇄하려고하면 다음 과 같이 정의 된대로 배열 className의 16 진수 + '@'+ 를 얻습니다 .hashCodeObject.toString()

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(intArray);     // prints something like '[I@3343c8b3'

그러나 일반적으로 우리는 실제로보다 유사한 것을 원할 것 [1, 2, 3, 4, 5]입니다. 가장 간단한 방법은 무엇입니까? 다음은 입력 및 출력의 예입니다.

// Array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};
//output: [1, 2, 3, 4, 5]

// Array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};
//output: [John, Mary, Bob]

Java 5부터 Arrays.toString(arr)또는 Arrays.deepToString(arr)배열 내의 배열을 사용할 수 있습니다 . 참고 것을 Object[]버전 호출 .toString()배열의 각 객체. 원하는 방식으로 결과물이 꾸며져 있습니다.

예 :

• 간단한 배열 :

  String[] array = new String[] {"John", "Mary", "Bob"};
  System.out.println(Arrays.toString(array));

  산출:

  [John, Mary, Bob]

• 중첩 배열 :

  String[][] deepArray = new String[][] {{"John", "Mary"}, {"Alice", "Bob"}};
  System.out.println(Arrays.toString(deepArray));
  //output: [[Ljava.lang.String;@106d69c, [Ljava.lang.String;@52e922]
  System.out.println(Arrays.deepToString(deepArray));

  산출:

  [[John, Mary], [Alice, Bob]]

• double 정렬:

  double[] doubleArray = { 7.0, 9.0, 5.0, 1.0, 3.0 };
  System.out.println(Arrays.toString(doubleArray));

  산출:

  [7.0, 9.0, 5.0, 1.0, 3.0 ]

• int 정렬:

  int[] intArray = { 7, 9, 5, 1, 3 };
  System.out.println(Arrays.toString(intArray));

  산출:

  [7, 9, 5, 1, 3 ]

항상 표준 라이브러리를 먼저 확인하십시오.

import java.util.Arrays;

그런 다음 시도하십시오.

System.out.println(Arrays.toString(array));

또는 배열에 다른 배열이 요소로 포함 된 경우 :

System.out.println(Arrays.deepToString(array));

그러나 "항상 표준 라이브러리를 먼저 확인하십시오"에 대해서는 알아두면 좋을 것입니다. Arrays.toString( myarray )

-이 작업을 수행하는 방법을보기 위해 myarray 유형에 집중하고 있기 때문에. 이 일을 반복하고 싶지는 않았습니다 .Eclipse 디버거에서 볼 수있는 것과 비슷하게하기 위해 쉬운 호출을 원했고 myarray.toString () 은하 지 않았습니다.

import java.util.Arrays;
.
.
.
System.out.println( Arrays.toString( myarray ) );

JDK1.8에서는 집계 연산과 람다 식을 사용할 수 있습니다.

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

// #3
Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob
*/

Java 8부터는 괄호없이 배열 요소를 인쇄하기 join()위해 String 클래스 가 제공 하는 메소드를 활용할 수 있으며 선택 구분 기호 (아래에 표시된 예의 공백 문자)로 구분됩니다.

String[] greeting = {"Hey", "there", "amigo!"};
String delimiter = " ";
String.join(delimiter, greeting) 

결과는 "Hey there amigo!"입니다.

Java 1.4를 사용하는 경우 대신 다음을 수행 할 수 있습니다.

System.out.println(Arrays.asList(array));

(물론 1.5 이상에서도 작동합니다.)

Arrays.toString

직접 답변으로 @Esko를 포함 하여 Arrays.toStringand Arrays.deepToString메소드를 사용하여 여러 가지가 제공하는 솔루션 이 가장 좋습니다.

Java 8-Stream.collect (joining ()), Stream.forEach

아래에는 제안 된 다른 방법 중 일부를 나열하려고합니다. 가장 주목할만한 추가 기능은 Stream.collect연산자를 사용 하고을 사용하여 수행중인 작업 을 모방하는 것 입니다.joining CollectorString.join

int[] ints = new int[] {1, 2, 3, 4, 5};
System.out.println(IntStream.of(ints).mapToObj(Integer::toString).collect(Collectors.joining(", ")));
System.out.println(IntStream.of(ints).boxed().map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(ints));

String[] strs = new String[] {"John", "Mary", "Bob"};
System.out.println(Stream.of(strs).collect(Collectors.joining(", ")));
System.out.println(String.join(", ", strs));
System.out.println(Arrays.toString(strs));

DayOfWeek [] days = { FRIDAY, MONDAY, TUESDAY };
System.out.println(Stream.of(days).map(Object::toString).collect(Collectors.joining(", ")));
System.out.println(Arrays.toString(days));

// These options are not the same as each item is printed on a new line:
IntStream.of(ints).forEach(System.out::println);
Stream.of(strs).forEach(System.out::println);
Stream.of(days).forEach(System.out::println);

Java 8 이전

Arrays.toString(array)1 차원 배열과 다차원 배열을 인쇄 하는 데 사용할 수있었습니다 Arrays.deepToString(array).

자바 8

이제 우리는 옵션을 가지고 있습니다 Stream및 lambda배열을 인쇄 할 수 있습니다.

1 차원 배열 인쇄 :

public static void main(String[] args) {
    int[] intArray = new int[] {1, 2, 3, 4, 5};
    String[] strArray = new String[] {"John", "Mary", "Bob"};

    //Prior to Java 8
    System.out.println(Arrays.toString(intArray));
    System.out.println(Arrays.toString(strArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(intArray).forEach(System.out::println);
    Arrays.stream(strArray).forEach(System.out::println);
}

출력은 다음과 같습니다.

[1, 2, 3, 4, 5]
[John, Mary, Bob]
1
2
3
4
5
John
Mary
Bob

다차원 배열 인쇄 다차원 배열 을 인쇄하려는 경우 다음 Arrays.deepToString(array)과 같이 사용할 수 있습니다 .

public static void main(String[] args) {
    int[][] int2DArray = new int[][] { {11, 12}, { 21, 22}, {31, 32, 33} };
    String[][] str2DArray = new String[][]{ {"John", "Bravo"} , {"Mary", "Lee"}, {"Bob", "Johnson"} };

    //Prior to Java 8
    System.out.println(Arrays.deepToString(int2DArray));
    System.out.println(Arrays.deepToString(str2DArray));

    // In Java 8 we have lambda expressions
    Arrays.stream(int2DArray).flatMapToInt(x -> Arrays.stream(x)).forEach(System.out::println);
    Arrays.stream(str2DArray).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);
} 

이제 관찰 할 점은 그 방법 Arrays.stream(T[])의 경우, int[]반환 우리 Stream<int[]>다음 방법은 flatMapToInt()각 요소에 제공 매핑 기능을 적용하여 생산 매핑 된 스트림의 내용 스트림의 각 요소를 매핑합니다.

출력은 다음과 같습니다.

[[11, 12], [21, 22], [31, 32, 33]]
[[John, Bravo], [Mary, Lee], [Bob, Johnson]]
11
12
21
22
31
32
33
John
Bravo
Mary
이
밥
존슨

Arrays.deepToString(arr) 한 줄에 인쇄합니다.

int[][] table = new int[2][2];

실제로 테이블을 2 차원 테이블로 인쇄하려면이 작업을 수행해야했습니다.

System.out.println(Arrays.deepToString(table).replaceAll("],", "]," + System.getProperty("line.separator")));

Arrays.deepToString(arr)메서드가 구분 기호 문자열을 가져야하는 것처럼 보이지만 불행히도 그렇지 않습니다.

for(int n: someArray) {
    System.out.println(n+" ");
}

Java로 배열을 인쇄하는 다른 방법 :

1. 간단한 방법

   List<String> list = new ArrayList<String>();
   list.add("One");
   list.add("Two");
   list.add("Three");
   list.add("Four");
   // Print the list in console
   System.out.println(list);

출력 : [하나, 둘, 셋, 넷]

2. 사용 toString()

   String[] array = new String[] { "One", "Two", "Three", "Four" };
   System.out.println(Arrays.toString(array));

출력 : [하나, 둘, 셋, 넷]

3. 배열 배열 인쇄

   String[] arr1 = new String[] { "Fifth", "Sixth" };
   String[] arr2 = new String[] { "Seventh", "Eight" };
   String[][] arrayOfArray = new String[][] { arr1, arr2 };
   System.out.println(arrayOfArray);
   System.out.println(Arrays.toString(arrayOfArray));
   System.out.println(Arrays.deepToString(arrayOfArray));

출력 : [[Ljava.lang.String; @ 1ad086a [[Ljava.lang.String; @ 10385c1, [Ljava.lang.String; @ 42719c] [[Fifth, Sixth], [Seventh, 8]]]

리소스 : 배열에 액세스

정기적 인 for 루프를 사용하는 것이 배열을 인쇄하는 가장 간단한 방법입니다. 여기에 intArray를 기반으로 한 샘플 코드가 있습니다.

for (int i = 0; i < intArray.length; i++) {
   System.out.print(intArray[i] + ", ");
}

1, 2, 3, 4, 5로 출력합니다.

최근 에 Vanilla #Java 에서이 게시물을 보았습니다 . 쓰기가 그리 편리하지 않고 항상 Arrays.toString(arr);가져 java.util.Arrays;옵니다.

이 방법은 영구적 인 수정이 아닙니다. 디버깅을 더 간단하게 만들 수있는 해킹 일뿐입니다.

배열을 직접 인쇄하면 내부 표현과 해시 코드가 제공됩니다. 이제 모든 클래스는 Object부모 유형입니다. 그렇다면 왜 해킹하지 Object.toString()않습니까? 수정하지 않으면 Object 클래스는 다음과 같습니다.

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

이것이 다음으로 변경되면 어떻게됩니까?

public String toString() {
    if (this instanceof boolean[])
        return Arrays.toString((boolean[]) this);
    if (this instanceof byte[])
        return Arrays.toString((byte[]) this);
    if (this instanceof short[])
        return Arrays.toString((short[]) this);
    if (this instanceof char[])
        return Arrays.toString((char[]) this);
    if (this instanceof int[])
        return Arrays.toString((int[]) this);
    if (this instanceof long[])
        return Arrays.toString((long[]) this);
    if (this instanceof float[])
        return Arrays.toString((float[]) this);
    if (this instanceof double[])
        return Arrays.toString((double[]) this);
    if (this instanceof Object[])
        return Arrays.deepToString((Object[]) this);
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

이 수정 된 클래스는 명령 행에 다음을 추가하여 클래스 경로에 추가 할 수 -Xbootclasspath/p:target/classes있습니다.

이제 deepToString(..)Java 5부터는 다른 배열을 포함하는 배열을 지원 toString(..)하도록 쉽게 변경할 수 있습니다 deepToString(..).

나는 이것이 매우 유용한 해킹임을 발견했으며 Java가 단순히 이것을 추가 할 수 있다면 좋을 것입니다. 문자열 표현이 문제가 될 수 있으므로 매우 큰 배열을 갖는 잠재적 문제를 이해합니다. 그러한 사건에 대해 a System.out또는 a 와 같은 것을 전달할 수도 PrintWriter있습니다.

어떤 JDK 버전을 사용하든 항상 작동해야합니다.

System.out.println(Arrays.asList(array));

Array포함 된 객체가 있으면 작동합니다 . Array기본 유형 이 포함 된 경우, 기본 유형을 직접 저장하는 대신 랩퍼 클래스를 사용할 수 있습니다.

예:

int[] a = new int[]{1,2,3,4,5};

다음으로 교체하십시오.

Integer[] a = new Integer[]{1,2,3,4,5};

업데이트 :

예 ! 이것은 배열을 객체 배열로 변환하거나 객체 배열을 사용하기 위해 비용이 많이 들고 실행 속도가 느려질 수 있습니다. 그것은 autoboxing이라는 자바의 특성에 의해 발생합니다.

따라서 인쇄 목적으로 만 사용해서는 안됩니다. 배열을 매개 변수로 사용하고 원하는 형식을 다음과 같이 인쇄하는 함수를 만들 수 있습니다.

public void printArray(int [] a){
        //write printing code
} 

Java 8에서는 쉽습니다. 두 개의 키워드가 있습니다

1. 흐름: Arrays.stream(intArray).forEach

2. 방법 참조 : ::println

   int[] intArray = new int[] {1, 2, 3, 4, 5};
   Arrays.stream(intArray).forEach(System.out::println);

배열의 모든 요소를 ​​같은 줄에 인쇄하려면 print대신 printlnie를 사용하십시오.

int[] intArray = new int[] {1, 2, 3, 4, 5};
Arrays.stream(intArray).forEach(System.out::print);

메소드 참조가없는 다른 방법은 다음을 사용하십시오.

int[] intArray = new int[] {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(intArray));

배열이 char [] 유형 인 경우 한 가지 추가 방법이 있습니다.

char A[] = {'a', 'b', 'c'}; 

System.out.println(A); // no other arguments

인쇄물

abc

모든 답변에 추가하려면 객체를 JSON 문자열로 인쇄하는 것도 옵션입니다.

Jackson 사용하기 :

ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
System.out.println(ow.writeValueAsString(anyArray));

Gson 사용하기 :

Gson gson = new Gson();
System.out.println(gson.toJson(anyArray));

반복하면서 배열을 반복하여 각 항목을 인쇄 할 수 있습니다. 예를 들면 다음과 같습니다.

String[] items = {"item 1", "item 2", "item 3"};

for(int i = 0; i < items.length; i++) {

    System.out.println(items[i]);

}

산출:

item 1
item 2
item 3

배열을 인쇄하는 방법은 다음과 같습니다.

 // 1) toString()  
    int[] arrayInt = new int[] {10, 20, 30, 40, 50};  
    System.out.println(Arrays.toString(arrayInt));

// 2 for loop()
    for (int number : arrayInt) {
        System.out.println(number);
    }

// 3 for each()
    for(int x: arrayInt){
         System.out.println(x);
     }

내가 시도한 간단한 단축키는 다음과 같습니다.

    int x[] = {1,2,3};
    String printableText = Arrays.toString(x).replaceAll("[\\[\\]]", "").replaceAll(", ", "\n");
    System.out.println(printableText);

인쇄합니다

1
2
3

이 방법에는 루프가 필요하지 않으며 작은 배열에만 적합합니다.

For-each 루프를 사용하여 배열의 요소를 인쇄 할 수도 있습니다.

int array[] = {1, 2, 3, 4, 5};
for (int i:array)
    System.out.println(i);

public class printer {

    public static void main(String[] args) {
        String a[] = new String[4];
        Scanner sc = new Scanner(System.in);
        System.out.println("enter the data");
        for (int i = 0; i < 4; i++) {
            a[i] = sc.nextLine();
        }
        System.out.println("the entered data is");
        for (String i : a) {
            System.out.println(i);
        }
      }
    }

org.apache.commons.lang3.StringUtils.join (*) 메소드 사용은 옵션이 될 수 있습니다.
예를 들면 다음과 같습니다.

String[] strArray = new String[] { "John", "Mary", "Bob" };
String arrayAsCSV = StringUtils.join(strArray, " , ");
System.out.printf("[%s]", arrayAsCSV);
//output: [John , Mary , Bob]

나는 다음과 같은 의존성을 사용했다

<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>

이것은 byte [] 인쇄 를 위해 중복으로 표시됩니다 . 참고 : 바이트 배열의 경우 적절한 추가 방법이 있습니다.

ISO-8859-1 문자가 포함되어 있으면 문자열로 인쇄 할 수 있습니다.

String s = new String(bytes, StandardChars.ISO_8559);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.ISO_8559);

또는 UTF-8 문자열을 포함하는 경우

String s = new String(bytes, StandardChars.UTF_8);
System.out.println(s);
// to reverse
byte[] bytes2 = s.getBytes(StandardChars.UTF_8);

또는 16 진수로 인쇄하려는 경우.

String s = DatatypeConverter.printHexBinary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseHexBinary(s);

또는 base64로 인쇄하려는 경우.

String s = DatatypeConverter.printBase64Binary(bytes);
System.out.println(s);
// to reverse
byte[] bytes2 = DatatypeConverter.parseBase64Binary(s);

또는 부호있는 바이트 값의 배열을 인쇄하려는 경우

String s = Arrays.toString(bytes);
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = Byte.parseByte(split[i]);

또는 부호없는 바이트 값의 배열을 인쇄하려는 경우

String s = Arrays.toString(
               IntStream.range(0, bytes.length).map(i -> bytes[i] & 0xFF).toArray());
System.out.println(s);
// to reverse
String[] split = s.substring(1, s.length() - 1).split(", ");
byte[] bytes2 = new byte[split.length];
for (int i = 0; i < bytes2.length; i++)
    bytes2[i] = (byte) Integer.parseInt(split[i]); // might need a range check.

// array of primitives:
int[] intArray = new int[] {1, 2, 3, 4, 5};

System.out.println(Arrays.toString(intArray));

output: [1, 2, 3, 4, 5]

// array of object references:
String[] strArray = new String[] {"John", "Mary", "Bob"};

System.out.println(Arrays.toString(strArray));

output: [John, Mary, Bob]

jdk 8을 실행중인 경우

public static void print(int[] array) {
    StringJoiner joiner = new StringJoiner(",", "[", "]");
    Arrays.stream(array).forEach(element -> joiner.add(element + ""));
    System.out.println(joiner.toString());
}


int[] array = new int[]{7, 3, 5, 1, 3};
print(array);

산출:

[7,3,5,1,3]

자바 8에서 :

Arrays.stream(myArray).forEach(System.out::println);

Commons.Lang 라이브러리를 사용하는 경우 다음을 수행 할 수 있습니다.

ArrayUtils.toString(array)

int[] intArray = new int[] {1, 2, 3, 4, 5};
String[] strArray = new String[] {"John", "Mary", "Bob"};
ArrayUtils.toString(intArray);
ArrayUtils.toString(strArray);

산출:

{1,2,3,4,5}
{John,Mary,Bob}

// 콘솔에서 배열 요소의 주소를 java로 인쇄하는 경우.

      int myArrayElement[] = {1,2,3,4,5,6,7,8,9,10};
       Log.i("MyTag",myIntegerNumbers + "");

배열 요소를 인쇄하는 방법에는 여러 가지가 있습니다. 먼저 배열이란 무엇입니까?. 어레이는 데이터를 저장하는 간단한 데이터 구조입니다. 어레이를 정의 할 때 보조 메모리 블록 세트를 할당하십시오 메모리 블록은 하나의 단위로 사용됩니다.

좋아, 나는 이런 배열을 만들 것이다.

class demo{
      public static void main(String a[]){

           int[] number={1,2,3,4,5};

           System.out.print(number);
      }
}

이제 출력을보십시오.

알 수없는 문자열이 인쇄 된 것을 볼 수 있습니다. 앞에서 언급했듯이 array (number array)가 선언 된 메모리 주소가 인쇄됩니다. 배열에 요소를 표시하려면 "for loop"를 사용할 수 있습니다.

class demo{
      public static void main(String a[]){

           int[] number={1,2,3,4,5};

           int i;

           for(i=0;i<number.length;i++){
                 System.out.print(number[i]+"  ");
           }
      }
}

이제 출력을보십시오.

Ok, 성공적으로 1 차원 배열의 요소를 인쇄했습니다. 이제 2 차원 배열을 고려하겠습니다. 2 차원 배열을 "number2"로 선언하고 "Arrays.deepToString ()"키워드를 사용하여 요소를 인쇄합니다. 'java.util.Arrays'라이브러리를 가져와야합니다.

 import java.util.Arrays;

 class demo{
      public static void main(String a[]){

           int[][] number2={{1,2},{3,4},{5,6}};`

           System.out.print(Arrays.deepToString(number2));
      }
}

출력을 고려하고

동시에 두 개의 for 루프를 사용하면 2D 요소를 인쇄 할 수 있습니다. 감사합니다!