java - 초기화 - 자바 배열 선언 종류




Java로 배열을 선언하고 초기화하는 방법은 무엇입니까? (14)

Java로 배열을 선언하고 초기화하는 방법은 무엇입니까?


Java 9

다른 IntStream.iterateIntStream.takeWhile 메서드 사용 :

int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();

Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]


int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();

Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

자바 10

지역 변수 유형 추론 사용하기 :

var letters = new String[]{"A", "B", "C"};

ArrayList를 선언하고 초기화하는 또 다른 방법은 다음과 같습니다.

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

Java 8에서는 이와 같이 사용할 수 있습니다.

String[] strs = IntStream.range(0, 15)  // 15 is the size
    .mapToObj(i -> Integer.toString(i))
    .toArray(String[]::new);

Java에서 배열을 선언 할 수있는 다양한 방법이 있습니다.

float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};

자세한 내용은 Sun 자습서 사이트 및 JavaDoc 에서 찾을 수 있습니다.


객체 참조의 배열 선언하기 :

class Animal {}

class Horse extends Animal {
    public static void main(String[] args) {

        /*
         * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed)
         */
        Animal[] a1 = new Animal[10];
        a1[0] = new Animal();
        a1[1] = new Horse();

        /*
         * Array of Animal can hold Animal and Horse and all subtype of Horse
         */
        Animal[] a2 = new Horse[10];
        a2[0] = new Animal();
        a2[1] = new Horse();

        /*
         * Array of Horse can hold only Horse and its subtype (if any) and not
           allowed supertype of Horse nor other subtype of Animal.
         */
        Horse[] h1 = new Horse[10];
        h1[0] = new Animal(); // Not allowed
        h1[1] = new Horse();

        /*
         * This can not be declared.
         */
        Horse[] h2 = new Animal[10]; // Not allowed
    }
}

나는 당신이 각 부분을 이해한다면 도움이된다고 생각합니다.

Type[] name = new Type[5];

Type[] 은 name이라는 변수유형 입니다 ( "name"은 식별자 라고 함). 리터럴 "Type"은 기본 유형이며 대괄호는 해당베이스의 배열 유형을 의미합니다. 배열 유형은 차례대로 자체의 유형으로, Type[][] (Type [])의 배열 유형과 같은 다차원 배열을 만들 수 있습니다. new 키워드는 새 배열에 메모리를 할당한다고 말합니다. 브래킷 사이의 숫자는 새 배열의 크기와 할당 할 메모리 양을 나타냅니다. 예를 들어 Java에서 기본 유형 Type 이 32 바이트를 차지하고 크기가 5 인 배열을 원한다면 내부적으로 32 * 5 = 160 바이트를 할당해야합니다.

이미있는 값을 사용하여 배열을 만들 수도 있습니다 (예 :

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

빈 공간을 생성 할뿐만 아니라 그 값으로 채 웁니다. Java는 원시가 정수이고 그 중 5 개가 있음을 알 수 있으므로 배열의 크기를 암시 적으로 결정할 수 있습니다.


또는,

// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];

arrayName 이라는 크기의 배열을 선언합니다 (사용할 요소는 0에서 9까지입니다).


또한 좀 더 동적 인 것을 원할 경우 List 인터페이스가 있습니다. 이는 잘 수행되지 않지만 더 유연합니다.

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

배열 선언 또는 배열 리터럴을 사용할 수 있지만 (변수를 즉시 선언하고 영향을 줄 때만, 배열 리터럴을 사용하여 배열을 다시 할당 할 수 없습니다).

기본 유형의 경우 :

int[] myIntArray = new int[3];
int[] myIntArray = {1,2,3};
int[] myIntArray = new int[]{1,2,3};

클래스 (예 : String )의 경우에는 동일합니다.

String[] myStringArray = new String[3];
String[] myStringArray = {"a","b","c"};
String[] myStringArray = new String[]{"a","b","c"};

배열을 먼저 선언하고 초기화 할 때 세 번째 초기화 방법이 유용합니다. 여기에 캐스트가 필요합니다.

String[] myStringArray;
myStringArray = new String[]{"a","b","c"};

배열에는 두 가지 유형이 있습니다.

1 차원 배열

기본값에 대한 구문 :

int[] num = new int[5];

또는 (덜 선호하는)

int num[] = new int[5];

주어진 값을 가진 구문 (변수 / 필드 초기화) :

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

또는 (덜 선호하는)

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

참고 : 편의상 int [] num은 배열에 대해 여기에서 말하고 있다는 것을 분명하게 알려주기 때문에 바람직합니다. 그렇지 않으면 차이가 없습니다. 전혀.

다차원 배열

선언

int[][] num = new int[5][2];

또는

int num[][] = new int[5][2];

또는

int[] num[] = new int[5][2];

초기화

 num[0][0]=1;
 num[0][1]=2;
 num[1][0]=1;
 num[1][1]=2;
 num[2][0]=1;
 num[2][1]=2;
 num[3][0]=1;
 num[3][1]=2;
 num[4][0]=1;
 num[4][1]=2;

또는

 int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };

