# 1차원 배열

## 1차원 배열

1차원 배열은 **변수들을 한 줄로 모아 놓은 형태의 배열**을 말한다. **같은 종류의 데이터 여러 개를 저장**하기 위해 사용하며 1차원 배열을 사용하는 경우는 다음과 같은 데이터를 저장할 때이다.

* 반 학생 10명의 시험 점수
* 아시아 국가들의 나라 이름
* 프로그래밍 언어 이름

위 데이터들의 공통점은 같은 형태이며 값이 여러 개라는 것이다. 점수는 int가 여러 개, 나라 이름이나 언어 이름은 String이 여러 개인 데이터 형태이다. int가 여러 개일 경우 배열로 `int[]`라 표현하며, String이 여러 개일 경우 배열로 `String[]`이라 표현한다.

### 1차원 배열의 생성

1차원 배열을 생성하는 방법은 다음과 같다

* 선언 후 생성
* 선언과 동시에 생성
* 선언과 동시에 생성 및 초기화

배열을 만들기 위해서는 반드시 **데이터의 종류와 개수**를 알아야 하며, 한 번 생성된 배열의 크기나 형태는 변할 수 없다. 예시에서는 5개의 정수(10,20,30,40,50)로 데이터를 정한다.

> 선언 후 생성

```java
int[] arr;
arr = new int[5];
```

배열은 `참조형`이며 제어를 위한 `참조변수(Reference)`와 `객체(본체)`로 구분된다. 위의 코드에서 첫 번째 줄은 `참조변수`를 선언하는 코드이며, 두 번째 줄은 `객체`를 생성하고 참조변수에 연결 설정하는 코드이다. 생성 시 개수를 \[] 안에 지정한다.

> 선언과 동시에 생성

```java
int[] arr = new int[5];
```

위의 선언 후 생성 코드를 붙여서 사용할 수 있으며, 특징은 같다.\
`new`로 생성된 데이터들은 초기값을 가지며, int의 초기값은 0이므로 배열에는 각각 0이라는 값이 설정된 상태이다.

> 선언과 동시에 생성 및 초기화

```java
int[] arr = new int[]{10, 20, 30, 40, 50};
```

선언과 동시에 초기화를 수행하는 코드이다. 주의할 사항은 적혀있는 데이터에 의해 개수가 자동 계산되므로 \[] 안에 개수를 적으면 안된다는 것이다.

### 1차원 배열의 형태

```java
int[] arr = new int[5];
```

위의 코드로 생성된 배열은 다음 형태를 띈다.

![](/files/-MeNbnzhJ6ery-cUSVTc)

참조변수는 `stack` 메모리에, 실제 배열은 `heap`메모리에 생성되어 참조변수를 이용하여 제어할 수 있도록 구성된다.

또한 new를 이용하여 신규 생성하며 초기값이 할당되기 때문에 값을 넣지 않았음에도 `int`의 초기값인 0이 설정되어있음을 확인할 수 있다.

```java
int[] arr = new int[]{10, 20, 30, 40, 50};
```

생성과 동시에 초기화를 한 경우에는 자동으로 크기가 계산되며 해당 위치에 값이 설정된다.

![](/files/-MeNbtS7iQNBT4YhwVzu)

### 1차원 배열의 길이

```java
int[] arr = new int[]{10, 20, 30, 40, 50};
```

다음과 같은 배열이 있을 때, 배열이 5칸이라는 것을 눈으로 보면 알 수 있지만 프로그래밍 상에서 확인해야 하는 경우가 발생할 수 있다. 자바에서는 이러한 상황에 대비하여 배열에 자체적으로 배열의 길이(칸수)를 가지고 있는 변수를 준비해두었으며, 다음과 같이 확인할 수 있다.

```
System.out.println("arr 길이 : " + arr.length);
```

그림으로 살펴보면 다음과 같다.

![](/files/-MeNbx-15zz29Vs-Fg17)

### 1차원 배열 공간 접근

```
int[] arr = new int[5];
```

