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

배열 선언이나 배열 리터럴을 사용할 수 있습니다 (단, 변수를 선언하고 바로 영향을주는 경우에만 배열 리터럴을 사용하여 배열을 다시 할당 할 수 없습니다).

기본 유형의 경우 :

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

// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html

int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort 

예를 들어 클래스 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 자습서 에서 다차원 배열 세부 정보를 참조하십시오.

Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

변수도 유효하지만 변수 유형이 실제로 배열임을 쉽게 알 수 있기 때문에 유형 뒤에 괄호를 선호합니다.

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

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

Sun 튜토리얼 사이트와 JavaDoc 에서 자세한 정보를 찾을 수 있습니다 .

각 부분을 이해하면 도움이됩니다.

Type[] name = new Type[5];

Type[]name이라는 변수 의 유형 입니다 ( "name"은 identifier 라고 함 ). 리터럴 "Type"은 기본 유형이며 괄호는 이것이 기본의 배열 유형임을 의미합니다. 배열 유형은 고유 한 유형으로 , 배열 유형은 Type [] 과 같은 다차원 배열을 만들 수 있습니다 . 키워드 는 새 배열에 메모리를 할당한다고 말합니다. 대괄호 사이의 숫자는 새 배열의 크기와 할당 할 메모리 양을 나타냅니다. 예를 들어, Java가 기본 유형을 알고있는 경우Type[][]newType 32 바이트가 필요 5 크기의 배열을 원하면 내부적으로 32 * 5 = 160 바이트를 할당해야합니다.

이미 존재하는 값으로 배열을 만들 수도 있습니다.

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

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

다음은 배열 선언을 보여 주지만 배열이 초기화되지 않았습니다.

 int[] myIntArray = new int[3];

다음은 배열의 선언과 선언을 보여줍니다.

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

이제 다음은 선언 및 배열 초기화를 보여줍니다.

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

그러나이 세 번째는 참조 변수 "myIntArray"가 가리키는 익명 배열 객체 생성의 속성을 보여줍니다. "new int [] {1,2,3};" 이것이 익명 배열 객체를 만드는 방법입니다.

우리가 방금 쓴다면 :

int[] myIntArray;

이것은 배열 선언이 아니지만 다음 명령문은 위 선언을 완료합니다.

myIntArray=new int[3];

또는

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

arrayName크기가 10 인 배열을 선언합니다 (사용할 요소가 0-9입니다).

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

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

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

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

배열을 만드는 두 가지 주요 방법이 있습니다.

이 배열은 빈 배열입니다.

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};

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

를 int[]메소드 (또는 다른 메소드)에 전달할 때는 Type[]세 번째 방법을 사용할 수 없습니다. 명령문 int[] i = *{a, b, c, d, etc}*에서 컴파일러는 {...}평균이 a 라고 가정 합니다 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]

자바 9

다른 사용 IntStream.iterate및 IntStream.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

은 Using 지역 변수 유형 추론을 :

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

반사를 사용하여 배열을 만들려면 다음과 같이하십시오.

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size ); 

객체 참조의 배열 선언 :

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
    }
}

배열은 순차적 인 항목 목록입니다

int item = value;

int [] one_dimensional_array = { value, value, value, .., value };

int [][] two_dimensional_array =
{
  { value, value, value, .. value },
  { value, value, value, .. value },
    ..     ..     ..        ..
  { value, value, value, .. value }
};

그것이 물체라면 같은 개념입니다

Object item = new Object();

Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() };

Object [][] two_dimensional_array =
{
  { new Object(), new Object(), .. new Object() },
  { new Object(), new Object(), .. new Object() },
    ..            ..               ..
  { new Object(), new Object(), .. new Object() }
};

객체의 경우, 당신은 할 수 중 하나를 지정해야 null사용하여 초기화 new Type(..), 같은 수업을 String하고 Integer다음과 같이 처리됩니다 특별한 경우가 있습니다

String [] a = { "hello", "world" };
// is equivalent to
String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) };

Integer [] b = { 1234, 5678 };
// is equivalent to
Integer [] b = { new Integer(1234), new Integer(5678) };

일반적으로 M차원 의 배열을 만들 수 있습니다

int [][]..[] array =
//  ^ M times [] brackets

    {{..{
//  ^ M times { bracket

//            this is array[0][0]..[0]
//                         ^ M times [0]

    }}..}
//  ^ M times } bracket
;

M차원 배열 을 만드는 것은 공간 측면에서 비용이 많이 듭니다. 모든 M차원 에서 차원 배열 을 만들 때 각 배열에 참조가 있고 M 차원에 (M-1) 차원 배열의 배열이 있기 때문에 N배열의 전체 크기가보다 큽니다 N^M. 총 크기는 다음과 같습니다