비정형 배열 (또는 비 사각형 배열)

 int[][] num = new int[5][];
 num[0] = new int[1];
 num[1] = new int[5];
 num[2] = new int[2];
 num[3] = new int[3];

여기서는 명시 적으로 열을 정의합니다.
또 다른 방법:

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

액세스 용 :

for (int i=0; i<(num.length); i++ ) {
    for (int j=0;j<num[i].length;j++)
        System.out.println(num[i][j]);
}

대안 :

for (int[] a : num) {
  for (int i : a) {
    System.out.println(i);
  }
}

가변 배열은 다차원 배열입니다.
자세한 내용은 공식 Java 자습서 에서 다차원 배열 세부 정보를 참조하십시오.


배열을 만드는 두 가지 주요 방법은 다음과 같습니다.

이 배열은 빈 배열을 나타냅니다.

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

그리고 초기화 된 배열의 경우 :

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

다음과 같이 다차원 배열을 만들 수도 있습니다.

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

예를 들어 원시 형 int 를 가져옵니다. 선언하고 int 배열하는 몇 가지 방법이 있습니다 :

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

이 모든 경우에서 int[] i 대신 int i[] 를 사용할 수 있습니다.

리플렉션을 사용하면 (Type[]) Array.newInstance(Type.class, capacity);

메서드 매개 변수에서 ...variable arguments 나타냅니다. 본질적으로 모든 매개 변수가 문제가되지 않습니다. 코드로 설명하는 것이 더 쉽습니다.

public static void varargs(int fixed1, String fixed2, int... varargs) {...}
...
varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

이 메소드 내에서 varargs 는 일반적인 int[] 로 처리됩니다. Type... 은 메서드 매개 변수에서만 사용할 수 있으므로 int... i = new int[] {} 는 컴파일되지 않습니다.

int[] 를 메서드 (또는 다른 Type[] )에 전달할 때는 세 번째 방법을 사용할 수 없습니다. int[] i = *{a, b, c, d, etc}* 에서 컴파일러는 {...}int[] 의미한다고 가정합니다. 그러나 그것은 변수를 선언하기 때문입니다. 메소드에 배열을 전달할 때, 선언은 new Type[capacity] 이거나 new Type[] {...} 이어야합니다.

다차원 배열

다차원 배열은 다루기가 훨씬 어렵습니다. 기본적으로 2D 배열은 배열의 배열입니다. int[][] int[] 의 배열을 의미합니다. 핵심은 int[][]int[x][y] 로 선언되면 최대 인덱스는 i[x-1][y-1] 입니다. 기본적으로 직사각형 int[3][5] 는 다음과 같습니다.

[0, 0] [1, 0] [2, 0]
[0, 1] [1, 1] [2, 1]
[0, 2] [1, 2] [2, 2]
[0, 3] [1, 3] [2, 3]
[0, 4] [1, 4] [2, 4]

Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

변수의 유형이 실제로 배열임을 알기 쉽기 때문에 유형 뒤에 대괄호를 사용하는 것이 더 좋습니다.


int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]




declare