6Day - MathRandom / Lotto / RpaGane / Array /DoubleArray

MathRandom ( 로또 번호)

// 컴퓨터로부터 난수값을 제공받아 출력하는 프로그램 작성
// 난수값 - 컴퓨터로부터 불규칙적으로 제공되는 숫자값

	// Math 클래스
        // 수학 관련 기능을 제공하는 클래스

        // Math.random() - 0.0 보다 크거나 같고 1.0 보다 작은 실수 난수값을 반환하는 메소드
        // 0.0 <= 난수값 < 1.0

for (int i = 1; i <= 5 ; i++) {
            System.out.println(i + "번째 실수 난수 값 = " + Math.random());

        }
        System.out.println("---------------------------------------------");

        for(int i = 1; i <= 5; i++) {
            //(int)(Math.random()*100) >> 0 <= 난수값 < 100 = 0 ~ 99
            System.out.println(i+"번째 정수 난수값 = "+(int)(Math.random()*100));
        }

        System.out.println("---------------------------------------------");

        for(int i = 1; i <= 6; i++) {
            //(int)(Math.random()*45)+1 >> 1 <= 난수값 < 46 = 1 ~ 45
            System.out.println(i+"번째 정수 난수값 = "+((int)(Math.random()*45)+1));

        }
    }
}

// 출력값 실행할때마다 다름
1번째 실수 난수 값 = 0.4793959025749822
2번째 실수 난수 값 = 0.8925781729886614
3번째 실수 난수 값 = 0.942238888662992
4번째 실수 난수 값 = 0.34297817528060115
5번째 실수 난수 값 = 0.0963145074078634
---------------------------------------------
1번째 정수 난수값 = 98
2번째 정수 난수값 = 86
3번째 정수 난수값 = 53
4번째 정수 난수값 = 79
5번째 정수 난수값 = 44
---------------------------------------------
1번째 정수 난수값 = 1
2번째 정수 난수값 = 36
3번째 정수 난수값 = 14
4번째 정수 난수값 = 26
5번째 정수 난수값 = 34
6번째 정수 난수값 = 9

 

---

Lotto

// 1 ~ 45 범위의 정수형 난수값을 6개 제공받아 출력하는 프로그램 작성
// > 6개의 난수값은 서로 중복되지 않도록 작성하며 오름차순 정렬하여 출력

// 6개의 정수 난수값을 저장하기위한 배열 생성
        int[] lotto = new int[6];

        // 1 ~ 45 범위의 정수난수를 6개 제공받아 배열 요소에 차례대로 저장
        for (int i = 0; i < lotto.length; i++) { // 새로운 난수를 저장할 배열 요소의 표현한 첨자의 반복
            // 요소에 저장된 새로운 난수값을 기존 요소의 난수값과 모두 비교하여 같은 값이
            // 있는 경우 반복문이 이용아형 새로운 난수값을 다시 제공받아 저장
            // > 새로운 난수값이 기존의 모든 난수값과 다른 경우 반복문 종료

            while (true) {
                // 1 ~ 45 범위의 정수난수를 제공받아 배열 요소에 저장
                lotto[i] = (int) (Math.random() * 45) + 1;

                // 중복상태를 저장하기 위한 변수 - / true 중복 / false 미중복/
                boolean result = false;

                for (int j = 0; j < i ; j++) { // 기존 요소에 저장된 난수값을 표현하기 위한 반복
                    if (lotto[i] == lotto[j]) {
                        result = true;
                        break;
                    }
                }

                // 새로운 난수값이 기준 난수값과 중복되지 않는 경우 while 구문 종료
                if (!result) break;

            }
        }
        // 배열의 모든 요소값을 서로 비교하여 오름차순 정렬되도록 배열 요소값을 바꾸어 저장
        // > 선택 정렬 알고리즘 (Selection Sort Algorithm)을 사용하여 오름차순 정렬
        for (int i = 0; i < lotto.length; i++) { // 비교하기 위한 배열 요서의 첨자를 표현하는 반복문 -( 0 ~ 끝-1 )
            for (int j = i + 1; j < lotto.length ; j++) { // 피비교 요소의 첨자를 표현하는 반복문 (비교 +1 ~ 끝)

                // lotto[i] 비교 요소 / lotto[j] 피비교 요소
                if (lotto[i] > lotto[j]) {
                    // 요소에 저장된 값을 서로 바꾸어 저장 -Swap
                    int temp = lotto [i];
                    lotto[i] = lotto[j];
                    lotto[j] = temp;
                }
            }
        }


        // 배열의 모든 요소값 출력
        System.out.print("행운의 숫자 >> ");
        for (int number : lotto ) {
            System.out.print(number + " ");
        }
        System.out.println();
            
행운의 숫자 >> 1 19 20 30 31 33

