Java Language
배열

소개

통사론

• ArrayType[] myArray; // 배열 선언
• ArrayType myArray[]; // 다른 유효한 구문 (덜 일반적으로 사용되거나 권장되지 않음)
• ArrayType[][][] myArray; // 다차원 지그재그 형 배열 선언 ([]을 반복)
• ArrayType myVar = myArray[index]; // 인덱스에서 요소에 액세스 (읽기)
• myArray[index] = value; // 배열의 위치 index 에 값을 할당한다.
• ArrayType[] myArray = new ArrayType[arrayLength]; // 배열 초기화 구문
• int[] ints = {1, 2, 3}; // 길이가 제공되는 값의 수에서 유추됩니다 : {[value1 [, value2] *]}
• new int[]{4, -5, 6} // Can be used as argument, without a local variable
• int[] ints = new int[3]; // same as {0, 0, 0}
• int[][] ints = {{1, 2}, {3}, null}; // 다차원 배열 초기화. int []는 Object를 확장하므로 anyType []도 마찬가지이므로 null이 유효한 값입니다.

매개 변수

배열 생성 및 초기화

기본 케이스

int[]   numbers1 = new int[3];                 // Array for 3 int values, default value is 0
int[]   numbers2 = { 1, 2, 3 };                // Array literal of 3 int values
int[]   numbers3 = new int[] { 1, 2, 3 };      // Array of 3 int values initialized
int[][] numbers4 = { { 1, 2 }, { 3, 4, 5 } };  // Jagged array literal
int[][] numbers5 = new int[5][];               // Jagged array, one dimension 5 long
int[][] numbers6 = new int[5][4];              // Multidimensional array: 5x4

배열은 기본 또는 참조 형식을 사용하여 만들 수 있습니다.

float[]  boats = new float[5];          // Array of five 32-bit floating point numbers.
double[] header = new double[] { 4.56, 332.267, 7.0, 0.3367, 10.0 };
                                       // Array of five 64-bit floating point numbers.
String[] theory = new String[] { "a", "b", "c" };
                                       // Array of three strings (reference type).
Object[] dArt = new Object[] { new Object(), "We love Stack Overflow.", new Integer(3) };
                                       // Array of three Objects (reference type).

마지막 예에서는 선언 된 배열 유형의 하위 유형이 배열에 허용됩니다.

사용자 정의 유형에 대한 배열은 기본 유형과 유사하게 만들 수 있습니다.

UserDefinedClass[] udType = new UserDefinedClass[5];

배열, 컬렉션 및 스트림

// Parameters require objects, not primitives

// Auto-boxing happening for int 127 here
Integer[]       initial        = { 127, Integer.valueOf( 42 ) };
List<Integer>   toList         = Arrays.asList( initial );  // Fixed size! 

// Note: Works with all collections
Integer[]       fromCollection = toList.toArray( new Integer[toList.size()] );

//Java doesn't allow you to create an array of a parameterized type
List<String>[]  list = new ArrayList<String>[2];  // Compilation error!

// Streams - JDK 8+
Stream<Integer> toStream       = Arrays.stream( initial );
Integer[]       fromStream     = toStream.toArray( Integer[]::new );

소개

배열 은 고정 된 수의 원시 값 또는 객체 인스턴스에 대한 참조를 보유하는 데이터 구조입니다.

배열의 각 항목은 요소라고하며 각 요소는 숫자 인덱스로 액세스됩니다. 배열이 만들어지면 배열의 길이가 설정됩니다.

int size = 42;
int[] array = new int[size];

배열의 크기는 초기화 될 때 런타임에 고정됩니다. 초기화 후에는 변경할 수 없습니다. 런타임에 크기를 변경할 수 있어야하는 경우 ArrayList 와 같은 Collection 클래스를 대신 사용해야합니다. ArrayList 는 배열에 요소를 저장 하고 새 배열을 할당 하고 이전 배열의 요소를 복사 하여 크기 조정을 지원합니다.

배열이 원시적 형의 경우, 즉

int[] array1 = { 1,2,3 };
int[] array2 = new int[10];

값은 배열 자체에 저장됩니다. 위의 array2 같이 이니셜 라이저가없는 경우 각 요소에 할당 된 기본값은 0 입니다.

배열 형이 객체 참조 인 경우, 다음과 같이됩니다.

SomeClassOrInterface[] array = new SomeClassOrInterface[10];

배열에는 SomeClassOrInterface 유형의 객체에 대한 참조 가 포함됩니다. 이러한 참조의 예를 참조 할 수 SomeClassOrInterface 또는 (클래스) 또는 서브 클래스 (인터페이스) 구현 클래스 SomeClassOrInterface . 배열 선언에 초기자를 포함하지 않으면 null 의 기본값이 각 요소에 할당됩니다.

모든 배열이기 때문에 int -indexed, 배열의 크기는로 지정해야합니다 int . 배열의 크기는 long 으로 지정할 수 없습니다.

long size = 23L;
int[] array = new int[size]; // Compile-time error:
                             // incompatible types: possible lossy conversion from
                             // long to int

배열은 인덱스가 0 에서 시작하여 length - 1 끝점을 의미하는 0 부터 시작하는 인덱스 시스템을 사용합니다.

예를 들어 다음 이미지는 크기가 10 인 배열을 나타냅니다. 여기서 첫 번째 요소는 인덱스 1 있고 마지막 요소는 인덱스 10 (아래 그림 참조). 첫 번째 요소는 인덱스 0 있고 마지막 요소는 인덱스 9 에 있습니다.

배열 요소에 대한 액세스는 일정한 시간 내에 수행됩니다. 즉, 배열의 첫 번째 요소에 액세스하는 것은 두 번째 요소, 세 번째 요소 등을 액세스하는 것과 동일한 비용 (시간상)을 갖는다는 것을 의미합니다.

Java는 리터럴 및 생성자 표기법을 비롯하여 배열을 정의하고 초기화하는 여러 가지 방법을 제공합니다. new Type[length] 생성자를 사용하여 배열을 선언 할 때 각 요소는 다음 기본값으로 초기화됩니다.

• 0 을위한 프리미티브 숫자 형식 : byte , short , int , long , float , 및 double .
• char 형의 경우 '\u0000' (null 문자).
• boolean 형의 경우는 false
• 참조 형의 경우는 null

