TIL - 07. 배열 [230720]
누구나 1등을 꿈꾸게 만드는 로또 복권.
편의점에서 로또 판매 아르바이트를 오래했어서 친근했는데
코딩 내용은 어색하기 짝이 없었다.
기계에서는 자동버튼 누르면 바로 뽑았는데..
자동으로 코드가 읊어지도록 복습해보자
배열(Array)
같은 자료형의 변수를 하나의 묶음으로 다루는 것
배열은 저장된 값마다 인덱스 번호가 0부터 시작하여 설정
특징
- 한 가지 자료형만 저장 가능하다.
- 여러 값을 저장할 수 있다.
- 한 번 크기를 지정하면 변경 불가능하다.
선언과 할당
저장 구조
배열은 참조 변수로 Heap영역에 할당되며 배열 공간의 주소를 저장
배열 공간의 주소를 이용해 인덱스를 참조하는 방식으로 값 처리
초기화
Scanner sc = new Scanner(System.in);
/* 배열 (Array)
* - 같은 자료형의 변수를 하나의 묶음으로 다루는 것
* - 묶여진 변수들은 하나의 배열명으로 불려지고
* 구분은 index를 이용함. (index는 0부터 시작하는 정수)
*
*/
public void ex1() {
// 변수 vs 배열
// 변수 선언
int num;
// Stack 영역에 int 자료형을 저장할 수 있는 공간 4byte를 할당하고
// 그 공간에 num이라는 이름을 부여
// 변수 대입
num = 10;
// 생성된 num이라는 변수 공간에 10을 대입
// 변수 사용
System.out.println("num에 저장된 값 : " + num);
// num이 작성된 자리에 num에 저장된 값을 읽어와서 출력
// -----------------------------------------------------------
// 배열 선언
int[] arr;
// Stack 영역에 int [] (int 배열) 자료형 공간을 4byte 할당하고
// 그 공간에 arr 이라는 이름을 부여
// ** 해당 변수는 참조형으로 주소값만을 저장할 수 있다.
// 배열 할당
arr = new int[3];
// new : "new 연산자"라고 하며
// Heap 메모리 영역에 새로운 공간(배열, 객체)을 할당
// int[3] : int 자료형 변수 3개를 하나의 묶음으로 나타내는 배열
// new int[3] : heap 영역에 int 3칸 짜리 int[]을 생성(할당)
// ** 생성된 int[]에는 시작 주소가 지정된다 !! **
// arr = new int[3];
// (int[]) (int[]) -> 같은 자료형 == 연산 가능
// double[] arr = new int[3]; (X)
// heap 영역에 생성된 int[]의 시작주소를
// stack 영역에 생성된 arr변수에 대입
// -> arr 변수가 int[] 을 참조하게됨
// 그래서 arr을 참조형이라 함.
// 배열 요소 값 대입
// arr은 int[] 참조형 변수이지만
// arr[0]은 int 자료형 변수이기 때문에 정수값을 대입할 수 있다!
arr[0] = 10;
arr[1] = 50;
arr[2] = 1000;
System.out.println("arr 의 주소값? : " + arr);
// 배열 요소 값 읽어오기
System.out.println(arr[0]); // arr이 참조하고 있는 배열의 0번 인덱스 값을 얻어옴.
System.out.println(arr[1]); // arr이 참조하고 있는 배열의 1번 인덱스 값을 얻어옴.
System.out.println(arr[2]); // arr이 참조하고 있는 배열의 2번 인덱스 값을 얻어옴.
}
public void ex2() {
// 배열 선언 및 할당
int[] arr = new int[4];
arr[0] = 100;
arr[1] = 200;
arr[2] = 500;
arr[3] = 1000;
// 배열의 길이 (몇 칸 인가) : 배열명.length
System.out.println("배열의 길이 : " + arr.length);
// 배열과 for문
for(int i = 0; i < arr.length; i++) {
System.out.printf("arr[%d]에 저장된 값 : %d\n", i, arr[i]);
}
입력받고 평균 구하기
public void ex3() {
// 5명의 키(cm)를 입력받고 평균 구하기
// 1번 키 입력 : 170.5
// 2번 키 입력 : 165.7
// 3번 키 입력 : 184.3
// 4번 키 입력 : 190.2
// 5번 키 입력 : 174.4
// 평균 : ~
double[] height = new double[5];
// double[] 자료형 참조 변수 height를 stack 영역에 생성하고
// height에 heap 영역에 새로 생성된 double 5 칸 짜리 double[] 의 시작주소를 대입
for(int i = 0; i < height.length; i++) {
System.out.print( (i + 1) + "번 키 입력 : "); // 1 2 3 4 5
height[i] = sc.nextDouble(); // 0 1 2 3 4
// 각 인덱스에 입력받은 값을 대입(초기화)
}
System.out.println();
double sum = 0;
for (int i = 0; i < height.length; i++) {
sum += height[i]; // 배열에 저장된 값을 sum에 누적
}
System.out.printf("평균 : %.2f\n", sum / height.length);
}
public void ex4() {
// 입력 받은 인원 수 만큼의 점수를 입력 받아 배열에 저장
// 입력이 완료되면 점수 합계, 평균, 최고점, 최저점 출력
// ex)
// 입력 받을 인원 수 : 4
// 1번 점수 입력 : 100
// 2번 점수 입력 : 80
// 3번 점수 입력 : 50
// 4번 점수 입력 : 60
// 합계 : 290
// 평균 : 72.5
// 최고점 : 100
// 최저점 : 50
System.out.print("입력 받을 인원 수 : ");
int num = sc.nextInt();
// 배열 선언 및 할당
// 할당할 배열의 크기는 입력받은 크기 만큼(input)
int[] score = new int[num];
// 합계 저장용 변수
double sum = 0;
for (int i = 0; i < score.length; i++) {
System.out.printf("%d번 점수 입력 : ", i + 1);
score[i]= sc.nextInt();
sum += score[i];
}
// 최저/최고점 구하기
int max = score[0];
int min = score[0];
// 아래 for문을 이용해서 score 배열에 있는 모든 값과 max, min을 비교
// score[i] 값이 max 보다 크면 max 대입
// score[i] 갑싱 min 보다 작으면 min 대입
for(int i = 0; i < score.length; i++) {
if( score[i] > max) {
max = score[i];
}
if( score[i] < min) {
min = score[i];
}
}
System.out.printf("\n합계 : %.0f\n", sum);
System.out.println("평균 : " + sum / score.length);
System.out.println("최고점 : " + max);
System.out.println("최저점 : " + min);
}배열 선언과 동시에 초기화
public void ex5() {
// 배열 선언과 동시에 초기화
char[] arr = new char[5];
// char[] arr이 참조하는 배열 요소에 A,B,C,D,E 대입하기
for(int i = 0; i < arr.length; i++) {
arr[i] = (char)('A' + i);
// A == 65
// B == 66
// C == 67
}
// ** Arrays 클래스
// -> Java에서 제공하는 배열과 관련된 기능을 모아둔 클래스
// Arrays.toString(배열명) : 모든 요소 값을 출력
int[] arr2 = new int[4];
System.out.println( Arrays.toString(arr) );
System.out.println( Arrays.toString(arr2) );
// 배열 선언과 동시에 ( 할당 및 ) 초기화
char[] arr3 = {'A', 'B', 'C', 'D', 'E'};
// {} (중괄호) 는 배열의 리터럴 표기법
System.out.println( Arrays.toString(arr3) );
}
public void ex6() {
// 점심 메뉴 뽑기 프로그램
String[] arr = {"짜장면", "짬뽕", "라면", "우동", "김밥", "돈가스"};
System.out.println( "오늘 점심 메뉴 : " + arr[ (int)(Math.random() * 6) ] ); // -> 0 1 2 3 4 5
// 0.0 <= x < 1.0
// 0.0 <= x * 6 < 6.0
// 0 <= (int)(x*6) <6
// -> 0 1 2 3 4 5
}
배열을 이용한 검색
public void ex7() {
// 배열을 이용한 검색
// 입력 받은 정수가 배열에 있는지 없는지 확인
// 만약 있다면 몇 번 인덱스에 존재하는지 출력
int[] arr = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
System.out.print("정수 입력 : ");
int input = sc.nextInt();
// 신호를 나타내기 위한 변수
// flag == false : 일치하는 값이 존재하지 않음
// flag == true : 일치하는 값이 존재
boolean flag = false; // 검사 전에는 없다고 가정
// arr 배열 요소 순차(반복) 접근
for (int i = 0; i < arr.length; i++) {
if(arr[i] == input) {
System.out.println(i + "번째 인덱스에 존재");
flag = true; // 일치하는 값이 있으므로 true로 변경
}
}
// flag 상태를 검사
if ( !flag ) { // flag == false
System.out.println("존재하지 않음");
}
}
public void ex8() {
// 입력 받은 값과 일치 값이 있으면 인덱스 번호 출력
// 없으면 "존재하지 않음"
String[] arr = {"사과", "딸기", "바나나", "키위", "멜론", "아보카도"};
System.out.print("과일 입력 : ");
String input = sc.next();
boolean flag = false;
for(int i = 0; i < arr.length; i++) {
if( arr[i].equals(input) ) { // String 비교시 equals() 사용
System.out.println("인덱스 번호 : " + i);
flag = true;
}
}
if( !flag ) {
System.out.println("존재하지 않음");
}
}
public void ex9() {
// 1. 문자열을 입력 받아 한 글자씩 잘라내어 char 배열에 순서대로 저장
// 2. 문자 하나를 입력 받아 일치하는 문자가 char 배열에 몇 개 존재하는지 확인
// 3. 단, 일치하는 문자가 없을 경우 "존재하지 않습니다." 출력
// [사용 해야되는 기술, 지능]
// 1) 배열 검색
// 2) String.length() : 문자열의 길이
// ex) "Hello".length() -> 5
// 3) String.charAt(index) : 문자열에서 특정 index에 위치한 문자 하나를 얻어옴.
// ex) "Hello".charAt(1) -> 'e'
// 01234
// 4) count (숫자 세기)
System.out.print("문자열을 입력하세요 : ");
String input = sc.nextLine(); // 한줄(띄어쓰기 포함) 입력받기
// 1. 문자열을 입력 받아 한 글자씩 잘라내어 char 배열에 순서대로 저장
char[] arr = new char[input.length()];
for (int i = 0; i < input.length(); i++) {
arr[i] = input.charAt(i);
// arr[i] 에 입력받은 문자열 중 i번째 문자를 대입
}
System.out.println( Arrays.toString(arr) );
System.out.print("문자 하나를 입력하세요 : ");
char ch = sc.next().charAt(0);
int count = 0;
for (int i = 0; i < arr.length; i++) {
if ( arr[i] == ch ) {
// arr[i]값과 검색할 문자 ch가 같은 경우
// -> 카운트
count++;
}
}
if (count>0) {
System.out.println(count + "개 존재합니다.");
} else {
System.out.println("존재하지 않습니다.");
}
}복사
얕은 복사
깊은 복사
Scanner sc = new Scanner(System.in);
// 얕은 복사 (shallow)
// -> 주소를 복사하여 서로 다른 두 변수가
// 하나의 배열 (또는 객체)을 참조하는 상태를 만드는 복사 방법
public void shallowCopy() {
int[] arr = {1, 2, 3, 4, 5};
// 얕은 복사 진행
int[] copyArr = arr; // 주소만 복사
// 배열 값 변경
System.out.println("변경 전");
System.out.println("arr : " + Arrays.toString(arr));
System.out.println("copyArr : " + Arrays.toString(copyArr));
// 얕은 복사한 배열의 값을 변경해보자
copyArr[2] = 999;
System.out.println("변경 후");
System.out.println("arr : " + Arrays.toString(arr));
System.out.println("copyArr : " + Arrays.toString(copyArr));
}
public void deepCopy() {
int[] arr = {1,2,3,4,5}; // 원본
// 1. for문을 이용한 깊은 복사
int[] copyArr1 = new int[arr.length]; // 5칸 짜리 배열 생성
for (int i = 0; i < arr.length; i++) {
copyArr1[i] = arr[i];
}
// 2. System.arraycopy(원본배열, 원본 복사 시작 인덱스,
// 복사배열, 복사 배열의 삽입 시작 인덱스, 복사길이);
int[] copyArr2 = new int[arr.length];
System.arraycopy(arr, 0, copyArr2, 0, arr.length);
// 3. 복사할 배열 참조 변수 = Arrays.copyOf(원본배열, 복사길이);
int[] copyArr3 = Arrays.copyOf(arr, arr.length);
// 값 변경 후 확인
copyArr1[4] = 0;
copyArr2[4] = 999;
copyArr3[4] = 5000;
System.out.println("arr : " + Arrays.toString(arr));
System.out.println("copyArr1 : " + Arrays.toString(copyArr1));
System.out.println("copyArr2 : " + Arrays.toString(copyArr2));
System.out.println("copyArr3 : " + Arrays.toString(copyArr3));
}로또
// 배열을 이용한 중복 데이터 제거 + 정렬
public void createLottoNumber() {
// 1. 1 ~ 45 사이 중복되지 않는 난수 6개 생성
// 2. 생성된 난수가 오름차순으로 정렬
// 1) 정수 6개를 저장할 배열 선언 및 할당
int[] lotto = new int[6];
// 2) 생성된 배열을 처음부터 끝까지 순차 접근하는 for문 작성
for (int i = 0; i < lotto.length; i++) {
// 3) 1 ~ 45 사이 난수 생성
int random = (int)(Math.random() * 45 + 1);
// 0.0 <= x < 1.0
// 1 <= x * 45 + 1 < 46
// 1 <= (int)(x*45+1) < 46
// 4) 생성된 난수를 순서대로 배열 요소에 대입
lotto[i] = random;
// 5) 중복 검사를 위한 for문 작성
for (int x = 0; x < i; x++) {
// 6) 현재 생성된 난수와 같은 수가
// 앞쪽 요소에 있는지 검사
if(random == lotto[x]) {
i -- ;
// i가 1씩 증가할 때마다 난수가 하나 생성된다.
// -> 중복 값이 있으므로 난수를 새로 하나 더 생성해야된다.
// --> i는 기본적으로 0~5까지 6회 반복되지만
// i 값을 인위적으로 1 감소시켜서 총 7회 반복되는 모양을 만든 것.
break;
// 앞쪽에서 중복 데이터를 발견하면
// 남은 값을 비교할 필요 없다.
// -> 효율 향상을 위해서 검사하는 for문을 종료
}
}
}
// 7) 오름차순 정렬
// -> 선택, 삽입, 버블, 퀵 등등
// --> 자바가 정렬 방법을 미리 만들어서 제공하고 있음.
// Arrays.sort(배열명); : 배열 내 값들이 오름차순으로 정렬됨.
Arrays.sort(lotto);
// 결과 출력
System.out.println("로또 번호 : " + Arrays.toString(lotto));
}
초보자