---

 

RpaGame (가위바위보 게임)

// 가위바위보 게임 프로그램 작성
// >> 컴퓨터 (난수값)과 사용자 (키보드 입력값)의 가위바위보 대결

// > 사용자가 이길 경우 대결을 반복 실행하며 질 경우 대결 종료
// > 대결 종료 후 사용자의 승리 횟수 출력

import java.sql.SQLOutput;
import java.util.Scanner;
public class RpaGameApp {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 사용자 승리횟수를 저장하기 위한 변수
        int count = 0;

        // 가위바위보 대결 - 반복 처리
        while (true) {
            // 컴퓨터에게 가위바위보 중 하나를 제공받아 저장
            // > 1: 가위 / 2: 바위 / 3: 보
            // 1 ~ 3 범위의 정수값을 난수로 제공받아 저장
            int computer = (int) (Math.random()*3 ) +1;

            // 사용자에게 가위바위보 중 하나를 키보드로 입력받아 저장
            // > 입력값이 1 ~ 3 범위의 정수값이 아닌경우 에러메시지 출력후 재입력
            int user;
            while (true) {
                System.out.print("가위바위보 [1: 가위 / 2: 바위 / 3: 보] >> ");
                user = scanner.nextInt();
                if (user >= 1 && user <= 3) break; // 정상적인 값이 입력된 경우 반복문 종료
                System.out.println("[에러] 가위 / 바위/ 보 중 하나를 선택하여 입력해 주세요");
            }

            // 컴퓨터와 사용자의 가위바위보 출력
            System.out.print("[입력] 컴퓨터 >> ");
            switch (computer) {
                case 1:
                    System.out.print("가위");
                    break;
                case 2:
                    System.out.println("바위");
                    break;
                case 3:
                    System.out.println("보");
                    break;
            }

            System.out.print("[사용자] >> ");
            switch (user) {
                case 1:
                    System.out.print("가위");
                    break;
                case 2:
                    System.out.println("바위");
                    break;
                case 3:
                    System.out.println("보");
                    break;
            }
            System.out.println();

            // 컴퓨터와 사용자의 가위바위보 대결의 승패를 판단하여 결과 출력
            if (computer == user) {
                System.out.println("[결과] 컴퓨터와 사용자가 서로 비겼습니다.");

            } else if (computer == 1 && user == 2 || computer ==2 && user ==3 || computer ==3 && user ==1) { // 사용자가 이긴것
                System.out.println("[결과] 사용자가 컴퓨터에게 이겼습니다.");
                count++; // 승리횟수 1증가
            } else {
                System.out.println("[결과] 사용자가 컴퓨터에게 졌습니다.");
                break; // 대결종료 > 반복문 종료
            }
            System.out.println();
        }

        System.out.println("--------------------------------");
        // 승리 횟수 출력
        if (count == 0) {
            System.out.println("[메세지] 사용자가 컴퓨터에게 한번도 이기지 못했습니다.");
        } else  {
            System.out.println("[메세지] 사용자가 컴퓨터에게"+ count +"번을 연속적으로 이겼습니다.");
        }

        scanner.close();
    }
}

// 출력값 실행할때마다 다름
가위바위보 [1: 가위 / 2: 바위 / 3: 보] >> 2
[입력] 컴퓨터 >> 보
[사용자] >> 바위

[결과] 사용자가 컴퓨터에게 졌습니다.
--------------------------------
[메세지] 사용자가 컴퓨터에게 한번도 이기지 못했습니다.

 

---

혼자공부하는자바 166p

 

Array

배열 - 177p

/ Java 자료형 : 원시형 (PrimitiveType)과 참조형 (ReferenceType)
// > 원시형 - 값을 표현하기위한 자료형 - byte / short / int / long / char / float / double / boolean
// > 참조형 - 툭정 대상을 표현하기 위한 자료형 - 배열(Array) / 클래스(Class) / 인터페이스(Interface) / 나열형(Enum)

 

// 참조형 변수 - 참조형으로 생성된 변수 - 특정 대상의 메소리 주소값을 저장하기 위한 변수
// ex) String plzza = "피자";
// > 힙영역에 생성된 배열 또는 객체의 메모리 주소를 저장하여 접근하기 위한 사용
// > 비교 연산자를 사용하여 참조변수를 비교할 경우, 참조변수의 저장된 메모리 주소 비교
// > 참조변수에 배열 또는 객체를 저장하지 않을 경우 초기값으로 null 저장
// null - 아무것도 없는 걸 표현하기 위한 키워드