원시 형 배열 만들기 및 초기화

int[] array1 = new int[] { 1, 2, 3 }; // Create an array with new operator and 
                                      // array initializer.
int[] array2 = { 1, 2, 3 };           // Shortcut syntax with array initializer.
int[] array3 = new int[3];            // Equivalent to { 0, 0, 0 }
int[] array4 = null;                  // The array itself is an object, so it
                                      // can be set as null.

배열을 선언 할 때 [] 는 선언의 시작 부분 (유형 이름 다음)이나 특정 변수 선언 자의 일부 (변수 이름 뒤에) 또는 둘 모두로 표시됩니다.

int array5[];       /* equivalent to */  int[] array5;
int a, b[], c[][];  /* equivalent to */  int a; int[] b; int[][] c;
int[] a, b[];       /* equivalent to */  int[] a; int[][] b;
int a, []b, c[][];  /* Compilation Error, because [] is not part of the type at beginning
                       of the declaration, rather it is before 'b'. */    
// The same rules apply when declaring a method that returns an array:
int foo()[] { ... } /* equivalent to */  int[] foo() { ... }

다음 예제에서 두 선언은 모두 정확하며 아무런 문제없이 컴파일하고 실행할 수 있습니다. 그러나 Java 코드 작성 규칙 과 Google Java 스타일 가이드 는 변수 이름 다음에 대괄호가 있는 양식을 금지합니다 . 대괄호는 배열 유형을 식별하며 유형 지정과 함께 표시되어야합니다 . 메소드 반환 시그니처에도이 값을 사용해야합니다.

float array[]; /* and */ int foo()[] { ... } /* are discouraged */
float[] array; /* and */ int[] foo() { ... } /* are encouraged */

낙심 타입은 변수 이름 다음에 괄호가있는 C의 구문에 익숙한 C 사용자 전환을 수용 하기위한 것입니다.

Java에서는 크기가 0 배열을 가질 수 있습니다.

int[] array = new int[0]; // Compiles and runs fine.
int[] array2 = {};        // Equivalent syntax.

그러나 빈 배열이므로 요소를 읽거나 할당 할 수 없습니다.

array[0] = 1;     // Throws java.lang.ArrayIndexOutOfBoundsException.
int i = array2[0]; // Also throws ArrayIndexOutOfBoundsException.

이러한 빈 배열은 일반적으로 반환 값으로 유용하므로 호출 코드는 NullPointerException 유발할 수있는 잠재적 null 값 대신 배열을 처리하는 것에 대해서만 염려해야합니다.

배열의 길이는 음수가 아닌 정수 여야합니다.

int[] array = new int[-1]; // Throws java.lang.NegativeArraySizeException

배열 크기는 length 라는 public 최종 필드를 사용하여 결정할 수 있습니다.

System.out.println(array.length); // Prints 0 in this case.

참고 : array.length 는 값이 할당 된 배열 요소의 수를 반환하는 ArrayList.size() 와는 달리 배열의 실제 크기를 반환하고 값이 할당 된 배열 요소 수는 반환하지 않습니다.

다차원 배열 만들기 및 초기화

다차원 배열을 만드는 가장 간단한 방법은 다음과 같습니다.

int[][] a = new int[2][3];

a[0] 과 a[1] 두 개의 3 길이 int 배열을 생성합니다. 이것은 직사각형 다차원 배열의 고전적인 C 스타일 초기화와 매우 유사합니다.

동시에 만들고 초기화 할 수 있습니다.

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

직사각형 다차원 배열 만 지원되는 C와 달리 내부 배열은 길이가 같거나 정의 될 필요가 없습니다.

int[][] a = { {1}, {2, 3}, null };

여기서 a[0] 은 1 길이의 int 배열이며 a[1] 은 2 길이의 int 배열이고 a[2] 는 null 입니다. 이와 같은 배열을 들쭉날쭉 한 배열 또는 불규칙한 배열 이라고 합니다 . 즉, 배열의 배열입니다. Java의 다차원 배열은 배열의 배열로 구현됩니다. 즉, array[i][j][k] 는 ((array[i])[j])[k] . C #과는 달리 구문 array[i,j] 는 Java에서 지원되지 않습니다.

Java의 다차원 배열 표현

출처 - Ideone에 게시

참조 유형 배열 만들기 및 초기화

String[] array6 = new String[] { "Laurel", "Hardy" }; // Create an array with new 
                                                      // operator and array initializer.
String[] array7 = { "Laurel", "Hardy" };              // Shortcut syntax with array 
                                                      // initializer.
String[] array8 = new String[3];                      // { null, null, null }
String[] array9 = null;                               // null

이데올로기에 살기

위에 표시된 String 리터럴 및 프리미티브 외에도 배열 초기화에 대한 단축키 구문은 표준 Object 유형에서도 작동합니다.

Object[] array10 = { new Object(), new Object() };

배열은 공변 (covariant)하기 때문에 요소를 String 아닌 다른 것으로 설정하려고하면 ArrayStoreException 이 throw되지만 참조 유형 배열을 하위 클래스의 배열로 초기화 할 수 있습니다.

Object[] array11 = new String[] { "foo", "bar", "baz" };
array11[1] = "qux"; // fine
array11[1] = new StringBuilder(); // throws ArrayStoreException

바로 가기 구문에 암시 적 Object[] 유형이 있으므로 바로 가기 구문을 사용할 수 없습니다.

배열은 String[] emptyArray = new String[0] 을 사용하여 0 요소로 초기화 할 수 있습니다. 예를 들어 길이가 0 인 Array 은 메서드에서 객체의 런타임 유형이 필요할 때 Collection 에서 Array 를 만드는 데 사용됩니다.

기본 유형과 참조 유형 모두에서 빈 배열 초기화 (예 : String[] array8 = new String[3] )는 각 데이터 유형 의 기본값으로 배열을 초기화합니다.

제네릭 형식 배열 만들기 및 초기화

제네릭 클래스에서는 제네릭 형식의 배열을 형식 지움 으로 인해 초기화 할 수 없습니다 .

public class MyGenericClass<T> {
    private T[] a;

    public MyGenericClass() {
        a = new T[5]; // Compile time error: generic array creation
    }
}

