0404 - 난수 출력, 가위바위보 게임, Java 자료형, Java 메모리 영역, 배열, 향상된 for문, 로또 프로그램, 2차원 배열

컴퓨터로부터 난수값을 제공받아 출력하는 프로그램 

-난수값 : 컴퓨터로부터 불규칙적으로 제공되는 숫자값

-Math 클래스 : 수학 관련 기능을 제공하는 클래스 
-Math.random() : 0.0보다 크거나 같고 1.0보다 작은 실수 난수값을 반환하는 메소드 
 =>  0.0  <=  난수값  <  1.0

실행할 때 마다 난수값이 달라진다

 

 

예시)

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

/*
ex)

1번째 실수 난수값 = 0.4043411414948358
2번째 실수 난수값 = 0.7257453007142685
3번째 실수 난수값 = 0.8418696556869438
4번째 실수 난수값 = 0.7519235610610522
5번째 실수 난수값 = 0.9454519461876755

*/

 

예시) 0 ~ 99 범위의 난수값 출력 

 

(int)(Math.random()*100)>>>  0 <= 난수값 < 100

 //(int)(Math.random()*100) >>  0 <= 난수값 < 100 = 0 ~ 99 범위의 난수값

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

/*
ex)

1번째 정수 난수값 = 12
2번째 정수 난수값 = 67
3번째 정수 난수값 = 58
4번째 정수 난수값 = 91
5번째 정수 난수값 = 57

*/

 

예시) 1 ~ 45 범위의 난수값 출력 

 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));
      }

/*
ex)

1번째 정수 난수값 = 4
2번째 정수 난수값 = 25
3번째 정수 난수값 = 7
4번째 정수 난수값 = 9
5번째 정수 난수값 = 25
6번째 정수 난수값 = 14

*/

 

 

가위바위보 게임 프로그램 

 

import java.util.Scanner;
public class practice {

    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.print("바위"); break;
                case 3: System.out.print("보"); break;
            }

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

            //컴퓨터와 사용자의 가위바위보 대결의 승패를 판단하여 결과 출력
            if(computer == user) {
                System.out.println("[결과]컴퓨터와 사용자가 서로 비겼습니다.");  //and가 or보다 우선순위 높다
            } 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();
    }
}

---

Java 자료형 

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

기본형(원시형) 변수 : 원시형(기본형)으로 생성된 변수 - 값을 저장하기 위한 변수 ex) int num = 100; 
참조형 변수 : 참조형으로 생성된 변수 - 특정 대상의 메모리 주소값을 저장하기 위한 변수 ex) String name = "홍길동";
                   =>힙영역(HeapArea)에 생성된 배열 또는 객체의 메모리 주소를 저장하여 접근하기 위해 사용 
                   => 비교 연산자를 사용하여 참조변수를 비교할 경우 참조변수의 메모리 주소 비교
                   => 참조변수에 배열 또는 객체를 저장하지 않을 경우 초기값으로 null 저장 
                        **null : 아무런 것도 없음을 표현하기 위한 키워드 (약속된 키워드)

 

Java 프로그램에서 사용하는 메모리 영역

=> 메소드 영역(Method Area), 힙 영역(Heap Area), 스택 영역(Stack Area)

1. 메소드 영역 : 클래스 파일(XXX.class)의 클래스, 인터페이스, 나열형을 읽어 저장하는 영역 
2. 힙 영역 : 배열 또는 객체를 저장하기 위한 영역 - new 연산자 이용 
      => 메모리에 이름 설정 불가능 : 참조변수에 객체 또는 배열의 메모리 주소(Hash Code)를 저장하여 접근 
           (메모리에 이름 부여X, 메모리 할당만 받을 수 O. 따라서 참조변수 필요)
3. 스택 영역 : 지역변수(기본형 변수 또는 참조형 변수)를 저장하기 위한 영역 - FILO (First In Last Out)

---

배열

: 같은 자료형의 값을 여러개 저장하기 위한 메모리를 할당받기 위해 사용되는 자료형 

 