생성된 배열에 접근하기 위해서는 `index`를 사용해야 한다. 배열은 `참조변수`와 `index`를 결합하여 저장소에 접근한다.

```
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
```

주의할 사항은 배열의 위치는 **기준점부터 얼마나 떨어져 있는가**로 정하기 때문에 +0부터 시작한다는 것이다.

![](/files/-MeNbzA5TCMGZ-DV2Lgu)

따라서 다음 코드는 오류를 발생시킨다

```java
arr[5] = 60;//배열 범위 초과
```

출력 역시 마찬가지로 `참조변수`와 `index`를 이용하여 접근한다.

```java
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
```

### 1차원 배열의 반복

배열은 `index`를 이용하여 접근할 수 있으므로 반복을 통해 일부 또는 전체에 대한 접근이 가능하다.

* 배열이 1칸이면 index = 0
* 배열이 2칸이면 index = 0, 1
* 배열이 3칸이면 index = 0, 1, 2
* 배열이 4칸이면 index = 0, 1, 2, 3
* 배열이 n칸이면 index = 0, 1, 2, 3, ... , n-1

위의 규칙에 따라 3칸인 배열을 만들고 출력 반복문을 만들면 다음과 같다.

```java
int[] arr = new int[3];
for(int i=0; i<3; i++){
    System.out.println(arr[i]);
}
```

칸 수가 변하면 고쳐야 할 곳이 두 군데이기 때문에 수정하기 쉽도록 다음과 같이 바꿀 수 있다.

```java
int size = 3;
int[] arr = new int[size];
for(int i=0; i<size; i++){
    System.out.println(arr[i]);
}
```

또는 앞서 배운 `length` 속성을 사용하여 설정할 수도 있다.

```java
int[] arr = new int[3];
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}
```

기본적으로 내장된 속성인 `length`를 사용하면 변수 추가 없이 전체에 접근하는 반복문을 구성할 수 있다.

### 데모 1 : 배열에 10,20,30,40,50 저장

```java
public class ArrayExample01 {
    public static void main(String[] args){
        int[] data = new int[5];
        
        for(int i=0; i<data.length; i++){
            data[i] = (i+1) * 10;
        }
        
        for(int i=0; i<data.length; i++){
            System.out.println("data["+i+"] = "+data[i]);
        }
    }
}
```

### 데모 2 : 배열에 랜덤 주사위값 5개 저장

```java
import java.util.Random;
public class ArrayExample02 {
    public static void main(String[] args){
        Random r = new Random();
        
        int[] data = new int[5];
        
        for(int i=0; i<data.length; i++){
            data[i] = r.nextInt(6) + 1;
        }
        
        for(int i=0; i<data.length; i++){
            System.out.println(data[i]);
        }
    }
}
```

배열은 일괄 처리가 목적이므로 **단위 작업별로 코드가 작성**되어야 한다. 즉, `설정→출력→설정→출력`이 아니라 `설정→설정→출력→출력`이 되어야 한다는 것이다. 이해를 돕기 위해 아래 이미지를 첨부해둔다.

