쭈쌤
쭈쌤 Hello World

[Java] 1차 배열

크리에이티브 커먼즈 라이선스 ITPAPER(호쌤,쭈쌤)에 의해 작성된 ≪[Java] 1차 배열≫은(는) 크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 4.0 국제 라이선스에 따라 이용할 수 있습니다.
이 라이선스의 범위 이외의 이용허락을 얻기 위해서는 leekh4232@gmail.com으로 문의하십시오.

[Java] 1차 배열

학급의 성적표를 보고 각 학생별로 총점과 평균을 구해야 한다고 생각해 봅시다.

성적표가 아래와 같다면 3명씩 3과목이므로 총 9개의 변수가 필요할 것 입니다.

  국어 영어 수학
철수 92 81 76
영희 72 95 84
민혁 80 86 98
1
2
3
4
5
6
int kor1 = 92;
int kor2 = 71;
int kor3 = 80;
// ... 생략 ...
int math2 = 84;
int math3 = 98;

만약 30명의 학생에 대한 20과목에 대한 점수라고 가정한다면 프로그램은 좀 더 복잡해 지고 더 많은 변수를 소스코드상에 선언,할당 해야 할 것 입니다.

#01. 배열

같은 종류의 데이터를 그룹화 한 형태.

1) 배열 만들기

배열의 선언

데이터 타입 뒤에 배열임을 의미하는 []를 명시한다.

1
    int[] a;

배열의 할당

값을 대입하는 것이 아니라 배열의 칸을 결정하는 것임에 유의한다.

new 예약어 뒤에 데이터 타입을 다시 한번 명시하고 배열의 칸 수를 []를 사용하여 지정한다.

1
    a = new int[3];

선언과 할당의 통합

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

2) 배열의 활용

값 저장하기

크기가 결정된 배열은 0부터 시작되는 일련번호를 부여받는다. 이를 배열의 인덱스라고 한다.

값을 저장하기 위해서는 배열변수 이름 뒤에 [0] 형식으로 인덱스 번호를 지정하고 대입한다.

1
2
3
a[0] = 10;  // 인덱스가 0인 칸에 10을 대입
a[1] = 20;  // 인덱스가 1인 칸에 20을 대입
a[2] = 30;  // 인덱스가 2인 칸에 30을 대입

즉, 아래와 같이 구성된다고 생각할 수 있다.

0 1 2
10 20 30

위와 같이 행의 수가 1줄로만 구성되어 있는 형태의 배열을 1차 배열 이라고 한다.

배열에 저장된 값 사용하기

인덱스 번호를 사용한다는 점을 제외하고는 일반 변수의 사용과 동일하다.

a) 다른 변수에 복사하기
1
int k = a[0];   // k에 10이 복사됨
b) 출력하기
1
System.out.println(a[1]);   // 20이 출력됨
c) 연산하기
1
a[2] = a[0] * a[1]; // 인덱스가 2인 공간의 값이 200이 됨

선언+할당+값대입을 한 번에 일괄 처리 하기

배열을 할당할 때 사이즈를 지정하지 않고 중괄호 {}를 열어서 배열의 원소값들을 직접 나열한다.

1
int[] a = new int[] { 10, 20, 30, 40 };

이 때 new int[]는 생략할 수 있다.

1
int[] a = { 10, 20, 30, 40 };

3) 배열의 크기

배열이름.length는 배열의 칸 수를 반환한다.

1
2
int[] a = new int[5];
System.out.println(a.length);   // 5가 출력됨

배열의 인덱스는 항상 0부터 크기-1까지 1씩 증가하면서 존재한다.

4) 반복문을 통한 활용

인덱스가 0부터 크기-1까지 1씩 증가한다는 특성을 활용하여 for문과 함께 사용하면 배열의 모든 원소에 대한 일괄 처리가 가능하다.

ArrayTest.java

1
2
3
4
5
6
7
8
9
10
public class Array1 {
    public static void main(String[] args) {
        int[] a = new int[4];

        for (int i=0; i<a.length; i++) {
            a[i] = i * 10;
            System.out.println(a[i]);
        }
    }
}
출력결과
1
2
3
4
0
10
20
30

ArraySum.java

배열의 모든 원소에 대한 합 구하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ArraySum {
    public static void main(String[] args) {
        int[] data = { 10, 20, 30, 40, 50 };

        // 총 합을 구할 때는 항상 누적 합산을 수행할 변수를 0으로 초기화 해 놓고 반복을 수행해야 한다.
        int sum = 0;

        // 배열의 모든 원소에 대한 반복문 구성
        for (int i = 0; i < data.length; i++) {
            // i번째 원소를 sum에 누적 합산
            sum += data[i];
        }

        System.out.println(sum);
    }
}
출력결과
1
150

ArrayMax.java