대신 다음 방법 중 하나를 사용하여 만들 수 있습니다 (이 옵션은 검사되지 않은 경고를 생성 함)

1. Object 배열을 만들고이를 generic 형식으로 캐스팅합니다.

   a = (T[]) new Object[5];
   

   이것은 가장 간단한 방법이지만 기본 배열이 여전히 Object[] 유형 Object[] 메서드는 형식 안전을 제공하지 않습니다. 따라서 배열을 만드는이 방법은 공개적으로 노출되지 않는 제네릭 클래스 내에서만 사용하는 것이 가장 좋습니다.

2. Array.newInstance 를 클래스 매개 변수와 함께 사용하여 :

   public MyGenericClass(Class<T> clazz) {
       a = (T[]) Array.newInstance(clazz, 5);
   }
   

   여기서 T 의 클래스는 생성자에 명시 적으로 전달되어야합니다. Array.newInstance 의 반환 유형은 항상 Object 입니다. 그러나 새로 생성 된 배열은 항상 T[] 유형이므로 안전하게 외부화 할 수 있으므로이 방법이 더 안전합니다.

초기화 후 배열 채우기

Arrays.fill(array8, "abc");        // { "abc", "abc", "abc" }

Arrays.fill(array8, 1, 2, "aaa");  // Placing "aaa" from index 1 to 2.

int[] array = new int[5];
Arrays.setAll(array, i -> i); // The array becomes { 0, 1, 2, 3, 4 }.

배열 선언과 초기화의 분리

배열 요소의 인덱스 값은 정수 (0, 1, 2, 3, 4, ...) 여야하며 배열의 길이보다 작아야합니다 (인덱스는 0부터 시작 함). 그렇지 않은 경우, ArrayIndexOutOfBoundsException 가 Throw됩니다.

int[] array9;             // Array declaration - uninitialized
array9 = new int[3];      // Initialize array  - { 0, 0, 0 }
array9[0] = 10;           // Set index 0 value - { 10, 0, 0 }
array9[1] = 20;           // Set index 1 value - { 10, 20, 0 }
array9[2] = 30;           // Set index 2 value - { 10, 20, 30 }

어레이 초기화 프로그램 바로 가기 구문을 사용하여 배열을 다시 초기화 할 수 없습니다.

배열 초기화자를 필드 선언이나 로컬 변수 선언에만 지정하거나 배열 작성 표현식의 일부로 지정할 수 있기 때문에 배열 초기화 자를 사용 하여 바로 가기 구문을 통해 배열을 다시 초기화 할 수 없습니다.

그러나 새 배열을 만들고 이전 배열을 참조하는 데 사용되는 변수에 할당 할 수 있습니다. 이로 인해 해당 변수가 참조하는 배열이 다시 초기화되는 동안 변수 내용은 완전히 새로운 배열입니다. 이렇게하려면 new 연산자를 배열 초기화 프로그램과 함께 사용할 수 있으며 배열 변수에 할당 할 수 있습니다.

// First initialization of array
int[] array = new int[] { 1, 2, 3 };

// Prints "1 2 3 ".
for (int i : array) {
    System.out.print(i + " ");
}

// Re-initializes array to a new int[] array.
array = new int[] { 4, 5, 6 };

// Prints "4 5 6 ".
for (int i : array) {
    System.out.print(i + " ");
}

array = { 1, 2, 3, 4 }; // Compile-time error! Can't re-initialize an array via shortcut 
                        // syntax with array initializer.

이데올로기에 살기

컬렉션에서 배열 만들기

java.util.Collection 두 메소드는 콜렉션에서 배열을 작성합니다.

• Object[] toArray()

• <T> T[] toArray(T[] a)

Object[] toArray() 는 다음과 같이 사용할 수 있습니다.

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// although set is a Set<String>, toArray() returns an Object[] not a String[]
Object[] objectArray = set.toArray();

<T> T[] toArray(T[] a) 는 다음과 같이 사용할 수 있습니다.

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// The array does not need to be created up front with the correct size.
// Only the array type matters. (If the size is wrong, a new array will
// be created with the same type.)
String[] stringArray = set.toArray(new String[0]);  

// If you supply an array of the same size as collection or bigger, it
// will be populated with collection values and returned (new array
// won't be allocated)
String[] stringArray2 = set.toArray(new String[set.size()]);

그들 사이의 차이점은 유형이 지정되지 않은 결과와 유형이없는 결과를 갖는 것 그 이상입니다. 그들의 성능은 다를 수 있습니다 (자세한 내용은이 성능 분석 섹션을 참조하십시오 ).

• Object[] toArray() 벡터화 사용 arraycopy , 타입 체크보다 훨씬 빠르며, arraycopy 에 사용 T[] toArray(T[] a) .
• T[] toArray(new T[non-zero-size]) 는 런타임에 배열을 제로 아웃해야하지만 T[] toArray(new T[0]) 는 T[] toArray(new T[0]) 되지 않습니다. 이러한 회피는 전자보다 후자의 호출을 빠르게한다. 여기에 상세한 분석 : 고대인의 지혜의 배열 .

String[] strings = list.stream().toArray(String[]::new);

스택 오버플 로시 Java 에서 ArrayList를 'String []' 로 변환 하는 두 가지 대답 ( 1 , 2 )에서 가져온 예제

문자열 배열

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

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
System.out.println(Arrays.deepToString(arr));  // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

public class Cat { /* implicitly extends Object */
    @Override
    public String toString() {
      return "CAT!";
    }
}

Cat[] arr = { new Cat(), new Cat() };
System.out.println(Arrays.toString(arr));        // [CAT!, CAT!]

public class Dog {
    /* implicitly extends Object */
}

Dog[] arr = { new Dog() };
System.out.println(Arrays.toString(arr));        // [Dog@17ed40e0]

배열에서 목록 만들기

Arrays.asList() 메서드는 주어진 배열의 요소를 포함하는 고정 크기의 List 를 반환하는 데 사용할 수 있습니다. 결과 List 는 배열의 기본 유형과 동일한 매개 변수 유형이됩니다.

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = Arrays.asList(stringArray);

주 :이리스트는 원래의 배열 ( 의 뷰 )에 의해 뒷받침됩니다. 즉,리스트를 변경하면 배열이 변경되고 그 반대의 경우도 마찬가지입니다. 그러나 크기를 변경하는 목록을 변경하면 배열 길이가 변경되므로 예외가 발생합니다.