// Java 프로그램에서 사용하는 메모리 영역
// > 메소드 영역 (Method Area) / 힙 영역 (Heap Area) / 스택 영역(Stack Area)
// 1. 메소드 영역 : 클래스 파일 (XXX.class) 의 Java 자료형 (클래스, 인터페이스, 나열형)을 읽어 저장
// 2. 힙 영역 : 배열 또는 객체를 저장하기 위한 영역 - new 연산자 이용
// > 메모리에 이름 설정 불가능 - 참조변수에 메모리 주소(HashCode)를 저장하여 접근
// 3. 스택 영역 : 지역변수 (기본형 변수 또는 참조형 변수)를 저장하기 위한 영역 - FILO (First In Last Out)

// 배열 (Array) : 같은 자료형의 값을 여러 개 저장하기 위한 메모리를 할당받기 위해 사용하는 자료형
// > 일괄처리를 목적으로 사용하는 자료형 - 배열의 사용 목적
// > 1차원 배열과 다차원 배열(2차원 배열, 3차원 배열)로 구분

// > 1차원 배열 - 다수의 값을 저장히기 위한 자료형, 다차원 배열 - 다수의 배열을 저장하기 위한

// 1차원 배열을 생성하여 참조변수에 생성된 배열의 메모리 주소(HashCode)를 저장
// 형식) 자료형[] 참조변수 = new 자료형[갯수];
// > new 자료형 [갯수] - 자료형의 값을 갯수만큼 저장 가능한 메모리 할당 - 1차원 배열
// > 자료형[] 참조변수 - 1차원 배열의 메모리 주소를 저장하기 위한 참조변수 생성
// > "자료형 참조변수[]" 형식으로 참조변수 생성 가능
// 1차원 배열에서 값을 저장하기위한 메모리 공간을 요소 (Element)로 표현
// > 배열의 요소는 첨자 (Index : 0 부터 1씩 증가되는 정수값)를 이용하여 구분
// > 생성된 배열의 요소에는 기본값(숫자형 : 0 / 논리형 : false / 참조형 : null)이 자동저장

int[] num = new int [3];
    double[] don = new double [4];

    // 참조변수에 저장된 값을 출력할 경우 "자료형 @ 메모리주소" 형식의 문자열로 변환되어 출력
        System.out.println("num = " + num);

        System.out.println("------------------------------------------------");
        // 참조변수와 배열의 요소를 구분하는 첨자를 사용하여 배열 요소에 접근 가능
        // 형식 ) 참조변수[첨자] - 배열의 요소를 표현하는 방법

        System.out.println("num[0] = " + num [0]);
        System.out.println("num[1] = " + num [1]);
        System.out.println("num[2] = " + num [2]);
//        System.out.println("num[3] = " + num [3]); // ArrayIndex ~~ 오류뜸
        // 예외가 발생된 경우 프로그램 강제 종료
        