=> '일괄처리'를 목적으로 사용하는 자료형 - 배열의 사용 목적 
=> 1차원 배열과 다차원 배열(2차원 배열, 3차원 배열 등)로 구분 
      -> 1차원 배열 : 다수의 값을 저장하기 위한 자료형 / 다차원 배열 : 다수의 배열을 저장하기 위한 자료형

 

-1차원 배열을 생성하여 참조변수에 생성된 배열의 메모리 주소(HashCode)를 저장

형식) 자료형[] 참조변수 = new 자료형[갯수];

=> new 자료형[갯수] : 자료형의 값을 갯수만큼 저장 가능한 메모리 할당 - 1차원 배열 
=> 자료형[] 참조변수 : 1차원 배열의 메모리 주소를 저장하기 위한 참조변수 생성 
    ( 자료형[] -> 배열 자료형)
=> "자료형 참조변수[]" 형식으로도 참조변수 생성 가능 

-1차원 배열에서 값을 저장하기 위한 메모리 공간을 요소(Element)로 표현 

=> 배열의 요소는 첨자(Index : 0부터 1씩 증가되는 정수값)를 이용하여 구분
=> 생성된 배열의 요소에는 기본값(숫자형 : 0, 논리형 : false, 참조형 : null)이 자동 저장 

 

 

정수값 3개 저장할 수 있는 메모리 할당(배열 생성)

 

int[] num = new int[3]; //숫자형이므로, 기본값으로 0이 저장되어 있음

 

-> 참조변수에 저장된 값을 출력할 경우 "자료형@메모리주소" 형식의 문자열로 변환되어 출력 

 

 

참조변수와 배열의 요소를 구분하는 첨자를 사용하여 배열 요소에 접근 가능 
형식) 참조변수[첨자] - 배열의 요소 접근 

 

 

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

//배열의 요소를 구분하는 첨자를 잘못 사용한 경우 ArrayIndexOutOfBoundsException 발생
// => 예외(Exception)이 발생된 경우 프로그램 강제 종료
// System.out.println("num[3] = " + num[3]);

 

참조변수.length : (참조변수가 가리키는) 배열 요소의 갯수를 제공하는 표현식 

 

System.out.println("num.length = " + num.length); //num.length = 3

 

배열 요소를 구분하는 첨자는 변수 또는 연산식 사용 가능 

 

int index = 0;
num[index] = 10;
num[index+1] = 10;
num[index+2] = 10;

 

for 구문을 사용하여 배열 요소에 대한 일괄처리

      => for 구문의 초기식, 조건식, 증감식에서 사용하는 변수를 첨자로 표현하여 일괄처리
      => 입력, 계산, 출력에 대한 일괄처리에 사용 (배열은 반복문을 통해 일괄처리 하는 것을 권장한다)

 

 

int index = 0;
num[index] = 10;
num[index+1] = 10;
num[index+2] = 10;

for(int i = 0; i < num.length ; i++) {
          System.out.println("num[" + i + "] = " + num[i] ); //일괄처리 통해 값을 한꺼번에 출력
      }                                              

/*
num[0] = 10
num[1] = 10
num[2] = 10
*/

 

배열 생성시 배열 요소의 기본값 대신 원하는 초기값 저장 가능

형식1) 자료형[] 참조변수 = new 자료형[]{초기값, 초기값, ... };                    >>  정석 방식(힙에 만들어짐)
                                                              ->[] 안에 갯수 쓰면 안됨
          => 나열된 초기값의 갯수만큼 요소의 갯수를 가지고 있는 배열 생성

 

 

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

/*
su1[0] = 10
su1[1] = 20
su1[2] = 30
*/

 

블럭 내부에 값을 나열하여 배열 생성 가능
형식2) 자료형[] 참조변수 = {초기값, 초기값, ... };                            >> 간편형(메소드 영역에 만들어짐)

 

(형식1과 만들어지는 영역은 다르지만 배열이 만들어 지는건 같음)

 

 

int[] su2 = {10, 20, 30};

 

 

 향상된 for문

Java에서는 배열을 일괄처리하기 위해 '향상된 for 구문' 제공 (배열이 아닌 경우 사용 불가)

형식) for(자료형 변수명 : 참조변수) { 명령; ... }