리스트의 복사본을 생성하기 위해서 java.util.ArrayList 의 생성자를 사용하여 Collection 을 인수로 취한다.

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));

// Using Arrays.asList()

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));

// Using ArrayList.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(stringArray));

// Using Collections.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, stringArray);

// Using Streams

int[] ints = {1, 2, 3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

String[] stringArray = {"foo", "bar", "baz"};
List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());

Arrays.asList () 메서드 사용과 관련된 중요 사항

• 이 방법은 반환 List 의 인스턴스, Arrays$ArrayList (정적 내부 클래스 Arrays )과하지 java.util.ArrayList . 결과 List 은 고정 크기입니다. 즉, 요소를 추가 또는 삭제하는 것은 지원되지 않고 UnsupportedOperationException 을 throw합니다.

  stringList.add("something"); // throws java.lang.UnsupportedOperationException
  

• 새로운 List 는 array-backed List 를 새로운 List 의 생성자에 전달함으로써 생성 될 수 있습니다. 이렇게하면 크기가 변경 될 수 있고 원본 배열에 의해 백업되지 않는 데이터의 새 복사본이 만들어집니다.

  List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
  

• int[] 등의 프리미티브 (primitive) 배열의 <T> List<T> asList(T... a) 를 호출 <T> List<T> asList(T... a) , 실제의 요소가 아닌 원시적 배열의 요소만을 가지는 List<int[]> 가 작성 됩니다 소스 배열의

  이 동작의 이유는 제네릭 형식 매개 변수 대신 기본 형식을 사용할 수 없으므로 전체 프리미티브 배열이이 경우 제네릭 형식 매개 변수를 대체하기 때문입니다. 원시적 배열을 List 로 변환하려면, 우선, 원시적 배열을 대응하는 래퍼 형의 배열로 변환합니다 (즉, int[] 대신 Integer[] 에 Arrays.asList 를 호출합니다).

  따라서 false 를 출력합니다 :

  int[] arr = {1, 2, 3};      // primitive array of int
  System.out.println(Arrays.asList(arr).contains(1));
  

  데모보기

  반면에,이 인쇄됩니다 true :

  Integer[] arr = {1, 2, 3};  // object array of Integer (wrapper for int)
  System.out.println(Arrays.asList(arr).contains(1));
  

  데모보기

  이것은 배열이 Integer[] 로 해석되기 때문에 true 를 출력 true :

  System.out.println(Arrays.asList(1,2,3).contains(1));
  

  데모보기

다차원 배열 및 들쭉날쭉 한 배열

하나 이상의 차원을 갖는 배열을 정의하는 것이 가능합니다. 단일 색인을 제공하여 액세스하는 대신 각 차원에 대한 색인을 지정하여 다차원 배열에 액세스합니다.

다차원 배열의 선언은 각 차원에 대해 [] 를 정규 배열 해체에 추가하여 수행 할 수 있습니다. 예를 들어, 2 차원 int 배열을 만들려면 int[][] 와 같은 다른 대괄호 세트를 선언에 추가하십시오. 이것은 3 차원 배열 ( int[][][] ) 등에 대해서도 계속됩니다.

세 개의 행과 세 개의 열이있는 2 차원 배열을 정의하려면 :

int rows = 3;
int columns = 3;
int[][] table = new int[rows][columns];

이 배열을 사용하여 배열을 인덱싱하고 값을 할당 할 수 있습니다. 할당되지 않은 값은 배열 유형의 기본값이며,이 경우 int 0 입니다.

table[0][0] = 0;
table[0][1] = 1;
table[0][2] = 2;

한 번에 차원을 인스턴스화하고 비 직사각형 배열을 만들 수도 있습니다. 이들은 일반적으로 지그재그 어레이 라고 합니다 .

int[][] nonRect = new int[4][];

들쭉날쭉 한 배열의 치수를 정의 할 수는 있지만 선행 수준을 정의해야한다는 점에 유의 해야 합니다.

// valid
String[][] employeeGraph = new String[30][];

// invalid
int[][] unshapenMatrix = new int[][10];

// also invalid
int[][][] misshapenGrid = new int[100][][10];

Java에서 다차원 배열을 나타내는 방법

