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




자바 배열 선언 종류 (16)

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

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

배열에 값 지정 :

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

배열에서 읽기 :

ClassName variableName = arrayName.get(index);

노트 :

variableNamevariableName 을 조작하면 arrayName 을 조작한다는 의미의 배열에 대한 참조입니다.

for 루프 :

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

for 루프를 사용하면 arrayName 을 편집 할 수 있습니다 (for for conventional 루프).

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

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

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]과 double [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]]

또는,

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

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


지역 변수 타입 추론을 사용하면 타입을 한 번만 지정하면됩니다.

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

또는

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

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

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

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

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

int[] SingleDimensionalArray = new int[2]

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

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

예를 들어 원시 형 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[] 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 개가 있음을 알 수 있으므로 배열의 크기를 암시 적으로 결정할 수 있습니다.


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

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

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

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

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

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[] 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];

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

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

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


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

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

객체의 경우 new Type(..) 사용하여 객체를 초기화하기 위해 null 에 할당하거나 StringInteger 와 같은 클래스는 다음과 같이 처리 될 특별한 경우입니다

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 차원 배열을 만드는 것은 공간면에서 비용이 많이 든다는 점에 유의할 가치가 있습니다. 모든 차원에서 N 을 갖는 M 차원 배열을 만들 때부터 각 배열에 참조가 있고 M 차원에서 (M-1) - 참조의 차원 배열. 총 크기는 다음과 같습니다.

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




declare