[JAVA 17] 자바 고정 배열 ( Array )

■ 배열 ( Array )

1. '같은 타입' 의 데이터를 저장하는 ' 저장소 객체'

생성시 그 크기가 고정된다. (=고정배열) 

2. 선언

tpye 배열변수[];

3. 생성

new tpye[크기];

4. 초기화

배열변수[0] = 데이터1;

배열변수[1] = 데이터2;

  ...

배열변수[n-1] = 데이터n;

class ArrayS1{        // Array Study 01
    
    int as[];                // 1. 선언
 
    ArrayS1(){
        as = new int[5];     // 2. 생성 (5개의 방을 생성한다)
        System.out.println("as[] 배열의 크기는 : " + as.length + " 이다.");
    }
 
    void in(){
        for(int i=0 ; i < as.length ; i++){
            as[i] = i;        // 3. 초기화                
        }                                    // 출력 하고 싶은 값
        System.out.println("저장 완료");      // as[0] = 1;       
    }                                        // as[1] = 2;       
                                             // as[2] = 3;
             // 인간 : 1 , 2 , 3 , 4 , 5      // as[3] = 4;
             // 기계 : 0 , 1 , 2 , 3 , 4      // as[4] = 5;
                                                
    void out(){                // 4. 사용한다.
        for(int i=0 ; i < as.length ; i++){
            System.out.println("as[ " + i + " ] : " + as[i]);
        }
    }
 
    public static void main(String[] args){
        ArrayS1 as1 = new ArrayS1();
        System.out.println("");    
        as1.in();
        System.out.println("");
        as1.out();
    }
}

배열변수.length 가 나타났다고 당황하지 말도록 하자!!

배열에서의 length는 배열의 길이(=크기)를 알려주는 역할을 한다.

유용하게 사용하도록 하자!!

class ArrayS2{
    String strs[];                // 1. 선언
    
    ArrayS2(){
        strs = new String[4];     // 2. 생성
    }
 
    void in(){                
        strs[0] = "봄";           // 3. 초기화
        strs[1] = "여름";
        strs[2] = "가을";
        strs[3] = "겨울";
        System.out.println("<< 저장 완료 >>");
    }
 
    void out(){                   // 4. 사용한다.
        for(int i = 0 ; i < strs.length ; i++){
            System.out.println(" strs[ " + i + " ] : " + strs[i]);
        }
    }
 
    public static void main(String[] args){
        ArrayS2 as2 = new ArrayS2();
        as2.in();
        as2.out();
    }
}

cf) default 초기값

- 기본형 : 0 , 0L , 0.0f , 0.0

- 참조형 : null

class ArrayS3{
    byte as[] = new byte[10];        // 1. 정수형
    short bs[] = new short[10];
    int ds[] = new int[10];
    long es[] = new long[10];
    float fs[] = new float[10];      // 2. 실수형
    double gs[] = new double[10];
    boolean hs[] = new boolean[10];  // 3. 불린형
    String is[] = new String[10];    // 4. 참조형
 
    void out(){
        System.out.println("1. 정수형 배열의 초기값");
        System.out.println(" byte[0]    : " + as[0]);
        System.out.println(" short[0]   : " + bs[0]);
        System.out.println(" int[0]     : " + ds[0]);
        System.out.println(" long[0]    : " + es[0] + "\n");
        System.out.println("2. 실수형 배열의 초기값");
        System.out.println(" float[0]   : " + fs[0]);
        System.out.println(" double[0]  : " + gs[0] + "\n");
        System.out.println("3. boolean형 배열의 초기값");
        System.out.println(" boolean[0] : " + hs[0] + "\n");
        System.out.println("4. 참조형 배열의 초기값");
        System.out.println(" String[0]  : " + is[0]);
    }
 
    public static void main(String[] args){
        new ArrayS3().out();
    }
}

5. 선언 + 생성

type 배열변수[] = new type[n];

    n = 원하는 크기만큼

6. 선언 + 생성 + 초기화

type 배열변수[] = { 데이터1 , 데이터2 , ~ , 데이터n };

※ ' 선언 + 생성 + 초기화 ' 시에는

   ' 선언 ' 을 분리할 수 없다.

class ArrayS4{
    
    int as[] = new int[4];        // (1)선언 + (2)생성
    
    void in1(){
        as[0] = 1;                // (3)초기화
        as[1] = 2;
        as[2] = 3;
        as[3] = 4;
    }
 