배열의 원소 중에서 가장 큰 값 구하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ArrayMax {
    public static void main(String[] args) {
        // 원소값을 무작위로 갖는 배열
        int[] data = { 5, 2, 7, 9, 2 };

        // 비교를 위한 값 준비
        int max = 0;

        // 배열의 원소 수 만큼 반복
        for (int i = 0; i < data.length; i++) {
            System.out.printf("max=%d, data[%d]=%d\n", max, i, data[i]);

            // max가 data의 i번째보다 작다면 i번째 원소를 max에 복사
            if (max < data[i]) {
                System.out.printf(">> max에 %d를 복사\n", data[i]);
                max = data[i];
            }
        }

        System.out.println("---------");
        System.out.println("최대값 = " + max);
    }
}
출력결과
1
2
3
4
5
6
7
8
9
max=0, data[0]=5
>> max에 5를 복사
max=5, data[1]=2
max=5, data[2]=7
>> max에 7를 복사
max=7, data[3]=9
>> max에 9를 복사
max=9, data[4]=2
최대값 = 9

ArrayConverse.java

배열의 순서를 뒤집기

반복 회수를 구하기 위한 연산
  1. 원소가 5개일 경우 반복 회수 : 2회
    • 5/2를 연산한다. 나머지는 버리게 되므로 2가 된다.
  2. 원소가 6개일 경우 반복 회수 : 3회
    • 6/2를 연산한다.

배열의 길이/2를 구한다.

i번째 원소와 맞교환 하기 위한 반대쪽 원소의 인덱스

배열의길이 - i - 1;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ArrayConverse {
    public static void main(String[] args) {
        int[] data = { 1, 5, 2, 4, 3 };

        for (int i=0; i<data.length/2; i++) {
            // 반대쪽 원소의 인덱스 구하기
            int k = data.length - i - 1;

            // i번째 원소와 k번째 원소 교환
            int tmp = data[i];
            data[i] = data[k];
            data[k] = tmp;
        }

        for (int i=0; i<data.length; i++) {
            System.out.println(data[i]);
        }
    }
}
출력결과
1
2
3
4
5
3
4
2
5
1

ArraySort.java

배열 정렬하기

중첩 반복문이 필요.

부모 반복문은 기준이 되는 위치를 지정한다.

마지막 원소는 비교할 필요가 없으므로 기준위치 i는 0부터 배열길이-1 전 까지만 증가한다.

자식 반복문은 기준 위치와 비교할 값들을 결정한다.

기준 위치 다음 원소부터 마지막 원소까지 순차적으로 비교해야 하므로 비교위치 j는 i+1부터 배열길이전 까지 반복한다.

i 번째 원소와 j번째 원소를 비교하여 교환여부를 결정한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ArraySort {
    public static void main(String[] args) {
        int[] data = { 1, 5, 2, 4, 3 };

        // 비교할 기준을 선정하는 반복처리 --> 0번째부터 길이-1 번째까지
        for (int i=0; i<data.length-1; i++) {
            // 기준과 비교할 위치를 선정하는 반복 --> i+1번째부터 길이까지.
            for (int j=i+1; j<data.length; j++) {
                // i번째와 j번째를 비교하여 교환 여부를 결정
                if (data[i] > data[j]) {
                    int tmp = data[i];
                    data[i] = data[j];
                    data[j] = tmp;
                }
            }
        }

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

#02. 배열 사용시의 주의사항

1) 사이즈가 결정되지 않은 배열은 사용할 수 없다.

ArrayTest1.java

1
2
3
4
5
6
public class ArrayTest1 {
    public static void main(String[] args) {
        int[] a;
        a[0] = 10;
    }
}
결과
1
2
3
4
Test.java:5: error: variable a might not have been initialized
                a[0] = 10;
                ^
1 error

2) 배열은 초기값이 자동으로 할당된다.

배열의 크기만을 결정하고 원소를 대입하지 않은 경우 초기값이 자동으로 할당된다.

  1. 숫자형 - 0으로 초기화
  2. boolean형 - false로 초기화
  3. String형 - null로 초기화

null이라는 개념은 객체라는 단원에서 다시 소개합니다.

ArrayTest2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class ArrayTest2 {
    public static void main(String[] args) {
        // 정수형
        int[] a = new int[2];

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

        // 실수형
        double[] b = new double[3];

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

        // 논리형
        boolean[] c = new boolean[4];

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

        // 문자열
        String[] d = new String[5];

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

출력결과

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a[0]=0
a[1]=0
b[0]=0.0
b[1]=0.0
b[2]=0.0
c[0]=false
c[1]=false
c[2]=false
c[3]=false
d[0]=null
d[1]=null
d[2]=null
d[3]=null
d[4]=null

3) 존재하지 않는 인덱스에 접근할 경우

크기가 3인 배열에 대해 인덱스가 3인 위치에 접근한다면 에러가 발생한다.

이 때 컴파일시에는 아무런 문제가 없고, 컴파일 된 결과물을 실행할 때 에러가 발생한다.

문제가 없는 부분은 정상실행되고 문제가 있는 행을 실행하는 시점에 에러가 발생함

출력결과

1
2
3
4
5
10
20
30
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
        at Test.main(Test.java:9)

크리에이티브 커먼즈 라이선스 ITPAPER(호쌤,쭈쌤)에 의해 작성된 ≪[Java] 1차 배열≫은(는) 크리에이티브 커먼즈 저작자표시-비영리-동일조건변경허락 4.0 국제 라이선스에 따라 이용할 수 있습니다.
이 라이선스의 범위 이외의 이용허락을 얻기 위해서는 leekh4232@gmail.com으로 문의하십시오.

comments powered by Disqus