num = [I@61dc03ce

        // 참조변수.lenght : 배열 요소의 갯수를 제공하는 표현식
        System.out.println("num.lenght = " + num.length);
        
num[0] = 0
num[1] = 0
num[2] = 0

int index = 0;
        // 배열 요소를 구분하는 첨자는 변수 또는 연산식 사용하여 표현 가능
        num [index] = 10;
        num [index + 1] = -20;
        num [index + 2] = 30;

        // for 구문을 사용하여 배열 요소에 대한 일괄처리
        // > for 구문의 초기식/ 조건식/ 증감식 에서 사용하는 변수를 첨자로 표현하여 일괄처리
        // > 입력, 계산, 출력에 대한 일관처리에 사용
        for (int i = 0; i < 3; i++){
            System.out.println("num[" + i + "] = " + num[i]);
        }
        
num.lenght = 3

 

        // 배열 생성시 배열 요소의 기본값 대신 원하는 초기값 저장 가능
        // 형식) 자료형[] 참조변수 = new 자료형[*여기에 갯수 쓰면X*] {초기값,초기값, ...};
        // > 나열된 초기값의 갯수만큼 배열에 요소의 갯수를 가지고 있는 배열 생성

        int[] su1 = new int[] {10, 20, 30};
        for (int i = 0; i < su1.length; i++) {
            System.out.println("su1 [" + i + "] =" + su1[i]);
        }

num[0] = 10
num[1] = -20
num[2] = 30

 

// 블럭내부에 값을 나열하여 배열 생성 가능
        // 형식 ) 자료형[] 참조변수 = {초기값, 초기값, ...};
        int[] su2 = {10, 20, 30};

        // Java에서는 배열을 일괄처리하기 위해 향상된 for구문 제공
        // 형식) for(자료형 변수명: 참조변수) { 명령; ...}
        // > 참조변수에 저장된 배열의 요소값을 커서(cursor)를 사용하여 차례대로 하나씩
        // 제공받아 변수에 저장하여 일괄처리하는 반복문
        // > 배열에서 얻어올 요소값이 없는 경우 반복문 종료
        // > 계산, 출력에 대한 일괄처리에 사용

        for (int temp : su2) {
            System.out.print(temp + "\t");
        }
        
10	20	30

 

int[] array = {54, 70, 64, 87, 96, 21, 65, 76 ,11 , 34, 56, 41, 77, 80};

        // 배열의 모든 요소값에 대한 합계를 계산하여 출력하는 프로그램 작성
        int tot = 0;

        for (int i = 0; i < array.length; i++) {
            tot += array[i];

        }
        
합계 = 832

 

// 배열 요소값이 30 ~ 60 범위의 정수값이 저장된 요소의 갯수를 계산하여 출력하는 프로그램

        int count = 0;
        for (int element : array) {
            if (element >= 30 && element <= 60) {
                count++;
            }
        }
        System.out.println("30 ~ 60 범위의 요소의 갯수 = " + count);
        
        
30 ~ 60 범위의 요소의 갯수 = 4

 

---

DoubleArray

import java.util.Enumeration;

// 2차원 배열 : 1차원 배열의 모임
public class DoubleArrayApp {
    public static void main(String[] args) {
        // 형식) 자료형 [] [] 참조변수 = new 자료형 [행갯수] [열갯수];
        // > 행 갯수: 2차원 배열에 생성되는 1차원 배열의 갯수
        // > 열 갯수 : 1차원 배열에 생서오디는 요소의 갯수
        int[][] num = new int[2][3];

        System.out.println("num = " + num);
        System.out.println("num[0] = " + num[0]);
        System.out.println("num[1] = " + num[1]);
        
      
num = [[I@61dc03ce
num[0] = [I@2cb4c3ab
num[1] = [I@13c78c0b

 

// 2차원 배열에서는 값이 저장된 요소에 접근하기 위해 첨자를 2개 사용
        System.out.println("num[0][0] = " + num[0][0]);
        System.out.println("num[0][1] = " + num[0][1]);
        System.out.println("num[0][2] = " + num[0][2]);

        System.out.println("num[1][0] = " + num[1][0]);
        System.out.println("num[1][1] = " + num[1][1]);
        System.out.println("num[1][2] = " + num[1][2]);
        
        
num[0][0] = 0
num[0][1] = 0
num[0][2] = 0
num[1][0] = 0
num[1][1] = 0
num[1][2] = 0

 

        System.out.println("num.length = " + num.length);
        System.out.println("num[0].length = " + num[0].length);
        System.out.println("num[1].lenght = " + num[1].length);
        
num.length = 2
num[0].length = 3
num[1].lenght = 3

 

for (int i = 0; i < num.length; i++) { // 1차원 배열(행)을 일괄처리 하기 위한 반복문 - 행을 표현하는 첨자
            for (int j = 0; j < num[i].length; j++) { // 요소(열)를 일괄처리 하기 위한 반복문
                System.out.println(num[i][j] + "\t");
            }
            System.out.println();
        }
        
0	
0	
0	

0	
0	
0

// int[][] su = new int[][] {{10,20,30} , {40,50,60} , {70,80,90}};
        int[][] su = {{10,20,30},{40,50,60}, {70,80,90}};

        for (int [] array : su) {
            for (int temp : array) {
                System.out.print(temp + "\t");
            }
            System.out.println();
        }
        
10	20	30	
40	50	60	
70	80	90

 

// 1차원 배열의 요소의 갯수가 정해져 있지않은 2차원 배열선언
        // > 1차원 배열의 메모리 주소를 저장하는 참조요소만 생성되고 1차원 배열은 미생성
        // > 2차원 배열의 참조요소는 null 저장

        int[][] value = new int[3][];

        System.out.println("value = " + value);
        System.out.println("value = [0]" + value[0]);
        System.out.println("value = [1]" + value[1]);
        System.out.println("value = [2]" + value[2]);
        
        
value = [[I@5056dfcb
value = [0]null
value = [1]null
value = [2]null

 

// 2차원 배열의 참조요소에 1차원 배열을 생성하여 메모리 주소 저장
        // > 1차원 배열의 요소의 갯수가 다르게 생성하여 저장 가능 - 가변배열
        value[0] = new int[3];
        value[1] = new int[2];
        value[2] = new int[4];

        System.out.println("value[0] = " + value[0]);
        System.out.println("value[1] = " + value[1]);
        System.out.println("value[2] = " + value[2]);
        
        
value[0] = [I@6574b225
value[1] = [I@2669b199
value[2] = [I@2344fc66

 

 

// Java는 다차원 배열을 가변배열로 선언 가능
        int[][] array = {{10,20,30}, {40,50}, {60,70,80,90}};

        for (int[] arr : array) {
            for (int temp : arr) {
                System.out.print(temp + "\t");
            }
            System.out.println();
        }

10	20	30	
40	50	
60	70	80	90