    void out1(){
        for(int i=0 ; i < as.length ; i++){
            System.out.println("as[ " + i + " ] : " + as[i]);
        }
    }
 
    int bs[] = {1 , 2 , 3 , 4};    // (1)선언 + (2)생성 + (3)초기화
    
    void out2(){
        for(int i=0 ; i < as.length ; i++){
            System.out.println("bs[ " + i + " ] : " + bs[i]);
        }
    }
 
    public static void main(String[] args){
        ArrayS4 as4 = new ArrayS4();
        as4.in1();
        as4.out1();
        System.out.println("");
        as4.out2();
    }
}

void out1() 과 voud out2() 의 결과는 같다는 것을 알 수 있습니다.

여러분이라면 어떤 로직을 선호 하십니까??

선언과 생성 그리고 초기화를 한번에 할 경우에는

확실하게 로직이 짧아지게 되고 간결하게 보이게 됩니다.

아직 학생이지만, 

저의 입장에서는 로직이 짧고 간결한 경우에는 실력이 더 높다고 느껴지네요.

7. 배열의 형변환

ex) short sA[] = { a , b , (short)c};        byte a; , short b; , int c;

     Object objs[] ={ str , obj };

class ArrayS5{
    byte a = 10;
    short b = 20;
    int c = 30;
       // Short Array
    //short sA1[] = {a , b , c};         // 1번
    short sA2[] = {a , b , (short)c};    // 2번
 
    void use1(){
        for(int i=0 ; i<sA2.length ; i++){
            System.out.println(" Short Array[ " + i + " ] : " + sA2[i]);
        }
    }
 
    public static void main(String[] args){
        ArrayS5 as5 = new ArrayS5();
        as5.use1();
    }
}

[ error : incompatible types: possible lossy conversion from int to short ]

에러 : 공존할 수 없는 타입 : int 에서 short 로 전환시에 파일 정보가 손실될 수 있다.

 (함께 쓸 수 없는 타입) 

 (호환성이 없는 타입)

8. 이차원 배열

일차원 배열을 하나의 데이터로 취급하는 배열

9. 다차원 배열 (=N차원배열)

n-1 차원 배열을 하나의 데이터로 취급하는 배열

class ArrayS6{
    int as[] = {1 , 2};
    int bss[][] = {as , {3} , {4 , 5}};
    int csss[][][] = {bss , {{6}} , {{7 , 8}}};
 
    void out1(){    // 1. 2차원 배열 bss[][] 를 출력해보자!
        try{        // Exception 예외 처리에 대해서는 다음 포스팅에서 설명하겠습니다.
            System.out.println("bss[ 0 ][ 0 ] : " + bss[0][0]);    // [0][0] = 1
            System.out.println("bss[ 0 ][ 1 ] : " + bss[0][1]);    // [0][1] = 2
            System.out.println("bss[ 1 ][ 0 ] : " + bss[1][0]);    // [1][0] = 3 , [1][1] 은 없다.
            System.out.println("bss[ 2 ][ 0 ] : " + bss[2][0]);    // [2][0] = 4
            System.out.println("bss[ 2 ][ 1 ] : " + bss[2][1]);    // [2][1] = 5
        }catch(Exception e){}
    }
 
    void out2(){    // 2. 2차원 배열 bss[][] 를 출력 해보자!(반복문 이용)
        for(int i=0 ; i < bss.length ; i++){
            for(int j=0 ; j < bss[i].length ; j++){
                System.out.println("bss[ " + i + " ][ " + j + " ] : " + bss[i][j]);
            }
        }
    }
 
    void out3(){    // 3. 3차원 배열 csss[][][] 를 출력 해보자!
        for(int i=0 ; i < csss.length ; i++){
            for(int j=0 ; j < csss[i].length ; j++){
                for(int k=0 ; k < csss[i][j].length ; k++){
                    System.out.println("csss[ " + i + " ][ " + j + " ][ " + k + " ] : " + csss[i][j][k]);
                }
            }
        }
    }
 
    public static void main(String[] args){
        ArrayS6 as6 = new ArrayS6();
        as6.out1();
        System.out.println("");
        as6.out2();
        System.out.println("");
        as6.out3();
    }
}

저는 void out1() 처럼 배열의 행과 열을 한번에 알 수 없습니다 ( ; - ; )

이게 void out3() 처럼 3차원 배열 또는 더더욱 많아진 n차원 배열까지 계산 할 수 있으신가요??

그렇다면 정말 대단하다고 생각합니다.

저는 반복문을 돌려서야 확인 할 수 있거든요..