![출처 : 생활의 달인 - 라면의 달인 편](https://file3.instiz.net/data/file3/2019/09/11/c/0/0/c006ff32a2a089a9edb6e1a82533020f.gif)

### 데모 3 : 배열에 이름 5개 입력 및 출력

```java
import java.util.Scanner;
public class ArrayExample03 {
    public static void main(String[] args){
        String[] names = new String[5];
        
        Scanner sc = new Scanner(System.in);
        
        for(int i=0; i<names.length; i++){
            names[i] = sc.nextLine();
        }
        
        sc.close();
        
        for(int i=0; i<names.length; i++){
            System.out.println(names[i]);
        }
    }
}
```

### 데모 4 : 배열을 이용한 주사위 눈금 별 횟수 측정

```java
import java.util.Random;
public class ArrayExample04 {
    public static void main(String[] args){
        Random r = new Random();
        
        int[] count = new int[6];
        
        for(int i=1; i<=100; i++){
            int dice = r.nextInt(6) + 1;
            count[dice-1]++;
        }
        
        for(int i=0; i<count.length; i++){
            System.out.println("주사위 "+(i+1)+" : "+count[i]+"번");
        }
    }
}
```

### 데모 5 : 배열을 이용한 로또 번호 빈도 측정

```java
import java.util.Random;
public class ArrayExample05 {
    public static void main(String[] args){
        Random r = new Random();
        
        int[] count = new int[6];
        
        for(int i=1; i<=100; i++){
            int lotto = r.nextInt(45) + 1;
            count[lotto-1]++;
        }
        
        for(int i=0; i<count.length; i++){
            System.out.println("로또 "+(i+1)+" : "+count[i]+"번");
        }
    }
}
```

이 예제의 핵심은 코드가 데모 4번과 크게 다르지 않다는 것이다. 배열은 이처럼 데이터 범위나 개수가 늘어나도 코드를 최소한으로 변경하여 확장할 수 있다는 장점을 가지고 있다.

### 데모 6 : 배열의 데이터 합계 구하기

```java
public class ArrayExample06 {
    public static void main(String[] args){
        int[] score = new int[]{75, 80, 85, 80, 82};
        
        int total = 0;
        for(int i=0; i<score.length; i++){
            total += score[i];
        }
        
        double average = (double)total / score.length;
        
        System.out.println("총점 : "+total+"점");
        System.out.println("평균 : "+average+"점");
    }
}
```

### 데모 7 : 배열 뒤집기

```java
public class ArrayExample07 {
    public static void main(String[] args){
        int[] data = new int[]{10, 20, 30, 40, 50};
        
        System.out.println("변경 전");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]);
            if(i == data.length-1)
                System.out.println();
            else
                System.out.print(",");
        }
        
        for(int i=0, j=data.length-1; i < data.length/2; i++, j--){
            System.out.println("변경 : i="+i+",j="+j);
            int temp = data[i];
            data[i] = data[j];
            data[j] = temp;
        }
        
        System.out.println("변경 후");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]);
            if(i == data.length-1)
                System.out.println();
            else
                System.out.print(",");
        }
    }
}
```

배열의 위치를 활용하여 데이터 교체를 통해 배열을 뒤집는 예제이다. 주의할 점은 배열의 절반만큼만 실행해야 하므로 data.length/2로 범위를 설정했다는 것이며, 이처럼 전체적으로 하는 것이 아니라 일부분만 실행하는 경우도 존재한다. 또한 필요하다면 반복문의 반복수를 2개 이상 설정할 수도 있다.

### 데모 8 : 배열 오른쪽 회전

```java
public class ArrayExample08 {
    public static void main(String[] args){
        int[] data = new int[]{10, 20, 30, 40, 50};
        
        int shift = 1;//회전시킬 칸 수
        
        System.out.println("회전하기 전");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]);
            if(i == data.length-1)
                System.out.println();
            else
                System.out.print(",");
        }
        
        //shift만큼 회전
        for(int i=0; i<shift; i++){
             //1칸 회전
            int temp = data[data.length - 1];
            for(int k=data.length-1; k>0; k--){
                data[k] = data[k-1];
            }
            data[0] = temp;
        }
        
        System.out.println("회전한 뒤");
        for(int i=0; i<data.length; i++){
            System.out.print(data[i]);
            if(i == data.length-1)
                System.out.println();
            else
                System.out.print(",");
        }
    }
}
```

위치를 제어하여 배열을 회전시킬 수도 있다.\
제일 마지막 데이터를 미리 백업한 뒤 오른쪽으로 한칸씩 옮기고 첫 번째 칸에 백업 데이터를 집어넣는 형태의 코드이다.

### 결론

배열을 이용하면 다양한 형태의 대량 데이터에 대한 계산이 가능하다. 각종 유형들을 파악해두고 문제 상황에 적용시키면 문제를 쉽게 풀어낼 수 있다.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.sysout.co.kr/base-language/java/beginner/array/1d-array.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.