컴퓨터로부터 난수값을 제공받아 출력하는 프로그램
-난수값 : 컴퓨터로부터 불규칙적으로 제공되는 숫자값
-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
*/
'학원 > 복기' 카테고리의 다른 글
0406 - 클래스, 접근 제한자(private, public),캡슐화,메소드 오버로딩, 다향성, VO클래스, 필드/생성자/메소드 선언 (0) | 2023.04.06 |
---|---|
0405 - 객체 중심 프로그래밍(OOP), 메소드 선언 및 호출, return 키워드 (0) | 2023.04.05 |
0403 - For문 추가, 이중for문, While문, do while문, break, continue, Scanner Class (0) | 2023.04.03 |
0331 - 제어문(IF문, Switch문, For문), 전역변수, Debug Perspctive (0) | 2023.04.01 |
0330 - 문자형 리터럴, 논리형 리터럴, 자료형 변환, 연산자 (0) | 2023.03.30 |