^{이미지 출처 : http://math.hws.edu/eck/cs124/javanotes3/c8/s5.html}

지그재그 배열 리터럴 초기화

다차원 배열 및 들쭉날쭉 한 배열은 리터럴 식으로 초기화 될 수도 있습니다. 다음은 2x3 int 배열을 선언하고 채 웁니다.

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

주 : 들쭉날쭉 한 부분 배열도 null 일 가능성이 있습니다. 예를 들어, 다음 코드는 첫 번째 하위 배열이 null 이고 두 번째 하위 배열의 길이가 0이고 두 번째 하위 배열의 길이가 하나이며 마지막 하위 배열의 길이가 두 개인 배열 인 2 차원 int 배열을 선언하고 채 웁니다.

int[][] table = {
    null,
    {},
    {1},
    {1,2}
};

다차원 배열의 경우 색인을 사용하여 하위 차원 차원의 배열을 추출 할 수 있습니다.

int[][][] arr = new int[3][3][3];
int[][] arr1 = arr[0]; // get first 3x3-dimensional array from arr
int[] arr2 = arr1[0]; // get first 3-dimensional array from arr1
int[] arr3 = arr[0]; // error: cannot convert from int[][] to int[]

ArrayIndexOutOfBoundsException

ArrayIndexOutOfBoundsException 는 배열의 존재하지 않는 인덱스에 액세스 할 때 발생합니다.

배열은 0부터 시작하므로 첫 번째 요소의 인덱스는 0 이고 마지막 요소의 인덱스는 배열의 용량에서 1 뺀 값입니다 (즉 array.length - 1 ).

따라서, 인덱스 i 의한 배열 요소의 요구는, 0 <= i < array.length 의 조건을 채우지 않으면 안됩니다. 그렇지 않은 경우, ArrayIndexOutOfBoundsException 가 Throw됩니다.

다음 코드는 ArrayIndexOutOfBoundsException 이 던져지는 간단한 예제입니다.

String[] people = new String[] { "Carol", "Andy" };

// An array will be created:
// people[0]: "Carol"
// people[1]: "Andy"

// Notice: no item on index 2. Trying to access it triggers the exception:
System.out.println(people[2]);  // throws an ArrayIndexOutOfBoundsException.

산출:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at your.package.path.method(YourClass.java:15)

액세스되는 불법 인덱스는 예외 (이 예에서는 2 )에도 포함됩니다. 이 정보는 예외의 원인을 찾는 데 유용 할 수 있습니다.

이것을 방지하려면 인덱스가 배열의 제한 범위 내에 있는지 확인하기 만하면됩니다.

int index = 2;
if (index >= 0 && index < people.length) {
    System.out.println(people[index]);
} 

배열 길이 가져 오기

배열은 지정된 유형의 요소 크기까지 저장할 수있는 공간을 제공하는 객체입니다. 배열을 만든 후에는 배열의 크기를 수정할 수 없습니다.

int[] arr1 = new int[0];
int[] arr2 = new int[2];
int[] arr3 = new int[]{1, 2, 3, 4};
int[] arr4 = {1, 2, 3, 4, 5, 6, 7};

int len1 = arr1.length; // 0
int len2 = arr2.length; // 2
int len3 = arr3.length; // 4
int len4 = arr4.length; // 7

배열의 length 필드는 배열의 크기를 저장합니다. 그것은 final 필드이며 수정할 수 없습니다.

이 코드는 배열의 length 와 배열에 저장되는 개체의 양 간의 차이를 보여줍니다.

public static void main(String[] args) {
    Integer arr[] = new Integer[] {1,2,3,null,5,null,7,null,null,null,11,null,13};

    int arrayLength = arr.length;
    int nonEmptyElementsCount = 0;

    for (int i=0; i<arrayLength; i++) {
        Integer arrElt = arr[i];
        if (arrElt != null) {
            nonEmptyElementsCount++;
        }
    }

    System.out.println("Array 'arr' has a length of "+arrayLength+"\n"
                            + "and it contains "+nonEmptyElementsCount+" non-empty values");
}

결과:

Array 'arr' has a length of 13
and it contains 7 non-empty values

배열이 동일한 지 비교하기

배열 유형은 상속 equals() (와 hashCode() java.lang.Object 상위)에서 구현 하므로, equals() 동일한 배열 객체에 대해 비교하는 경우에만 true를 돌려줍니다. 그 값에 근거 해 동등한 지 어떤지를 비교하려면, java.util.Arrays.equals 사용합니다. 이것은, 모든 배열 형에 대해서 오버로드되고 있습니다.

int[] a = new int[]{1, 2, 3};
int[] b = new int[]{1, 2, 3};
System.out.println(a.equals(b)); //prints "false" because a and b refer to different objects
System.out.println(Arrays.equals(a, b)); //prints "true" because the elements of a and b have the same values

요소 형이 참조 형인 경우, Arrays.equals() 는 배열 요소에 equals() 를 호출 해 동일성을 판정합니다. 특히 요소 유형 자체가 배열 유형 인 경우 ID 비교가 사용됩니다. 다차원 배열의 동일성을 비교하려면 다음과 같이 Arrays.deepEquals() 사용하십시오.

int a[] = { 1, 2, 3 };
int b[] = { 1, 2, 3 };

Object[] aObject = { a }; // aObject contains one element
Object[] bObject = { b }; // bObject contains one element

System.out.println(Arrays.equals(aObject, bObject)); // false
System.out.println(Arrays.deepEquals(aObject, bObject));// true

세트와 맵은 equals() 및 hashCode() 사용하므로 배열은 일반적으로 set 요소 또는 맵 키로 유용하지 않습니다. 배열 요소의 측면에서 equals() 및 hashCode() 를 구현하는 도우미 클래스로 래핑하거나 List 인스턴스로 변환하고 List 을 저장하십시오.

배열로 스트림

String[] arr = new String[] {"str1", "str2", "str3"};
Stream<String> stream = Arrays.stream(arr);

int[] intArr = {1, 2, 3};
IntStream intStream = Arrays.stream(intArr);

int[] values = {1, 2, 3, 4};
IntStream intStream = Arrays.stream(values, 2, 4);

Stream<Integer> intStream = Stream.of(1, 2, 3);
Stream<String> stringStream = Stream.of("1", "2", "3");
Stream<Double> doubleStream = Stream.of(new Double[]{1.0, 2.0});

배열 반복

향상된 for 루프 (일명 foreach)를 사용하거나 배열 인덱스를 사용하여 배열을 반복 할 수 있습니다.

int[] array = new int[10];

// using indices: read and write
for (int i = 0; i < array.length; i++) {
    array[i] = i;
}

// extended for: read only
for (int e : array) {
    System.out.println(e);
}

여기에서 주목할 점은 Array에서 Iterator를 사용하는 직접적인 방법이 없다는 점입니다. 그러나 Array 라이브러리를 통해 Iterable 객체를 얻기 위해 쉽게 목록으로 변환 될 수 있습니다.

박스형 배열의 경우 Arrays.asList를 사용합니다.

Integer[] boxed = {1, 2, 3};
Iterable<Integer> boxedIt = Arrays.asList(boxed); // list-backed iterable
Iterator<Integer> fromBoxed1 = boxedIt.iterator();

원시 배열 (자바 8 사용)의 경우 스트림 ( 특히이 예제에서는 Arrays.stream -> IntStream )을 사용하십시오.

int[] primitives = {1, 2, 3};
IntStream primitiveStream = Arrays.stream(primitives); // list-backed iterable
PrimitiveIterator.OfInt fromPrimitive1 = primitiveStream.iterator();

스트림 (java 8 없음)을 사용할 수 없다면 google의 구아바 라이브러리를 사용할 수 있습니다.

Iterable<Integer> fromPrimitive2 = Ints.asList(primitives);

2 차원 배열 이상에서는 두 가지 기법을 약간 더 복잡한 방식으로 사용할 수 있습니다.

예:

int[][] array = new int[10][10];

for (int indexOuter = 0; indexOuter < array.length; indexOuter++) {
    for (int indexInner = 0; indexInner < array[indexOuter].length; indexInner++) {
        array[indexOuter][indexInner] = indexOuter + indexInner;
    }
}

for (int[] numbers : array) {
    for (int value : numbers) {
        System.out.println(value);
    }
}

인덱스 기반 루프를 사용하지 않고 배열을 임의의 비 균일 값으로 설정할 수 없습니다.

물론 인덱스를 사용하여 반복 할 때 while 또는 do-while 루프를 사용할 수도 있습니다.

주의 사항 : 어레이 인덱스를 사용할 때 인덱스가 0 과 array.length - 1 (둘 모두 포함) 사이인지 확인하십시오. 배열 길이에 대해 하드 코딩 된 가정을하지 마십시오. 그렇지 않으면 배열 길이는 변경되지만 하드 코딩 된 값은 변경되지 않으면 코드가 손상 될 수 있습니다.

예:

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

public void incrementNumbers() {
    // DO THIS :
    for (int i = 0; i < numbers.length; i++) {
        numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;      
    }
 
    // DON'T DO THIS :
    for (int i = 0; i < 4; i++) {
        numbers[i] += 1;
    }
}

복잡한 계산을 사용하여 인덱스를 가져 오지 않고 인덱스를 사용하여 반복하고 다른 값을 필요로하는 경우 가장 좋습니다.

예:

public void fillArrayWithDoubleIndex(int[] array) {
    // DO THIS :
    for (int i = 0; i < array.length; i++) {
        array[i] = i * 2;
    }
 
    // DON'T DO THIS :
    int doubleLength = array.length * 2;
    for (int i = 0; i < doubleLength; i += 2) {
        array[i / 2] = i;
    }
}

배열 역순으로 액세스

int[] array = {0, 1, 1, 2, 3, 5, 8, 13};
for (int i = array.length - 1; i >= 0; i--) {
   System.out.println(array[i]);
}

임시 배열을 사용하여 코드 반복 감소

코드를 반복하지 않고 임시 배열을 반복하면 코드를보다 명확하게 처리 할 수 ​​있습니다. 동일한 작업이 여러 변수에서 수행되는 경우에 사용할 수 있습니다.

// we want to print out all of these
String name = "Margaret";
int eyeCount = 16;
double height = 50.2;
int legs = 9;
int arms = 5;


// copy-paste approach:
System.out.println(name);
System.out.println(eyeCount);
System.out.println(height);
System.out.println(legs);
System.out.println(arms);


// temporary array approach:
for(Object attribute : new Object[]{name, eyeCount, height, legs, arms})
    System.out.println(attribute);

// using only numbers
for(double number : new double[]{eyeCount, legs, arms, height})
    System.out.println(Math.sqrt(number));

루프가 입력 될 때마다 배열이 생성되고 원시 변수가 배열에 복사되어 수정할 수 없으므로이 코드는 성능이 중요한 섹션에 사용하면 안됩니다.

배열 복사

Java는 배열을 복사하는 몇 가지 방법을 제공합니다.

for 루프

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length]; 
for (int i = 0; i < a.length; i++) {
    b[i] = a[i];
}