Space = N^M + N^(M-1) + N^(M-2) + .. + N^0
//      ^                              ^ array reference
//      ^ actual data

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

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

클래스 객체의 배열을 만들려면을 사용할 수 있습니다 java.util.ArrayList. 배열을 정의하려면

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

배열에 값을 할당하십시오.

arrayName.add(new ClassName(class parameters go here);

배열에서 읽습니다.

ClassName variableName = arrayName.get(index);

노트 :

variableName배열에 대한 참조는 조작 variableName이 조작 한다는 의미입니다.arrayName

for 루프 :

//repeats for every value in the array
for (ClassName variableName : arrayName){
}
//Note that using this for loop prevents you from editing arrayName

편집 할 수있는 arrayNamefor 루프 (기존의 for 루프) :

for (int i = 0; i < arrayName.size(); i++){
    //manipulate array here
}

Java 8 이상을 선언하고 초기화하십시오. 간단한 정수 배열을 만듭니다.

int [] a1 = IntStream.range(1, 20).toArray();
System.out.println(Arrays.toString(a1));
// Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

[-50, 50] 사이의 정수와 배가 [0, 1E17]에 대한 랜덤 배열을 만듭니다.

int [] a2 = new Random().ints(15, -50, 50).toArray();
double [] a3 = new Random().doubles(5, 0, 1e17).toArray();

2의 거듭 제곱 시퀀스 :

double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray();
System.out.println(Arrays.toString(a4));
// Output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0]

String []의 경우 생성자를 지정해야합니다.

String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new);
System.out.println(Arrays.toString(a5));

다차원 배열 :

String [][] a6 = List.of(new String[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"})
    .toArray(new String[0][]);
System.out.println(Arrays.deepToString(a6));
// Output: [[a, b, c], [d, e, f, g]]

ArrayList를 선언하고 초기화하는 다른 방법 :

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

여기에 많은 답변이 있습니다. 배열을 만드는 몇 가지 까다로운 방법을 추가하고 있습니다 ( 시험 관점에서 이것을 아는 것이 좋습니다)

1. 배열 선언 및 정의

   int intArray[] = new int[3];

   이렇게하면 길이가 3 인 배열이 만들어집니다. 기본 유형 인 int를 유지하므로 모든 값은 기본적으로 0으로 설정됩니다. 예를 들어

   intArray[2]; // Will return 0

2. 변수 이름 앞에 상자 괄호 [] 사용

   int[] intArray = new int[3];
   intArray[0] = 1;  // Array content is now {1, 0, 0}

3. 배열을 초기화하고 데이터를 제공

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

   이번에는 상자 괄호 안에 크기를 언급 할 필요가 없습니다. 이것의 간단한 변형조차도 :

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

4. 길이가 0 인 배열

   int[] intArray = new int[0];
   int length = intArray.length; // Will return length 0

   다차원 배열과 유사

   int intArray[][] = new int[2][3];
   // This will create an array of length 2 and
   //each element contains another array of length 3.
   // { {0,0,0},{0,0,0} }
   int lenght1 = intArray.length; // Will return 2
   int length2 = intArray[0].length; // Will return 3

변수 앞에 상자 괄호 사용 :

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

마지막에 하나의 상자 브래킷을 넣으면 좋습니다.

    int[] intArray [] = new int[2][4];
    int[] intArray[][] = new int[2][3][4]

몇 가지 예

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}}
    // All the 3 arrays assignments are valid
    // Array looks like {{1,2,3},{4,5,6}}

각 내부 요소의 크기가 반드시 같은 것은 아닙니다.

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}

    int[][] intArray = new int[][2] ; // This won't compile. Keep this in mind.

위의 구문을 사용하고 있는지, 순방향으로 상자 괄호 안에 값을 지정해야합니다. 그렇지 않으면 컴파일되지 않습니다. 몇 가지 예 :

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

또 다른 중요한 특징은 공변량입니다

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   // You can store a subclass object in an array that is declared
   // to be of the type of its superclass.
   // Here 'Number' is the superclass for both Float and Integer.

   Number num[] = new Float[5]; // This is also valid

중요 : 참조 형식의 경우 배열에 저장된 기본값은 null입니다.

당신은 또한 그것을 할 수 있습니다 java.util.Arrays:

List<String> number = Arrays.asList("1", "2", "3");

Out: ["1", "2", "3"]

이것은 매우 간단 하고 간단합니다.

지역 변수 유형 유추를 사용하면 유형을 한 번만 지정하면됩니다.

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