=> 참조변수에 저장된 배열의 요소값을 커서(cursor)를 사용하여 차례대로 하나씩 제공받아 변수에 저장하여 일괄 처리
=> 배열에서 얻어올 요소값이 없는 경우 반복문 종료
=> 계산, 출력에 대한 일괄처리에 사용 (입력 제외)

+

일반 for문과 다르게 반복에 배열을 이용

배열의 길이로 for문의 반복 횟수가 정해짐

배열이 이미 있는 경우에 사용할 수 있음

 

int[] su2 = {10, 20, 30};
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];
}
System.out.println("합계 = " + tot); //832

 

 

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

 

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

for(int element : array) {
    if(element >= 30 && element <= 60) {
        count++;
    }
}

System.out.println("30~60 범위의 요소의 갯수 = " + count); //4

 

로또 프로그램 

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

 

정렬(Sort) : 값을 차례대로 나열하는 기능 - 오름차순 정렬(Ascending Sort), 내림차순 정렬(Descending Sort)

package basic;

public class LottoApp {
    public static void main(String[] args) {
        //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;

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

                for(int j = 0; j < i ; j++) {//기존 난수값이 저장된 요소의 첨자를 표현하기 위한 반복문 
                    if(lotto[i]==lotto[j]) {
                        result = true;
                        break;
                    }
                }
                if(!result) break; //새로운 난수값이 기존 난수값과 중복되지 않는 경우 while 구문 종료 
            }
        }

        //배열의 모든 요소값을 서로 비교하여 오름차순 정렬되도록 배열 요소값을 바꾸어 저장 
        // => 선택 정렬 알고리즘(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();
    }
}

 

---

2차원 배열

: 1차원 배열의 모임 
형식) 자료형[][] 참조변수 = new 자료형 [행갯수][열갯수];
=> 행갯수 : 2차원 배열에 생성되는 1차열 배열의 갯수
=> 열갯수 : 1차원 배열에 생성되는 요소의 갯수 

 

 

예제) 2행 3열의 2차원 배열 

 

 

int[][] num = new int[2][3]; //2행 3열

System.out.println("num = " + num); //num = [[I@6a5fc7f7 => int 2차원 배열의 메모리 주소 저장되어 있음
System.out.println("num[0] = " + num[0]); //num[0] = [I@3b6eb2ec => int 1차원 배열의 메모리 주소 저장되어 있음
System.out.println("num[1] = " + num[0]); //num[1] = [I@3b6eb2ec => int 1차원 배열의 메모리 주소 저장되어 있음

 

2차원 배열에서는 값이 저장된 요소에 접근하기 위해 첨자를 2개 사용

 

int[][] num = new int[2][3]; 

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

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

 

 

num.length -> 2차원 배열이 가진 1차원 배열의 갯수

int[][] num = new int[2][3]; 

System.out.println("num.length = " + num.length); //2차원 배열이 가진 1차원 배열의 갯수 => 2
System.out.println("num[0].length = " + num[0].length); //3
System.out.println("num[1].length = " + num[1].length); //3

 

 

2차원 배열 다중 for문 

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

/*
0	0	0	
0	0	0	
*/

 

3행 3열 2차원 배열 만들기

//int[][] su = new int[][] {{10,20,30}, {40,50,60}, {70,80,90}}; //3행 3열 2차원 배열
int[][] su = {{10,20,30}, {40,50,60}, {70,80,90}}; //3행 3열 2차원 배열

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]); // null
System.out.println("value[1] = " + value[1]); // null
System.out.println("value[2] = " + value[2]); // null

 

 

2차원 배열의 참조요소의 1차원 배열을 생성하여 메모리 주소 저장
=> 1차원 배열의 요소의 갯수를 다르게 생성하여 저장이 가능 - 가변배열
      가변 배열 사용 이유: 메모리 절약

 

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

value[0] = new int[3]; //행이 정해져 있어도 열은 바꾸어 저장할 수 있다
value[1] = new int[2];
value[2] = new int[4];

System.out.println("value = " + value); //value = [[I@1540e19d
System.out.println("value[0] = " + value[0]); //value[0] = [I@677327b6
System.out.println("value[1] = " + value[1]); //value[1] = [I@14ae5a5
System.out.println("value[2] = " + value[2]); //value[2] = [I@7f31245a

 

 

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	
*/