프리미티브 배열 대신 Object 배열에이 옵션을 사용하면 복사본 대신 원본 내용을 참조하여 복사본을 채 웁니다.

Object.clone ()

배열은 Java의 Object 이므로 Object.clone() 사용할 수 있습니다.

int[] a = { 4, 1, 3, 2 };
int[] b = a.clone(); // [4, 1, 3, 2]

배열의 Object.clone 메서드는 얕은 복사본을 수행합니다. 즉, 소스 배열 과 동일한 요소를 참조하는 새 배열에 대한 참조를 반환합니다.

Arrays.copyOf ()

java.util.Arrays 는 배열 복사를 다른 배열에 쉽게 수행 할 수있는 방법을 제공합니다. 다음은 기본적인 사용법입니다.

int[] a = {4, 1, 3, 2};
int[] b = Arrays.copyOf(a, a.length); // [4, 1, 3, 2]

Arrays.copyOf 는 배열의 유형을 변경할 수있는 오버로드를 제공합니다.

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

System.arraycopy ()

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 지정된 위치에서 시작하여 지정된 소스 배열의 배열을 대상 배열의 지정된 위치에 복사합니다.

사용 예 아래

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, a.length); // [4, 1, 3, 2]

Arrays.copyOfRange ()

주로 Array의 일부를 복사하는 데 사용되며, 아래와 같이 전체 Array를 다른 Array로 복사하는 데에도 사용할 수 있습니다.

int[] a = { 4, 1, 3, 2 };
int[] b = Arrays.copyOfRange(a, 0, a.length); // [4, 1, 3, 2]

주조 배열

배열은 객체이지만 형식은 포함 된 객체의 유형에 따라 정의됩니다. 따라서 A[] 를 T[] 캐스트 할 수는 없지만 특정 A[] 의 각 A 멤버는 T 객체로 캐스팅되어야합니다. 일반적인 예 :

public static <T, A> T[] castArray(T[] target, A[] array) {
    for (int i = 0; i < array.length; i++) {
        target[i] = (T) array[i];
    }
    return target;
}

따라서, 주어진 A[] 배열 :

T[] target = new T[array.Length];
target = castArray(target, array);

Java SE는,이 목적으로 Arrays.copyOf(original, newLength, newType) 메소드를 제공합니다.

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

배열에서 요소 제거

Java는 배열에서 요소를 제거하기 위해 java.util.Arrays 에 직접 메소드를 제공하지 않습니다. 이를 수행하기 위해 요소를 제거하지 않고 원래 배열을 새 배열로 복사하거나 배열을 다른 구조로 변환하여 제거 할 수 있습니다.

ArrayList 사용

배열을 java.util.List 로 변환하고, 요소를 제거하고, 다음과 같이 목록을 다시 배열로 변환 할 수 있습니다.

String[] array = new String[]{"foo", "bar", "baz"};

List<String> list = new ArrayList<>(Arrays.asList(array));
list.remove("foo");

// Creates a new array with the same size as the list and copies the list
// elements to it.
array = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(array)); //[bar, baz]

System.arraycopy 사용

System.arraycopy() 를 사용하면 원래 배열의 복사본을 만들고 원하는 요소를 제거 할 수 있습니다. 아래 예제 :

int[] array = new int[] { 1, 2, 3, 4 }; // Original array.
int[] result = new int[array.length - 1]; // Array which will contain the result.
int index = 1; // Remove the value "2".