또는

int[] values = { 1, 2, 3 }

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

정적 배열 : 고정 크기 배열 (시작시 크기를 선언해야하며 나중에 변경할 수 없음)

동적 배열 : 여기에는 크기 제한이 고려되지 않습니다. (순수 동적 배열은 Java에 존재하지 않습니다. 대신 List가 가장 권장됩니다)

Integer, string, float 등의 정적 배열을 선언하려면 다음 선언 및 초기화 문을 사용하십시오.

    int[] intArray = new int[10]; 
    String[] intArray = new int[10]; 
    float[] intArray = new int[10]; 
    
   // here you have 10 index starting from 0 to 9

동적 기능을 사용하려면 List ... List를 사용해야합니다. List는 순수한 동적 배열 이므로 처음에 크기를 선언 할 필요가 없습니다. JAVA에서 목록을 선언하는 올바른 방법은 Bellow입니다.>

        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("Value 1: something");
        myArray.add("Value 2: something more");

배열 선언 : int[] arr;

배열 초기화 : int[] arr = new int[10];10은 배열에서 허용되는 요소 수를 나타냅니다.

다차원 배열 선언 : int[][] arr;

다차원 배열 초기화 : int[][] arr = new int[10][17];10 곱하기 17은 170이므로 10 개의 행과 17 개의 열과 170 개의 요소가 있습니다.

배열을 초기화한다는 것은 배열의 크기를 지정하는 것을 의미합니다.

배열을 선언하고 초기화하는 것은 매우 쉽습니다. 예를 들어, 배열에 1, 2, 3, 4 및 5 인 5 개의 정수 요소를 저장하려고합니다. 다음과 같은 방법으로 수행 할 수 있습니다.

ㅏ)

int[] a = new int[5];

또는

비)

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

따라서 기본 패턴은 메소드 a)에 의한 초기화 및 선언입니다.

datatype[] arrayname = new datatype[requiredarraysize];

datatype 소문자 여야합니다.

따라서 기본 패턴은 메소드 a에 의한 초기화 및 선언입니다.

문자열 배열 인 경우 :

String[] a = {"as", "asd", "ssd"};

문자 배열 인 경우 :

char[] a = {'a', 's', 'w'};

float double의 경우 배열 형식은 정수와 같습니다.

예를 들면 다음과 같습니다.

double[] a = {1.2, 1.3, 12.3};

그러나 "method a"로 배열을 선언하고 초기화 할 때 값을 수동으로 또는 루프 등으로 입력해야합니다.

그러나 "방법 b"로 수행하면 수동으로 값을 입력 할 필요가 없습니다.

배열은 배열의 정의에 따라 기본 데이터 유형과 클래스의 객체를 포함 할 수 있습니다. 프리미티브 데이터 유형의 경우 실제 값은 연속 메모리 위치에 저장됩니다. 클래스의 객체의 경우 실제 객체는 힙 세그먼트에 저장됩니다.

1 차원 배열 :
1 차원 배열 선언의 일반적인 형태는

type var-name[];
OR
type[] var-name;

Java에서 배열 인스턴스화

var-name = new type [size];

예를 들어

    int intArray[];    //declaring array
    intArray = new int[20];  // allocating memory to array
    // the below line is equals to line1 + line2
    int[] intArray = new int[20]; // combining both statements in one
     int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
    // accessing the elements of the specified array
    for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + " : "+ intArray[i]);

참조 : https://www.geeksforgeeks.org/arrays-in-java/

영화 클래스 😋의 다른 전체 예제

public class A {

        public static void main(String[] args) {

                class Movie{

                    String movieName;
                    String genre;
                    String movieType;
                    String year;
                    String ageRating;
                    String rating;

                    public Movie(String [] str)
                    {
                        this.movieName = str[0];
                        this.genre = str[1];
                        this.movieType = str[2];
                        this.year = str[3];
                        this.ageRating = str[4];
                        this.rating = str[5];    
                    }

                }

                String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};

                Movie mv = new Movie(movieDetailArr);

                System.out.println("Movie Name: "+ mv.movieName);
                System.out.println("Movie genre: "+ mv.genre);
                System.out.println("Movie type: "+ mv.movieType);
                System.out.println("Movie year: "+ mv.year);
                System.out.println("Movie age : "+ mv.ageRating);
                System.out.println("Movie  rating: "+ mv.rating);


            }

        } 

int[] x=new int[enter the size of array here];

예:

int[] x=new int[10];

또는

int[] x={enter the elements of array here];

예:

int[] x={10,65,40,5,48,31};

int[] SingleDimensionalArray = new int[2]

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