// Copy the elements at the left of the index.
System.arraycopy(array, 0, result, 0, index);
// Copy the elements at the right of the index.
System.arraycopy(array, index + 1, result, index, array.length - index - 1);

System.out.println(Arrays.toString(result)); //[1, 3, 4]

Apache Commons Lang 사용하기

요소를 쉽게 제거하려면 Apache Commons Lang 라이브러리, 특히 ArrayUtils 클래스의 정적 메서드 removeElement() 를 사용할 수 있습니다. 아래 예제 :

int[] array = new int[]{1,2,3,4};
array = ArrayUtils.removeElement(array, 2); //remove first occurrence of 2
System.out.println(Arrays.toString(array)); //[1, 3, 4]

배열 공분산

객체 배열은 공변 (covariant)하기 때문에 Integer 가 Number 의 하위 클래스 인 것처럼 Integer[] 는 Number[] 의 하위 클래스입니다. 이것은 직관적으로 보일지 모르지만 놀라운 결과를 초래할 수 있습니다.

Integer[] integerArray = {1, 2, 3};
Number[] numberArray = integerArray;  // valid
Number firstElement = numberArray[0]; // valid
numberArray[0] = 4L;                  // throws ArrayStoreException at runtime

하지만 Integer[] 의 하위 클래스 Number[] , 만 저장할 수있는 Integer 들, 그리고 할당하려고 Long 요소하면 런타임 예외가 발생합니다.

이 동작은 배열마다 고유하므로 대신 generic List 을 사용하여 피할 수 있습니다.

List<Integer> integerList = Arrays.asList(1, 2, 3);
//List<Number> numberList = integerList;  // compile error
List<? extends Number> numberList = integerList;
Number firstElement = numberList.get(0);
//numberList.set(0, 4L);                  // compile error

배열 요소의 하위 클래스 인 한 모든 배열 요소가 동일한 유형을 공유 할 필요는 없습니다.

interface I {}

class A implements I {}
class B implements I {}
class C implements I {}

I[] array10 = new I[] { new A(), new B(), new C() }; // Create an array with new
                                                     // operator and array initializer.

I[] array11 = { new A(), new B(), new C() };         // Shortcut syntax with array
                                                     // initializer.

I[] array12 = new I[3];                              // { null, null, null }

I[] array13 = new A[] { new A(), new A() };          // Works because A implements I.

Object[] array14 = new Object[] { "Hello, World!", 3.14159, 42 }; // Create an array with
                                                     // new operator and array initializer.

Object[] array15 = { new A(), 64, "My String" };     // Shortcut syntax 
                                                     // with array initializer.

배열의 크기를 어떻게 변경합니까?

간단한 대답은 당신이 이것을 할 수 없다는 것입니다. 배열이 작성되면 크기를 변경할 수 없습니다. 대신 적절한 크기의 새 배열을 만들고 기존 배열의 요소를 새 배열에 복사하여 배열의 "크기를 조정"할 수 있습니다.

String[] listOfCities = new String[3];   // array created with size 3.
listOfCities[0] = "New York";
listOfCities[1] = "London";
listOfCities[2] = "Berlin";

예를 들어 위와 같이 정의 된 listOfCities 배열에 새 요소를 추가해야한다고 가정합니다. 이렇게하려면 다음을 수행해야합니다.

1. 크기가 4 인 새 배열을 만들고,
2. 이전 배열의 기존 3 요소를 오프셋 0, 1 및 2의 새 배열에 복사하고
3. 새 요소를 오프셋 3의 새 배열에 추가하십시오.

위의 방법에는 여러 가지가 있습니다. Java 6 이전의 가장 간결한 방법은 다음과 같습니다.

String[] newArray = new String[listOfCities.length + 1];
System.arraycopy(listOfCities, 0, newArray, 0, listOfCities.length);
newArray[listOfCities.length] = "Sydney";

Java 6 이후부터 Arrays.copyOf 및 Arrays.copyOfRange 메소드를 사용하면보다 간단 Arrays.copyOfRange 작업을 수행 할 수 있습니다.

String[] newArray = Arrays.copyOf(listOfCities, listOfCities.length + 1);
newArray[listOfCities.length] = "Sydney";

배열을 복사하는 다른 방법은 다음 예제를 참조하십시오. 크기를 조정할 때 원본과 다른 길이의 배열 사본이 필요하다는 점에 유의하십시오.

• 배열 복사

배열 크기 조정에 대한 더 나은 대안

위에서 설명한대로 배열 크기를 조정할 때 두 가지 주요 단점이 있습니다.

• 비효율적이다. 배열을 더 크거나 작게 만들려면 기존 배열 요소를 모두 또는 모두 복사하고 새 배열 객체를 할당해야합니다. 어레이가 클수록 어레이 비용이 높아집니다.
• 이전 배열에 대한 참조를 포함하는 "라이브"변수를 업데이트 할 수 있어야합니다.

한 가지 대안은 시작하기에 충분한 크기의 배열을 만드는 것입니다. 배열을 할당하기 전에 크기를 정확하게 결정할 수있는 경우에만 실행 가능합니다. 그렇게 할 수 없다면 배열의 크기 조정 문제가 다시 발생합니다.

또 다른 대안은 Java SE 클래스 라이브러리 또는 타사 라이브러리에서 제공하는 데이터 구조 클래스를 사용하는 것입니다. 예를 들어, Java SE의 「콜렉션」프레임 워크는, 실행시 properties가 다른 List , Set 및 Map API의 구현을 제공합니다. ArrayList 클래스는 참조 업데이트 문제없이 더 효율적인 크기 조정을 제공하면서 일반 배열 (예 : O (N) 조회, O (1) 가져 오기 및 설정, O (N) 임의 삽입 및 삭제)의 성능 특성에 가장 가깝습니다.

( ArrayList 의 크기 조정 효율은 각 크기 조정에서 배킹 배열의 크기를 두 배로 늘리는 전략에서 나온 것입니다. 일반적인 사용 사례의 경우 가끔씩 크기를 조정한다는 의미입니다. 목록 수명 동안 상환하면 크기 조정 비용 삽입 당 O(1) 입니다. 일반 배열 크기를 조정할 때 같은 전략을 사용할 수 있습니다.)

배열에서 요소 찾기

배열에서 값의 위치를 ​​찾는 방법은 여러 가지가 있습니다. 다음 예제 코드 단편은 모두 배열이 다음 중 하나임을 전제로합니다.

  String[] strings = new String[] { "A", "B", "C" };
  int[] ints = new int[] { 1, 2, 3, 4 };

또한 각 요소는 index 또는 index2 를 필수 요소의 인덱스로 설정합니다. 요소가 없으면 -1 설정합니다.

Arrays.binarySearch 사용 (정렬 된 배열에만 해당)

  int index = Arrays.binarySearch(strings, "A");
  int index2 = Arrays.binarySearch(ints, 1);

Arrays.asList 사용 (비 프리미티브 (primitive)가 아닌 배열에 대해서만)

  int index = Arrays.asList(strings).indexOf("A");
  int index2 = Arrays.asList(ints).indexOf(1);  // compilation error

Stream 사용

  int index = IntStream.range(0, strings.length)
                       .filter(i -> "A".equals(strings[i]))
                       .findFirst()
                       .orElse(-1); // If not present, gives us -1.
  // Similar for an array of primitives

루프를 사용한 선형 검색

  int index = -1;
  for (int i = 0; i < array.length; i++) {
      if ("A".equals(array[i])) {
          index = i;
          break;
      }            
  }
  // Similar for an array of primitives

org.apache.commons 와 같은 타사 라이브러리를 사용한 선형 검색

  int index = org.apache.commons.lang3.ArrayUtils.contains(strings, "A");
  int index2 = org.apache.commons.lang3.ArrayUtils.contains(ints, 1);

참고 : 직접 선형 검색을 사용하면 목록에 배치하는 것보다 효율적입니다.

배열에 요소가 포함되어 있는지 테스트

위의 예제는 계산 된 인덱스가 0보다 크거나 같은지 테스트하기 위해 배열에 요소가 들어 있는지 테스트하는 데 적용 할 수 있습니다.

또는 간결한 변형도 있습니다.

boolean isPresent = Arrays.asList(strings).contains("A");

boolean isPresent = Stream<String>.of(strings).anyMatch(x -> "A".equals(x));

boolean isPresent = false;
for (String s : strings) {
    if ("A".equals(s)) {
        isPresent = true;
        break;
    }
}

boolean isPresent = org.apache.commons.lang3.ArrayUtils.contains(ints, 4);

배열 정렬하기

Arrays API를 사용하면 배열을 쉽게 정렬 할 수 있습니다.

import java.util.Arrays;

// creating an array with integers
int[] array = {7, 4, 2, 1, 19};
// this is the sorting part just one function ready to be used
Arrays.sort(array);
// prints [1, 2, 4, 7, 19]
System.out.println(Arrays.toString(array));

문자열 배열 정렬 :

String 은 숫자 데이터가 아니며 사전 순서라고도하는 사전 식 순서라고하는 자체 순서를 정의합니다. sort() 메소드를 사용하여 String의 배열을 정렬하면 array를 Comparable 인터페이스에 정의 된 자연 순서로 sort() 아래 그림 참조).

증가 명령

String[] names = {"John", "Steve", "Shane", "Adam", "Ben"};
System.out.println("String array before sorting : " + Arrays.toString(names));
Arrays.sort(names); 
System.out.println("String array after sorting in ascending order : " + Arrays.toString(names));

산출:

String array before sorting : [John, Steve, Shane, Adam, Ben]    
String array after sorting in ascending order : [Adam, Ben, John, Shane, Steve]

주문 감소

Arrays.sort(names, 0, names.length, Collections.reverseOrder());
System.out.println("String array after sorting in descending order : " + Arrays.toString(names));

산출:

String array after sorting in descending order : [Steve, Shane, John, Ben, Adam]

객체 배열 정렬하기

객체 배열을 정렬하려면 모든 요소가 Comparable 또는 Comparator 인터페이스를 구현하여 정렬 순서를 정의해야합니다.

우리는 sort(Object[]) 메서드를 사용하여 객체 배열을 자연 순서로 정렬 할 수 있지만 배열의 모든 요소가 Comparable 구현해야합니다.

게다가 e1.compareTo(e2) 는 배열의 요소 e1과 e2에 ClassCastException 을 던져서는 안된다. 또는 다음 예와 같이 sort(T[], Comparator) 메서드를 사용하여 사용자 정의 순서로 Object 배열을 정렬 할 수 있습니다.

// How to Sort Object Array in Java using Comparator and Comparable
Course[] courses = new Course[4];
courses[0] = new Course(101, "Java", 200);
courses[1] = new Course(201, "Ruby", 300);
courses[2] = new Course(301, "Python", 400);
courses[3] = new Course(401, "Scala", 500);
       
System.out.println("Object array before sorting : " + Arrays.toString(courses));
       
Arrays.sort(courses);
System.out.println("Object array after sorting in natural order : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.PriceComparator());
System.out.println("Object array after sorting by price : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.NameComparator());
System.out.println("Object array after sorting by name : " + Arrays.toString(courses));

산출:

Object array before sorting : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting in natural order : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by price : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by name : [#101 Java@200 , #301 Python@400 , #201 Ruby@300 , #401 Scala@500 ]

프리미티브와 박스형간에 배열 변환

때로는 기본 유형을 박스형으로 변환해야합니다.

배열을 변환하려면 스트림을 사용할 수 있습니다 (Java 8 이상).

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = 
    Arrays.stream(primitiveArray).boxed().toArray(Integer[]::new);

하위 버전에서는 프리미티브 배열을 반복하여 명시 적으로 박스형 배열에 복사 할 수 있습니다.

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = new Integer[primitiveArray.length];
for (int i = 0; i < primitiveArray.length; ++i) {
    boxedArray[i] = primitiveArray[i]; // Each element is autoboxed here
}

마찬가지로, 박스형 배열은 프리미티브 대응 배열로 변환 될 수 있습니다.

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = 
    Arrays.stream(boxedArray).mapToInt(Integer::intValue).toArray();

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = new int[boxedArray.length];
for (int i = 0; i < boxedArray.length; ++i) {
    primitiveArray[i] = boxedArray[i]; // Each element is outboxed here
}