JAVA 2주차

Organ·2023년 9월 3일
0

JAVA

목록 보기
2/14

2주차 코멘트

지금까지는 나름 수월하게 하고 있다고 생각하는데 앞으로 처음하는게 나오면 잘 따라갈 수 있을지 걱정이 된다. 솔직히 아예 처음하는 사람 입장에서는 따라가기 힘들 것 같다는 생각도 든다. 조금이라도 공부하고 와서 다행이다.

5일차

용자로부터 이름, 국어점수, 영어점수, 수학점수를 입력받아 이름과 총점을 출력하는 프로그램을 구현(014)

실행 예)
이름을 입력하세요 : 정한울
국어 점수 입력 : 90
영어 점수 입력 : 80
수학 점수 입력 : 70

====[결과]====
이름 : 정한울
총점 : 240
계속하려면 아무 키나 누르세요

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test014
{
	public static void main(String[] args) throws IOException
	{
/*		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int kor = 0, eng = 0, mat = 0, total = 0;
		String name;

		System.out.print("이름을 입력하세요 : ");	
		name = br.readLine();

		System.out.print("국어 점수 입력 : ");
		kor = Integer.parseInt(br.readLine());

		System.out.print("영어 점수 입력 : ");
		eng = Integer.parseInt(br.readLine());

		System.out.print("수학 점수 입력 : ");
		mat = Integer.parseInt(br.readLine());

		total = kor + eng + mat;

		System.out.println();


		System.out.println("====[결과]====");
		System.out.println("이름 : " + name);
		System.out.println("총점 : " + total);
*/
// 결과 확인
/*
이름을 입력하세요 : 정한울
국어 점수 입력 : 90
영어 점수 입력 : 80
수학 점수 입력 : 70

====[결과]====
이름 : 정한울
총점 : 240
계속하려면 아무 키나 누르십시오 . . .
*/
		// 주요 변수 선언

		// BufferedReader 인스턴스 생성
		// BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 아래 두 줄과 같다. isr에 대입하면 아래 두 줄과 정확하게 같다.

		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(isr);

		String strName;			// 이름 변수
		int nKor, nEng, nMat;	// 국어점수, 영어점수, 수학점수 변수
		int nTot;				// 총점 변수
		String strTemp;			// 문자열 임시 저장 변수

		// 연산 및 처리
		// - 사용자에게 안내 메세지 출력(이름 입력 안내)
		System.out.print("이름을 입력하세요 : ");

		// - 사용자가 입력한 값(외부 데이터)을 변수에 담아내기
		strName = br.readLine();
		
		// - 사용자에게 안내 메세지 출력(국어점수 입력 안내)
		System.out.print("국어 점수 입력 : ");

		// - 사용자가 입력한 값(외부 데이터)을 변수에 담아내기
		strTemp = br.readLine();

		// - 담아낸 데이터를 변환한 후 필요한 변수에 다시 담기
		nKor = Integer.parseInt(strTemp);

		// - 사용자에게 안내 메세지 출력(영어점수 입력 안내)
		System.out.print("영어 점수 입력 : ");

		// - 사용자가 입력한 값(외부 데이터)을 변수에 담아내기
		strTemp = br.readLine();

		// - 담아낸 데이터를 변환한 후 필요한 변수에 담아내기
		nEng = Integer.parseInt(strTemp);

		// - 사용자에게 안내 메세지 출력(수학점수 입력 안내)
		System.out.print("수학 점수 입력 : ");

		// - 사용자가 입력한 값(외부 데이터)을 변수에 담아내기
		strTemp = br.readLine();

		// - 담아낸 데이터를 변환한 후 필요한 변수에 담아내기
		nMat = Integer.parseInt(strTemp);

		// - 각 점수 변수에 담겨있는 데이터(사용자가 입력한 데이터)들을
		//	 종합하여 총점을 산출하고 그 결과를 총점 변수에 담아내기
		nTot = nKor + nEng + nMat;

		// 결과 출력
		System.out.println("\n====[결과]====");
		System.out.println("이름 : " + strName);
		System.out.println("총점 : " + nTot);

	}
}

자바의 기본 입출력 : System.in.read()(015)

System.in.read() 메소드는 (입력 대기열로부터) 한 문자만 가져온다.
단. 입력받은 하나의 문자를 문자 그대로 가져오는 것이 아니라
아스키 코드 값(정수 형태)으로 반환하게 된다.

// 실행 예)
// 한 문자 입력		 : A
// 한 자리 정수 입력 : 9

// >> 입력한 문자 : A
// >> 입력한 정수 : 9

import java.io.IOException;

public class Test015
{
	public static void main(String args[]) throws IOException
	{
/*
		// 주요 변수 선언
		char ch;		//-- 문자


		// 연산 및 처리
		System.out.print("문자 하나 입력하세요 : ");	// A
		ch = (char)System.in.read();					// 65
		//			--------------
		//				 65

		// 결과 출력
		System.out.println(ch);
*/
/*
		char ch;
		char num;

		System.out.print("한 문자 입력 : ");
		ch = (char)System.in.read();

		System.in.skip(2); //\r \n 2개가 엔터이므로 2개를 skip해준다.

		System.out.print("한 자리 정수 입력 : ");
		num = (char)System.in.read();


		System.out.println();
		System.out.println("입력한 문자 : " + ch);
		System.out.println("입력한 정수 : " + num);
*/

		char ch;
		int n;
		
		// 변수 추가 선언
		//char temp;			//-- 임시로 테스트할 변수

		System.out.print("한 문자 입력    : ");
		ch = (char)System.in.read();

		// 입력 대기열에 남아있는 \r 과 \n 을 스킵(건너뛰기)
		System.in.skip(2);
		//-- 매개변수(2)에 의해 두 글자를 읽어내지 않고 건너뛴다.(버린다)

		System.out.print("한 자리 정수 입력 : ");
		n = System.in.read() - '0';  // 48 차이 즉 '0' 차이이므로 빼준다
		//temp = (char)System.in.read();

		System.out.println();
		System.out.println(">> 입력한 문자 : " + ch);
		System.out.println(">> 입력한 정수 : " + n);
		//System.out.println(">> 입력한 정수 : " + temp);

// 실행 결과
/*
한 문자 입력      : a
한 자리 정수 입력 : 9

>> 입력한 문자 : a
>> 입력한 정수 : 9
*/
		
	}
}

printf() 정리(016)

public class Test016
{
	public static void main(String args[])
	{
		System.out.print("AAA");
		System.out.print("BBB");
		System.out.print("CCC\n");		//-- \n 개행
		// ==AAABBBCCC

		System.out.println();			//-- 개행

		//System.out.print();				 매개변수 없이 사용못함

		System.out.printf("1234567890");
		System.out.printf("1234567890\n");	//-- \n 개행
		System.out.printf("1234567890%n");	//-- %n 개행

		//System.out.printf();				 매개변수 없이 사용못함

		System.out.printf("%d + %d = %d\n", 10, 20, 30);
		//== 10 + 20 = 30

		System.out.printf("%d\n", 123);
		System.out.printf("%10d\n", 123);	// 123을 포함하여 10자리를 확보해서 출력하라
		System.out.printf("%8d\n", 1234);	// 1234을 포함하여 8자리를 확보해서 출력하라
		System.out.printf("%010d\n", 123);	// 123을 포함하여 10자리를 확보하고 빈 자리는 0으로 채워라

		// 실행 결과
		//	123
		//		   123
		//		1234
		//	0000000123

		System.out.printf("%+d\n", 365);
		//== +365
		System.out.printf("+%d\n", 365);
		//== +365
		System.out.printf("%d\n", +365);
		//== 365

		//System.out.printf("%-d\n", 365);
		//== 에러 발생(런타임 에러)
		System.out.printf("-%d\n", 365);
		//== -365
		System.out.printf("%d\n", -365);
		//== -365

		//System.out.printf("%d\n", 'A');
		//== 에러 발생(런타임 에러)
		System.out.printf("%c\n", 'A');
		//== A

		//System.out.printf("%c\n", "ABCD");
		//== 에러 발생(런타임 에러)
		System.out.printf("%s\n", "ABCD");
		//== ABCD


		System.out.printf("%h\n", 365);
		//== 16d   -> 16진수 형태

		System.out.printf("%o\n", 24);
		//== 30

		System.out.printf("%b\n", true);
		System.out.printf("%b\n", false);
		//== true
		//   false

		System.out.printf("%f\n", 123.23);
		System.out.printf("%.2f\n", 123.23); // 소수점 이하 두 번째 자리까지 표현
		//== 123.230000
		//	 123.23

		System.out.printf("%.2f\n", 123.231);
		//== 123.23
		//   소수점 이하 두 번째 자리까지 표현
		//	 (소수점 이하 세 번째 자리 절삭)

		System.out.printf("%.2f\n", 123.235);
		//== 123.24
		//	 소수점 이하 두 번째 자리까지 표현
		//   (소수점 이하 세 번째 자리 올림)

		System.out.printf("%8.2f\n", 123.256);
		//==   123.26  -> .도 자리에 포함된다. 123.26 6개 포함해서 8자리 확보
		System.out.printf("%2.2f\n", 123.236); //표현하려는 데이터보다 확보수가 작으면 무시된다.
		//== 123.24
	}
}

자바의 기본 입출력 : System.util.Scanner(017~019)

java.util.Scanner
단락 문자 패턴을 사용하여 입력을 토큰에 따라 분할하며 디폴트(default)로 사용되는 단락문자는 공백이다. 작성된 다음 토큰은 next() 메소드 사용 및 다른 형태(자료형)의 값으로 변환할 수 있다.

import java.util.Scanner;

public class Test017
{
	public static void main(String args[]) //throws IOException 필요없음
	{
		// 주요 변수 선언

		// Scanner 클래스 기반의 인스턴스 생성
		Scanner sc = new Scanner(System.in);
		
		String name;			// 이름
		int kor, eng, mat;		// 국어,영어,수학 점수
		
		// 연산 및 처리
		System.out.print("이름을 입력하세요 : ");
		name = sc.next();

		// 테스트(확인)
		//System.out.println("입력한 이름 : " + name);
		
		System.out.print("국어 점수 입력 : ");
		//kor = Integer.parseInt(br.readLine());
		//kor = Integer.parseInt(sc.next());
		kor = sc.nextInt();

		System.out.print("영어 점수 입력 : ");
		eng = sc.nextInt();

		System.out.print("수학 점수 입력 : ");
		mat = sc.nextInt();
		
		// 결과 출력
		System.out.println();
		System.out.println(">> 이름 : " + name);
		//System.out.println(">> 총점 : " + kor + eng + mat);
		System.out.println(">> 총점 : " + (kor + eng + mat));
/*
이름을 입력하세요 : abc
국어 점수 입력 : 90
영어 점수 입력 : 80
수학 점수 입력 : 70

>> 이름 : abc
>> 총점 : 240
*/
	}
}

public class Test018
{
	public static void main(String args[])
	{
		// 주요 변수 선언
		java.util.Scanner sc = new java.util.Scanner(System.in);
		String name;
		int kor,eng,mat, tot;

		// 연산 및 처리
		System.out.print("이름 국어 영어 수학 입력(공백 구분) : ");
		//-- "ㅁㅁㅁ 90 80 70"

		// 사용자가 입력한 데이터를 각각의 변수에 담아내기
		name = sc.next();
		kor = sc.nextInt();
		eng = sc.nextInt();
		mat = sc.nextInt();

		// 총점 산출
		tot = kor + eng + mat;

		// 결과 출력
		System.out.println();
		System.out.println(">> 이름 : " + name);
		System.out.println(">> 총점 : " + tot);
		

		//실행 결과
/*
		이름 국어 영어 수학 입력(공백 구분) : aaa 90 80 70

		>> 이름 : aaa
		>> 총점 : 240
*/
	}
}
// 구분자 지정(, / . 등)

import java.util.Scanner;

public class Test019
{
	public static void main(String args[])
	{
		// 주요 변수 선언
		Scanner sc = new Scanner(System.in);
		String name;
		int kor,eng,mat, tot;

		// 연산 및 처리
		System.out.print("이름,국어,영어,수학 입력(, 구분) : ");
		// 이름,국어,영어,수학 입력(, 구분) : ㅁㅁㅁ,90,80,70

		sc = new Scanner(sc.next()).useDelimiter("\\s*,\\s*"); 
		//				 ---------
		//			 "ㅁㅁㅁ,90,80,70"
		//
		//new Scanner(sc.next()).useDelimiter("\\s*,\\s*"); 스캐너 안에 usdDelimiter 사용
		//						.구분자사용();
		//									  "\\s*,\\s*"
		//										\s*,\s*

		name = sc.next();
		kor = sc.nextInt();
		eng = sc.nextInt();
		mat = sc.nextInt();

		tot = kor + eng + mat;


		// 결과 출력
		System.out.println("\n>> 이름 : " + name);
		System.out.println(">> 총점 : " + tot);

		//실행 결과
/*
이름,국어,영어,수학 입력(, 구분) : ㅁㅁㅁ,90,80,70

>> 이름 : ㅁㅁㅁ
>> 총점 : 240
*/
	}
}

실수형 데이터타입의 정밀도 테스트 실습(020)

public class Test020
{
	public static void main(String args[])
	{
		// 주요 변수 선언
		float a = 0;
		double b = 0;

		// 연산 및 처리 -> 반복문 구성 -> 100000(십만)번 반복
		for (int i = 1; i <= 100000; i++)
		{
			//System.out.println("반복출력"); // 십만 번 반복
			a += 100000;	//-- a를 100000 만큼 증가시켜라
			b += 100000;	//-- b를 100000 만큼 증가시켜라
		}
	
		// 결과 출력
		System.out.println("float a : " + (a/100000));
		System.out.println("double b : " + (b/100000));

// 실행 결과

/*
float a : 99996.055
double b : 100000.0
*/
	}
}

사용자로부터 임의의 정수를 두 번 입력받아 사칙연산 및 나머지 연산을 수행하여 그 결과를 출력받는 프로그램을 구현(021)

실행 예)
첫 번째 정수 입력 : 10
두 번째 정수 입력 : 2
=====[결과]=====
10 + 2 = 12
10 - 2 = 8
10 * 2 = 20
10 / 2 = 5
10 % 2 = 0
================
BufferedReader와 printf() 활용할 것



import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test021
{
	public static void main(String args[]) throws IOException
	{
		// 내 풀이
/*
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int a = 0, b = 0; // a 첫 번째 정수 b 두 번째 정수

		System.out.printf("첫 번째 정수 입력 : ");
		a = Integer.parseInt(br.readLine());

		System.out.printf("두 번째 정수 입력 : ");
		b = Integer.parseInt(br.readLine());
		
		System.out.printf("\n");

		System.out.printf("=====[결과]=====\n");
		System.out.printf("%d + %d = %d\n", a, b, a + b);
		System.out.printf("%d - %d = %d\n", a, b, a - b);
		System.out.printf("%d * %d = %d\n", a, b, a * b);
		System.out.printf("%d / %d = %d\n", a, b, a / b);
		System.out.printf("%d %% %d = %d\n", a, b, a % b);
		System.out.printf("================\n");
*/

// 실행 결과
/*
첫 번째 정수 입력 : 10
두 번째 정수 입력 : 2

=====[결과]=====
10 + 2 = 12
10 - 2 = 8
10 * 2 = 20
10 / 2 = 5
10 % 2 = 0
================
*/
		// 수업
		
		// 주요 변수 선언
		int num1, num2;						// 사용자 입력값 받을 정수
		int res1, res2, res3, res4, res5;	// 각각의 연산 결과
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		// 연산 및 처리
		System.out.print("첫 번째 정수 입력 : ");
		num1 = Integer.parseInt(br.readLine());

		System.out.print("두 번째 정수 입력 : ");
		num2 = Integer.parseInt(br.readLine());

		res1 = num1 + num2;
		res2 = num1 - num2;
		res3 = num1 * num2;
		res4 = num1 / num2;
		res5 = num1 % num2;

		// 결과 출력
		System.out.printf("=====[결과]=====\n");
		System.out.printf("%d + %d = %d\n", num1, num2, res1);
		System.out.printf("%d - %d = %d\n", num1, num2, res2);
		System.out.printf("%d * %d = %d\n", num1, num2, res3);
		System.out.printf("%d / %d = %d\n", num1, num2, res4);
		System.out.printf("%d %% %d = %d\n", num1, num2, res5); // %% -> %
		System.out.printf("================\n");
	}
}

비트 단위 연산자(022~025)

public class Test023
{
	public static void main(String args[])
	{
		int a = 10, b = -10;

		System.out.printf("~a : %d%n", ~a); //비트낫 
		System.out.printf("~b : %d%n", ~b);

	}
}
// 실행 결과
/*
~a : -11
~b : 9
*/
  • 두 변수에 담겨있는 내용(값) 바꾸기 ->(swap)
public class Test024
{
	public static void main(String args[])
	{
		// 주요 변수 선언 및 초기화
		int x = 20, y = 23;
		//int temp;					// 임시 저장 변수

		// 담겨있는 내용물 확인
		System.out.printf("x -> %d, y -> %d\n", x, y);
		
		
		// 연산 및 처리
		/*
		temp = x;
		x = y;
		y = temp;
		*/

		/*
		x = x ^ y;
		y = y ^ x;
		x = x ^ y;
		*/

		y = y ^ x;
		x = x ^ y;
		y = y ^ x;

		// 결과 출력
		System.out.printf("x -> %d, y -> %d\n", x, y);
	}
}

/*
x -> 20, y -> 23
x -> 23, y -> 20
*/
public class Test025
{
	public static void main(String[] args)
	{
		int x = 128;	

		System.out.printf("x << 3 : %d\n", x << 3);
		System.out.printf("x * 8 : %d\n", x * 8); // 8  ==  2의 3제곱

		System.out.printf("x >> 3 : %d\n", x >> 3); 
		System.out.printf("x / 8 : %d\n", x / 8);

		System.out.printf("x << 24 : %d\n", x << 24); 
		// 10000000 00000000 00000000 00000000 -> -21억쯤 int형이 표현할 수 있는 가장 작은 값

		System.out.printf("x << 25 : %d\n", x << 25); // 0
		System.out.printf("x << 26 : %d\n", x << 26); // 0
		System.out.printf("x << 31 : %d\n", x << 31); // 0 

		System.out.printf("x << 32 : %d\n", x << 32);
		//== x << 32 : 128



// 실행 결과
/*
x << 3 : 1024
x * 8 : 1024
x >> 3 : 16
x / 8 : 16
x << 24 : -2147483648
*/
	}
}

논리 연산자(026)

/*===============================
   ■■■ 연산자(Operator) ■■■
 - 논리 연산자
================================*/
public class Test026
{
	public static void main(String[] args)
	{
		boolean a = true ,b = false;

		System.out.printf("a && b : %b\n", (a && b)); // true 또는 false를 담는 서식문자 %b
		System.out.printf("a || b : %b\n", (a || b));
		System.out.printf("!a     : %b\n", !a); // ! == 부정(반대)
		System.out.printf("!b     : %b\n", !b);

// 실행 결과
/*
a && b : false
a || b : true
!a     : false
!b     : true
*/
	}
}

조건 연산자 == 삼항 연산자(027)


/*
	피연산자 연산자 피연산자 연산자 피연산자
	--------        --------		--------
	   1항			  2항			   3항

	피연산자 ? 피연산자 : 피연산자
	--------   --------   --------
	   1항	     2항	    3항
	
	1항의 연산 결과 -> true  -> 2항 수행(치환)
					-> false -> 3항 수행(치환)
*/

// 사용자로부터 임의의 정수를 입력받아
// 입력받은 정수가 짝수인지 홀수인지 판별하는 프로그램을 구현한다.
// 단, 조건연산자(삼항연산자)를 활용하여 문제를 해결할 수 있도록 한다.

// 실행 예)
// 임의의 정수 입력 : 251
//
// ====[판별결과]====
// 251 -> 홀수
// ==================
// 계속하려면 아무 키나 누르세요...

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;


public class Test027
{
	public static void main(String[] args) throws IOException
	{
		// 주요 변수 선언
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n;				// 사용자로부터 입력받은 임의의 정수를 받아둘 변수
		String strResult;	// 홀수인지 짝수인지에 대한 판별 결과를 담게될 변수


		// 연산 및 처리
		System.out.print("임의의 정수 입력 : ");
		n = Integer.parseInt(br.readLine());

		// 홀수인지 짝수인지에 대한 판별 연산
		// _______ ? ________ : ________;
		//  수식1      수식2      수식3

		// 수식1 : 참(ture) 또는 거짓(false)를 반환할 수 있는 수식 형태로 작성
		// 수식2 : 수식1의 처리 결과가 참(true)인 경우 수행하는 영역
		// 수식3 : 수식1의 처리 결과가 거짓(false)일 경우 수행하는 영역

		// 입력받은 정수(n)가 홀수인지 짝수인지 확인하기 위한 연산
		// -> n 을 2 로 나누어서 나머지가 0이면       -> 짝수
		//								  0이 아니면  -> 홀수

		/*
		(n % 2 != 0) ? "홀수" : "짝수";
		(n % 2 == 0) ? "짝수" : "홀수";
		*/

		/*
		- 입력값이 5 일 경우...
		(5 % 2 == 0) ? "짝수" : "홀수";
		(1 == 0) ? "짝수" : "홀수";
		(false) ? "짝수" : "홀수";
		"홀수";
		*/

		// strResult = "홀수"
		strResult = (n % 2 == 0) ? "짝수" : "홀수";

		System.out.println();
		System.out.println("====[판별결과]====");
		System.out.printf("%d -> %s\n", n, strResult);
		System.out.println("==================");
		
		// 결과 출력
/*
====[판별결과]====
8 -> 짝수
==================
*/
	}
}

사용자로부터 임의의 정수를 입력받아 입력받은 정수가 양수인지, 음수인지, 0인지 구분하여 이 결과를 출력하는 프로그램을 구현(028)

실행 예)
임의의 정수 입력 : -24
-24 -> 음수
계속하려면 아무 키나 누르세요...
임의의 정수 입력 : 2597
2597 -> 양수
계속하려면 아무 키나 누르세요...
임의의 정수 입력 : 0
0 -> 영
계속하려면 아무 키나 누르세요...

단, 입력 데이터는 BufferedRader 를 활용하고,
조건연산자(삼항연산자)를 활용하여 기능을 구현할 수 있도록 한다.

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test028
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int num = 0;
		String ans;

		System.out.printf("임의의 정수 입력 : ");
		num = Integer.parseInt(br.readLine());

		ans = num > 0 ? "양수" : num < 0 ? "음수" : "영";
		System.out.printf("%d -> %s\n", num, ans);
	}
}

6일차

알파벳 대소문자 서로 바꾸는 프로그램 구현(029)

실행 예)
한 문자 입력 : A
A -> a
계속하려면 아무 키나 누르세요...
한 문자 입력 : b
b -> B
계속하려면 아무 키나 누르세요...
한 문자 입력 : 7
7 -> 7



// 실행 예)
// 한 문자 입력 : A
// A -> a
// 계속하려면 아무 키나 누르세요...

// 한 문자 입력 : b
// b -> B
// 계속하려면 아무 키나 누르세요

// 한 문자 입력 : 7
// 7 -> 7
import java.io.IOException;

public class Test029
{
	public static void main(String[] args) throws IOException
	{
		// 내 풀이
/*
		char ch, result;

		System.out.print("한 문자 입력 : ");

		ch = (char)System.in.read();

		result = (ch >= 'a' && ch <= 'z') ? (char)(ch - 32) : (ch >= 'A' && ch <= 'Z') ? (char)(ch + 32) : ch;

		System.out.println(ch + " -> " + result);
*/



		// 수업
/*
알파벳대문자 ? 알파벳소문자로변환 : (알파벳소문자 ? 알파벳대문자로변환 : 있는그대로);

		String result = temp >=65 && temp <=90 ? "대문자" : "대문자 아님";
		System.out.println("결과 : " + result);

		String result = temp >= 'a' && temp <= 'z' ? "소문자" : "소문자 아님";
		System.out.println("결과 : " + result);
		
		// 대문자 -> 소문자

*/

		char ch,result;

		System.out.print("한 문자 입력 : ");
		ch = (char)System.in.read();  // system.in.read가 int형 이므로

		result = ch >= 'A' && ch <= 'Z' ? (char)(ch + 32) : ch >= 'a' && ch <= 'z' ? (char)(ch - 32) : ch;
		
		System.out.println(ch + " -> " + result);
	}
}

윤년인지 평년인지 판독하는 프로그램 구현(030)

사용자로부터 임의의 연도를 입력받아
입력받은 연도가 윤년인지... 평년인지... 판별하여
그 결과를 출력하는 프로그램을 구현한다.
단, 입력은 BufferedReader를 활용하고
조건연산자를 활용하여 연산을 수행할 수 있도록 한다.

실행 예)
임의의 연도 입력 : 2000
2000 -> 윤년
계속하려면 아무 키나 누르세요...
윤년의 판별 조건
연도가 4의 배수이면서 100의 배수가 아니거나
400의 배수이면 윤년
그렇지 않은면 평년

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test030
{
	public static void main(String[] args) throws IOException
	{

		// 내 풀이
/*
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int year; // 연도
		String ans; // 답

		System.out.print("임의의 연도 입력 : ");
		year = Integer.parseInt(br.readLine());

		ans = (year % 4 == 0 && year % 100 != 0) ? "윤년" : year % 400 == 0 ? "윤년" : "평년";

		System.out.println(year + " -> " + ans);
*/

		// 수업
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int year;
		String strResult;

		System.out.print("임의의 연도 입력 : ");
		year = Integer.parseInt(br.readLine());

		// 연도가 4의 배수		연도가 100의 배수 아님			연도가 400의 배수
		// year % 4 == 0		   year % 100 != 0				 year % 400 == 0

		// ->  year % 4 == 0 이면서   year % 100 != 0	또는	 year % 400 == 0
		// ->  year % 4 == 0 &&   year % 100 != 0   ||	year % 400 == 0

		strResult = year % 4 == 0 && year % 100 != 0 ||	year % 400 == 0 ? "윤년" : "평년";

		System.out.printf("%d년 -> %s\n", year, strResult);
	}
}

사용자로부터 이름,점수를 입력받아 다음과 같은 형태로 출력하는 프로그램을 작성(031)

단, BufferedReader 를 활용해 데이터를 입력받을 수 있도록 하며,
printf() 메소드를 통해 출력할 수 있도록 한다.

실행 예)
이름 입력 : 김경태
국어 점수 : 90
영어 점수 : 80
수학 점수 : 70

당신의 이름은 김경태입니다.
국어 점수는 90,
영어 점수는 80,
수학 점수는 70,
총점은 240이고, 평균은 80.00입니다.
등급은 B 입니다.
계속하려면 아무 키나 누르세요

// 90점 이상		   : A
// 80점 이상 90점 미만 : B
// 70점 이상 80점 미만 : C
// 60점 이상 70점 미만 : D
// 60점 미만		   : F

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test031
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		/*
		String name;		// 이름
		int kor,eng,mat;	// 국어,영어,수학 점수
		int tot;			// 총점
		double avg;			// 총점
		char grade;			// 등급

		System.out.print("이름 입력 : ");
		name = br.readLine();

		System.out.print("국어 점수 : ");
		kor = Integer.parseInt(br.readLine());

		System.out.print("영어 점수 : ");
		eng = Integer.parseInt(br.readLine());

		System.out.print("수학 점수 : ");
		mat = Integer.parseInt(br.readLine());

		tot = kor + eng + mat;
		avg = tot / 3.0;

		if(avg >= 90)
		{
			grade = 'A';
		}
		else if(avg >= 80)
		{
			grade = 'B';
		}
		else if(avg >= 70)
		{
			grade = 'C';
		}
		else if(avg >= 60)
		{
			grade = 'D';
		}
		else
		{
			grade = 'F';
		}

		System.out.printf(">> 당신의 이름은 %s입니다.\n", name);
		System.out.printf(">> 국어 점수는 %d,\n", kor);
		System.out.printf(">> 영어 점수는 %d,\n", eng);
		System.out.printf(">> 수학 점수는 %d,\n", mat);
		System.out.printf(">> 총점은 %d이고, 평균은 %.2f입니다.\n", tot, avg);
		System.out.printf(">> 등급은 %c 입니다.\n", grade);
		*/
		// 1. 사용자들로부터 이름을 입력받는다.
		System.out.print("이름 입력 : ");
		String strName = br.readLine();

		// 2. 사용자로부터 국어, 영어, 수학 점수를 입력받는다.
		System.out.print("국어 점수 : ");
		String strKor = br.readLine();
		System.out.print("영어 점수 : ");
		String strEng = br.readLine();
		System.out.print("수학 점수 : ");
		String strMat = br.readLine();

		// 3. 문자열 형태로 입력받은 과목 점수를 정수 형태로 변환한다.
		int nKor = Integer.parseInt(strKor);
		int nEng = Integer.parseInt(strEng);
		int nMat = Integer.parseInt(strMat);

		// 4. 산술 연산을 통해 총점과 평균을 계산한다.
		int nTot = nKor + nEng + nMat;			//  총점
		double fAvg = (double)nTot / 3;			//  평균

		// 5. 등급에 대한 조건 검사를 수행한다.
		char grade;								//  등급
		char grade = 'F';			
// grade를 초기값을 넣어준다면 마지막에 else if로 끝나더라도 조건을 만족 못했을때
// 넣어줄 값이 있기 때문에 괜찮다. 초기값을 넣어주지 않는다면 마지막에는 else 로
// 끝나야 한다.

		if (fAvg >= 90)
		{
			grade = 'A';
		}
		else if(fAvg >= 80)
		{
			grade = 'B';
		}
		else if(fAvg >= 70)
		{
			grade = 'C';
		}
		else if (fAvg >= 60)
		{
			grade = 'D';
		}
		else 
		{
			grade = 'F';
		}

		// 6. 최종 결과 출력
		System.out.printf(">> 당신의 이름은 %s입니다.\n", strName);
		System.out.printf(">> 국어 점수는 %d,\n", nKor);
		System.out.printf(">> 영어 점수는 %d,\n", nEng); // strEng에는 문자형태의 점수, nEng의 경우 정수형태의 점수
		System.out.printf(">> 수학 점수는 %d,\n", nMat);
		System.out.printf(">> 총점은 %d이고, 평균은 %.2f입니다.\n", nTot, fAvg);
		System.out.printf(">> 등급은 %c 입니다.\n", grade);
// 실행 결과
/*
이름 입력 : 김경태
국어 점수 : 90
영어 점수 : 80
수학 점수 : 70

>> 당신의 이름은 김경태입니다.
>> 국어 점수는 90,
>> 영어 점수는 80,
>> 수학 점수는 70,
>> 총점은 240이고, 평균은 80.00입니다.
>> 등급은 B 입니다.
*/
	}
}

7일차

사용자로부터 임의의 정수를 입력받아 홀수인지, 짝수인지, 영인지 확인하여 그 결과를 출력하는 프로그램을 구현(032)

실행 예)
임의의 정수 입력 : 14
14 -> 짝수
계속하려면 아무 키나 누르세요...
실행 예)
임의의 정수 입력 : 0
0 -> 영
계속하려면 아무 키나 누르세요...

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test032
{
	public static void main(String args[]) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 내 풀이
		int n = 0;

		System.out.print("임의의 정수 입력 : ");
		n = Integer.parseInt(br.readLine());

		String ans; // 답

		if(n % 2 == 0 && n > 0)
		{
			ans = "짝수";
		}
		else if(n % 2 == 1)
		{
			ans = "홀수";
		}
		else
		{
			ans = "영";
		}

		System.out.printf("%d -> %s\n", n, ans);


		// 수업
		
		if(n == 0)
		{
			ans = "영";
		}
		else if(n % 2 == 1)
		{
			ans = "홀수";
		}
		else
		{
			ans = "짝수";
		}


		String result = "판정불가";
		if(n == 0)
		{
			ans = "영";
		}
		else if(n % 2 == 1)
		{
			ans = "홀수";
		}
		else if
		{
			ans = "짝수";
		}

		System.out.println(n + " -> " + result);

	}
}

사용자로부터 임의의 정수를 입력받아 다음과 같은 판별 결과를 출력하는 프로그램을 구현(033)

  • 2의 배수
  • 3의 배수
  • 2와 3의 배수
  • 2와 3의 배수 아님

실행 예)
임의의 정수 입력 : 4
4 -> 2의 배수
계속하려면 아무 키나 누르세요...

실행 예)
임의의 정수 입력 : 9
9 -> 3의 배수
계속하려면 아무 키나 누르세요...

실행 예)
임의의 정수 입력 : 12
12 -> 2와 3의 배수
계속하려면 아무 키나 누르세요...

실행 예)
임의의 정수 입력 : 17
17 -> 2와 3의 배수 아님
계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test033
{
	public static void main(String[] args) throws IOException
	{
		// 내 풀이
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n;

		System.out.print("임의의 정수 입력 : ");
		n = Integer.parseInt(br.readLine());

		String ans = "ERROR";
		if(n == 0)
		{
			ans = "2와 3의 배수 아님";
		}
		else if(n % 2 == 0 && n % 3 == 0 )
		{
			ans = "2와 3의 배수";
		}
		else if(n % 2 == 0)
		{
			ans = "2의 배수";
		}
		else if(n % 3 == 0)
		{
			ans = "3의 배수";
		}
		else
		{
			ans = "2와 3의 배수 아님";
		}

		System.out.println(n + " -> " + ans);

		
		// 수업

		if(n % 2 == 0 && n % 3 == 0 )
		{
			ans = "2와 3의 배수";
		}
		else if(n % 2 == 0)
		{
			ans = "2의 배수";
		}
		else if(n % 3 == 0)
		{
			ans = "3의 배수";
		}
		else if(n % 2 !=0 || n % 3 != 0)
		{
			ans = "2와 3의 배수 아님";
		}
		else
		{
			System.out.println(n + " -> 판정 불가");
		}

	}
}

윤년 평년 구별하기(034)

○ 과제
사용자로부터 임의의 연도를 입력받아
입력받은 연도가 윤년인지... 평년인지... 판별하여
그 결과를 출력하는 프로그램을 구현한다.
단, 입력은 BufferedReader 를 활용하고
if 조건문을 활용하여 연산을 수행할 수 있도록 한다.

실행 예)
임의의 연도 입력 : 2024
2024년 → 윤년
계속하려면 아무 키나 누르세요...

임의의 연도 입력 : 2023
2024년 → 평년
계속하려면 아무 키나 누르세요...

윤년의 판별 조건
연도가 4의 배수이면서 100의 배수가 아니거나
400의 배수이면 윤년
그렇지 않으면 평년

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test034
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int year;					// 입력받을 연도
		String ans;					// 윤년인지 평년인지
		
		System.out.print("임의의 연도 입력 : ");
		year = Integer.parseInt(br.readLine());

		if(  year % 4 == 0 && year % 100 != 0)    // 1.연도가 4의 배수이면서 100의 배수가 아닌 경우
		{
			ans = "윤년";
		}
		else if( year % 400 == 0)				  // 2. 연도가 400의 배수인 경우
 		{
			ans = "윤년";
		}
		else
		{
			ans = "평년";						  // 3. 1의 경우와 2의 경우가 아닌 경우 -> 평
		}

		System.out.println(year+"년 → " + ans);
	}
}

두 정수와 연산자를 입력받아 연산 처리 결과를 출력하는 프로그램을 구현(035)

실행 예)
첫 번째 정수 입력 : 10
두 번째 정수 입력 : 3
연산자 입력[+ - * /] : +

10 + 3 = 13
계속하려면 아무 키나 누르세요...

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test035
{
public static void main(String[] args) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
/*
int num1, num2;
char c;

	System.out.print("첫 번째 정수 입력    :   ");
	num1 = Integer.parseInt(br.readLine());

	System.out.print("두 번째 정수 입력    :   ");
	num2 = Integer.parseInt(br.readLine());

	System.out.print("연산자 입력[+ - * /] :   ");
	c = (char)System.in.read();
	

	// 내 풀이
	if(c == '+')
	{
		System.out.printf("%d %c %d = %d\n", num1, c, num2, num1 + num2);
	}
	else if(c == '-')
	{
		System.out.printf("%d %c %d = %d\n", num1, c, num2, num1 - num2);
	}
	else if(c == '*')
	{
		System.out.printf("%d %c %d = %d\n", num1, c, num2, num1 * num2);
	}
	else if(c == '/')
	{
		System.out.printf("%d %c %d = %d\n", num1, c, num2, num1 / num2);
	}
	else
	{
		System.out.printf("WRONG MARK\n");
	}
	*/
	// 수업

/*
int a,b;
char op;

	System.out.print("첫 번째 정수 입력    :   ");
	a = Integer.parseInt(br.readLine());

	System.out.print("두 번째 정수 입력    :   ");
	b = Integer.parseInt(br.readLine());

	// Integer.parseInt()
	// "1234"  -> Integer.parseInt() -> 1234
	// "abcd"  -> Integer.parseInt() -> (x)

	System.out.print("연산자 입력[+ - * /] :   ");
	//c = (char)Integer.parseInt(br.readLine());		 안됨
	op = (char)System.in.read();
	
	// 테스트
	//System.out.println("입력한 연산자 : " + op);     잘 나옴

	// + == 43       - == 45		 * == 42		/ == 47

	if(op == 43)
	{
		System.out.printf("\n>> %d %c %d = %d\n", a, op, b, a + b);
	}
	else if(op == 45)
	{
		System.out.printf("\n>> %d %c %d = %d\n", a, op, b, a - b);
	}
	else if(op == 42)
	{
		System.out.printf("\n>> %d %c %d = %d\n", a, op, b, a * b);
	}
	else if(op == 47)
	{
		System.out.printf("\n>> %d %c %d = %d\n", a, op, b, a / b);
	}
	else
	{
		System.out.println("\n>>입력 과정에 오류가 존재합니다.");
	}


	// 두 번째 풀이는 내 풀이와 같음
	
	// 세 번재 풀이
	int a, b, result = 0;
	char op;

	System.out.print("첫 번째 정수 입력    : ");
	a = Integer.parseInt(br.readLine());
	System.out.print("두 번째 정수 입력    : ");
	b = Integer.parseInt(br.readLine());
	System.out.print("연산자 입력[+ - * /] : ");
	op = (char)System.in.read();

	if(op == '+')
		result=a+b;
	else if(op == '-')
		result=a-b;
	else if(op == '*')
		result=a*b;
	else if(op == '/')
		result=a/b;

	System.out.printf("\n>> %d %c %d = %d\n", a, op, b, result);

}

사용자로부터 임의의 정수 세 개를 입력받아 작은 수에서 큰 수 순으로 출력하는 프로그램을 구현(036)

실행 예)
첫 번째 정수 입력 : 753
두 번째 정수 입력 : 22
세 번째 정수 입력 : 124

정렬 결과 : 22 124 753

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test036
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		// 내 풀이
		int num1,num2,num3;

		System.out.print("첫 번째 정수 입력 : ");
		num1 = Integer.parseInt(br.readLine());

		System.out.print("두 번째 정수 입력 : ");
		num2 = Integer.parseInt(br.readLine());

		System.out.print("세 번째 정수 입력 : ");
		num3 = Integer.parseInt(br.readLine());
/*
		int temp;

		if( num1 >= num2)
		{
			temp = num1;
			num1 = num2;
			num2 = temp;
		}
		if( num1 >= num3)
		{
			temp = num1;
			num1 = num3;
			num3 = temp;
		}
		if( num2 >= num3)
		{
			temp = num2;
			num2 = num3;
			num3 = temp;
		}
*/		
		System.out.printf("\n>> 정렬 결과 : %d %d %d\n", num1, num2, num3);

		// 수업

// 1. 첫 번째 정수, 두 번째 정수 크기 비교
// -> 첫 번째 정수가 두 번째 정수보다 클 경우 자리 바꿈

// 2. 첫 번째 정수, 세 번째 정수 크기 비교
// -> 첫 번째 정수가 세 번재 정수보다 클 경우 자리 바꿈

// 3. 두 번째 정수, 세 번째 정수 크기 비교
// -> 두 번째 정수가 세 번째 정수보다 클 경우 자리 바꿈
		
		// 비트연산자로 값을 바꿔주는 것이 더 빠르다.
		if( a > b)			// 첫 번째 정수가 두 번째보다 클 경우
		{
			a = a^b;
			b = b^a;
			a = a^b;
		}

		if( a > c)		    // 첫 번째 정수가 세 번째보다 클 경우
		{
			a = a^c;
			c = c^a;
			a = a^c;
		}

		if( b > c)			// 두 번째 정수가 세 번째보다 클 경우
		{
			b = b^c;
			c = c^b;
			b = b^c;
		}
		System.out.printf("\n>> 정렬 결과 : %d %d %d\n", a, b, c);
	}
}

사용자로부터 임의의 정수 5개를 입력받아 짝수별, 홀수별 합계를 출력하는 프로그램을 구현(037)

단, Scanner를 활용하여 데이터를 입력받을 수 있도록 한다.

실행 예)
임의의 정수 5개 입력(공백 구분) : 11 12 13 14 15

짝수의 합은 26 이고, 홀수의 합은 39 입니다.
계쏙하려면 아무 키나 누르세요...

import java.util.Scanner;

public class Test037
{
	public static void main(String[] args)
	{
/*
		int a,b,c,d,e;
		int oSum = 0, eSum = 0;
		Scanner sc = new Scanner(System.in);

		System.out.print("임의의 정수 5개 입력(공백 구분) : ");
		
		a = sc.nextInt();
		b = sc.nextInt();
		c = sc.nextInt();
		d = sc.nextInt();
		e = sc.nextInt();

		// 내 풀이
		if(a % 2 == 0)
			eSum += a;
		else
			oSum += a;

		if(b % 2 == 0)
			eSum += b;
		else
			oSum += b;

		if(c % 2 == 0)
			eSum += c;
		else
			oSum += c;

		if(d % 2 == 0)
			eSum += d;
		else
			oSum += d;

		if(e % 2 == 0)
			eSum += e;
		else
			oSum += e;

		System.out.printf("\n>> 짝수의 합은 %d 이고, 홀수의 합은 %d 입니다.\n", eSum, oSum);
*/
// 실행 결과
/*
임의의 정수 5개 입력(공백 구분) : 11 12 13 14 15

>> 짝수의 합은 26 이고, 홀수의 합은 39 입니다.
계속하려면 아무 키나 누르십시오 . . .
*/
		
		// 수업
		// 주요 변수 선언
		Scanner sc = new Scanner(System.in);

		// 누적합을 담아낼 변수 초기화
		int evenSum = 0;			// 짝수의 합을 담아낼 변수 선언 , 누적곱 일때는 1로 초기화한다.
		int oddSum = 0;				// 홀수의 합을 담아낼 변수 선언
		int num1, num2, num3, num4, num5;
		// 사용자로부터 입력받은 5개의 정수를 담을 변수 선언

		// 연산 및 처리
		System.out.print("임의의 정수 5개 입력(공백 구분) : ");	// 10 20 30 40 50
		num1 = sc.nextInt();
		num2 = sc.nextInt();
		num3 = sc.nextInt();
		num4 = sc.nextInt();
		num5 = sc.nextInt();

		if(num1 % 2 == 0)			// num1이 짝수일 때
		{
			evenSum += num1;		//evenSum 을 num1 만큼 증가
		}
		else						// num1이 홀수일 때
		{
			oddSum += num1;			//oddSum 을 num1 만큼 증가
		}
		
		if(num2 % 2 == 0)			// num2이 짝수일 때
		{
			evenSum += num2;		//evenSum 을 num2 만큼 증가
		}
		else						// num1이 홀수일 때
		{
			oddSum += num2;			//oddSum 을 num2 만큼 증가
		}

		if(num3 % 2 == 0)		
			evenSum += num3;		
		else					
			oddSum += num3;	
		
		if(num4 % 2 == 0)		
			evenSum += num4;		
		else					
			oddSum += num4;	

		if(num5 % 2 == 0)		
			evenSum += num5;		
		else					
			oddSum += num5;	

		// 결과 출력
		System.out.printf("\n>> 짝수의 합은 %d 이고, 홀수의 합은 %d 입니다.\n", evenSum, oddSum);
		
	}
}

알파벳 한 문자를 입력받아 이를 판별하여 입력받은 알파벳이 모음일 경우만 결과를 출력하는 프로그램을 구현(038)

단, 대소문자를 모두 적용할 수 있도록 처리한다.
또한, 알파벳 이외의 문자가 입력되었을 경우
입력 오류에 대한 내용을 사용자에게 안내해 줄수 있도록 한다.

실행 예)
임의의 알파벳 한 문자 입력 : A <- 대문자 모음
모음 ok~!!!
계속하려면 아무 키나 누르세요...

임의의 알파벳 한 문자 입력 : e <- 대문자 모음
모음 ok~!!!
계속하려면 아무 키나 누르세요...

임의의 알파벳 한 문자 입력 : B <- 대문자 자음
계속하려면 아무 키나 누르세요...

임의의 알파벳 한 문자 입력 : c <- 소문자 자음
계속하려면 아무 키나 누르세요...

임의의 알파벳 한 문자 입력 : 1 <- 알파벳 아님
입력 오류~!!!
계속하려면 아무 키나 누르세요...

import java.io.IOException;

public class Test038
{
	public static void main(String[] args) throws IOException
	{
		char c;			// 입력받을 문자

		System.out.print("임의의 알파벳 한 문자 입력 : ");
		c = (char)System.in.read();			
		// 정수 형태로 반환하는 것을 char형으로 바꾸어 c에 저장

		if( (c >= 65 && c <= 90) ||						// c가 알파벳인지 확인
			(c >= 97 && c <= 122))
		{
			if( c == 'a' || c == 'A' ||					// c가 알파벳인 경우중에서 모음인 경우
				c == 'e' || c == 'E' ||
				c == 'i' || c == 'I' ||
				c == 'o' || c == 'O' ||
				c == 'u' || c == 'U')
			{
				System.out.print(">> 모음 ok~!!!\n");	// 모음이라는 출력멘트 출력
			}											// 모음이 아니면 그대로 if문 나가짐

		}
		else											// 알파벳이 아닌 경우
		{
			System.out.print(">> 입력 오류~!!!\n");		// 입력오류 출력	
		}
	}
}

임의의 문자를 하나 입력받아 알파벳 대문자이면 소문자로, 소문자이면 대문자로 알파벳이 아닌 기타 문자면 입력 오류 처리하는 프로그램을 구현(039)

실행 예)
한 문자 입력 : A
A → a
계속하려면 아무키나 누르세요

한 문자 입력 : b
b → B
계속하려면 아무키나 누르세요

한 문자 입력 : 3
입력 오류~!!
계속하려면 아무키나 누르세요

import java.io.IOException;

public class Test039
{
	public static void main(String[] args) throws IOException
	{
		char c;			// 입력받을 문자

		System.out.print("임의의 알파벳 한 문자 입력 : ");
		c = (char)System.in.read();
		// 정수 형태로 반환하는 것을 char형으로 바꾸어 c에 저장
		char ch = c;									// 기본값 저장

		if( (c >= 65 && c <= 90) ||						// c가 알파벳인지 확인
			(c >= 97 && c <= 122))
		{
			if(c >= 65 && c <= 90)						// c가 대문자인 경우
			{
				c += 32;								// 소문자로 바꿔준다
				System.out.println(">> "+ ch + " → " + c);
			}
			else										// 대문자가 아닌 경우 == 소문자인 경우
			{
				c -= 32;								// 대문자로 바꿔 준다.
				System.out.println(">> "+ ch + " → " + c);
			}

		}
		else											// 알파벳이 아닌 경우
		{
			System.out.print(">> 입력 오류~!!!\n");		// 입력오류 출력	
		}

	}
}

switch문 실습(040)

/*

○ 형식 및 구조
   switch(수식)
   {
	   case 상수1 : 문장1; [break;]
	   case 상수2 : 문장2; [break;]
	   			:
	   [default : 문장n+1; [break;]]
   }

   switch 문의 수식과 case의 상수는
   byte, short, int, long 형이어야 한다.
   (+ 문자 타입 char)
   (+ 문자열 String)

   case 문 뒤에 break; 가 없는 형태인 경우
   다음 case 문의 문장을 계속해서(이어서) 수행하게 된다. (기본 모델)
   break 가 존재할 경우
   해당 지점에서 수행을 멈춘 후 switch 문을 빠져나간다. (일반 모델)

*/

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test040
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String name;			// 이름
		int kor, eng, mat, tot; // 국어, 영어, 수학, 총점
		//double avg;			// 평균
		int avg;				// switch 활용하기 위해 int형으로 처리
		char grade;				// 등급

		System.out.print("이름 입력 : ");
		name = br.readLine();

		System.out.print("국어점수 입력 : ");
		kor = Integer.parseInt(br.readLine());

		System.out.print("영어점수 입력 : ");
		eng = Integer.parseInt(br.readLine());
		
		System.out.print("수학점수 입력 : ");
		mat = Integer.parseInt(br.readLine());

		tot = kor + eng + mat;
//		avg = tot / 3.0
		avg = tot / 3;
/*
		if(avg >= 90)
			grade = 'A';
		else if(avg >= 80)
			grade = 'B';
		else if(avg >= 70)
			grade = 'C';
		else if(avg >= 60)
			grade = 'D';
		else	
			grade = 'F';
*/
/*
		switch (avg / 10)
		{
		case 10: grade = 'A'; break;
		case 9:  grade = 'A'; break;
		case 8:  grade = 'B'; break;
		case 7:  grade = 'C'; break;
		case 6:  grade = 'D'; break;
		case 5:  grade = 'F'; break;
		case 4:  grade = 'F'; break;
		case 3:  grade = 'F'; break;
		case 2:  grade = 'F'; break;
		case 1:  grade = 'F'; break;
		case 0:  grade = 'F'; break;
		}
*/
/*
		switch (avg / 10)
		{
		case 10: grade = 'A'; break;
		case 9:  grade = 'A'; break;
		case 8:  grade = 'B'; break;
		case 7:  grade = 'C'; break;
		case 6:  grade = 'D'; break;
		default:  grade = 'F'; break;
		}
*/
		switch (avg / 10)
		{
		case 10: case 9:  grade = 'A'; break;
		case 8:  grade = 'B'; break;
		case 7:  grade = 'C'; break;
		case 6:  grade = 'D'; break;
		default:  grade = 'F'; break;
		}

		// 결과 출력
		System.out.println();
		System.out.printf(">> 당신의 이름은 %s 입니다.\n", name);
		System.out.printf(">> 총점은 %d, 평균은 %d 입니다.\n", tot, avg);
		System.out.printf(">> 등급은 %c 입니다.\n", grade);

// 실행 결과

/*이름 입력 : 강혜성
국어점수 입력 : 90
영어점수 입력 : 80
수학점수 입력 : 70

>> 당신의 이름은 강혜성 입니다.
>> 총점은 240, 평균은 80 입니다.
>> 등급은 B 입니다.
*/
	}
}

1 부터 3까지의 정수 중 하나를 입력받아 입력받은 정수만큼의 별문자(★)가 출력되는 프로그램을 작성(041)

단, 두 가지 방법으로 구현할 수 있도록 한다.

1.switch 문의 일반 모델을 사용하여 구현한다.
2.switch 문의 기본 모델을 사용하되, break 를 딱 한 번만 사용할 수 있도록 구현한다.

실행 예)
임의의 정수 입력(1~3) : 3
★★★
계속하려면 아무 키나 누르세요...

실행 예)
임의의 정수 입력(1~3) : 1
★
계속하려면 아무 키나 누르세요...

실행 예)
임의의 정수 입력(1~3) : 7
입력 오류~!!!
계속하려면 아무 키나 누르세요...



// 사용자로부터 1 부터 3까지의 정수 중 하나를 입력받아
// 입력받은 정수만큼의 별문자(★)가 출력되는 프로그램을 작성한다.
// 

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test041
{
	public static void main(String[] args) throws IOException
	{
		int n;		// 입력 받을 정수
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


		System.out.print("임의의 정수 입력(1~3) : ");
		n = Integer.parseInt(br.readLine());

		// 내 풀이


		switch(n)
		{
			case 1: System.out.print("★\n"); break;
			case 2: System.out.print("★★\n"); break;
			case 3: System.out.print("★★★\n"); break;
 			default: System.out.print("입력 오류~!!!\n");break;
		}


		switch(n)
		{
			case 3: System.out.print("★");
			case 2: System.out.print("★");
			case 1: System.out.print("★");
 			default: System.out.print("\n입력 오류~!!!\n");break;
		}

		// 수업
		switch(n)
		{
			case 1: System.out.print("★\n"); break;
			case 2: System.out.print("★★\n"); break;
			case 3: System.out.print("★★★\n"); break;
 			default: System.out.print("입력 오류~!!!\n"); //break 필수 아님
		}
		switch(n)
		{
			case 3: System.out.print("★");
			case 2: System.out.print("★");
			case 1: System.out.print("★");
					break;
 			default: System.out.print("\n입력 오류~!!!\n");
		}
}

반복문 실습 및 관찰(043)

/*
○ 반복문의 개요
   
   주어진 조건이 참 인 경우
   일정한 영역의 문장을 반복 수행하다가
   조건식이 거짓이 되는 순간이 오면
   반복 수행을 중단하는 문장이다
   이러한 반복문에는 while, do~while, for문 등이 있으며
   반복의 제어를 위해 break, continue 등을 사용하는 경우가 있다.
   
○ while 문
   
   조건식을 먼저 비교하여
   조건식의 처리 결과가 참인 경우, 특정 영역을 반복 수행하는 문장으로
   반복 횟수가 정해져 있지 않은 경우나
   반복 횟수가 많은 경우 주로 사용한다.
   while 문은 조건이 맞지 않은 경우
   반복은 커녕 단 한 번도 실행되지 않을 수 있다.

○ while 문의 형식 구조

   while(조건식)
   {
	   실행문;
   }
*/

public class Test043
{
	public static void main(String[] args)
	{	
		/*
		int n = 0;

		while (n <= 10)
		{
			System.out.println("n=" + n);
			n++;
		}
		*/
		/*
		int n = 0;

		while (n <= 10)
		{
			n++;
			System.out.println("n=" + n);
		}
		*/
		/*
		int n = 0;

		while (n++ <= 10)
		{
			System.out.println("n=" + ++n);
		}
		*/

		int n = 1;

		while (n < 10)
		{
			System.out.println("n=" + n);
			n++;
		}
	}
}

1부터 100까지의 정수 중에서 짝수들의 합을 계산하여 결과값을 출력하는 프로그램을 구현(044)

단, 조건문은 사용하지 않도록 하며,
while 반복문을 활용하여 작성할 수 있도록 한다.

실행 예)
1부터 100 까지의 수 중 짝수의 합 : xxxx
계속하려면 아무 키나...

public class Test044
{
	public static void main(String[] args)
	{
/*		
		int i = 0;
		int sum = 0;
		
		while(i++ < 100)
		{
			sum += ++i;
		}
		System.out.println("1부터 100 까지의 수 중 짝수의 합 : " + sum);
*/		
/*
		int i = 1;
		int sum = 0;

		while(i <= 50)
		{
			sum = sum + i + i;
			i++;
		}
		System.out.println("1부터 100 까지의 수 중 짝수의 합 : " + sum);
*/
		// 문제 인식 및 분석
		// 2 + 4 + 6 + 8
		// 초기값 : 2
		// 증가값 : 2
		// 한계값 : 100

		// 주요 변수 선언 및 초기화
		int n = 1;
		int sum = 0;

		// 연산 및 처리
		while (n <= 100)
		{
			sum += n;	// sum 값을 n 만큼 증가~!!!
			n += 2;		// n 값을 2 만큼 증가~!!!
		}

		// 결과 출력
		System.out.println("1부터 100까지의 수 중 짝수의 합 : " + sum);
	}
}

1부터 100까지의 정수 중에서 짝수들의 합과 홀수들의 합을 따로 구분하여 계산하고 결과값 출력(045)

단, 반복문은 while문을 사용할 수 있도록 하며,
조건문은 if 조건문을 사용하여 작성할 수 있도록 한다.

실행 예)
1부터 100까지의 정수 중
짝수의 합 : 2550
홀수의 합 : 2500
계속하려면 아무 키나 누르세요...

public class Test045
{
	public static void main(String[] args)
	{
/*
		int n = 1;
		int oSum = 0, eSum = 0;

		while(n <= 100)
		{
			if( n % 2 == 0)
			{
				eSum += n;
			}
			else
			{
				oSum += n;
			}
			n++;
		}
		System.out.println("1부터 100까지의 정수중");
		System.out.println("짝수의 합 : " + eSum);
		System.out.println("홀수의 합 : " + oSum);
*/
		// 주요 변수 선언
		int n = 1;			// 1부터 100까지 1씩 증가할 변수
		int even = 0;		// 짝수들의 누적합을 담아낼 변수
		int odd = 0;		// 홀수들의 누적합을 담아낼 변수

		// 연산 및 처리
		while (n <= 100)	// 1 ~ 100
		{
			if(n % 2 == 0)	// n이 짝수일 경우
			{
				even += n;
			}
			else if(n % 2 != 0) // n이 홀수인 경우
			{
				odd += n;
			}
			else		
			{
				System.out.println("판별 불가 데이터");
				return;			// return뒤에 아무것도 없다는건 메소드를 종료하겠다는 뜻
								// 즉 main 메소드 종료 -> 프로그램 종료
			}
			n++;				// n을 1만큼 증가
		}


		// 결과 출력
		System.out.println("1부터 100까지의 정수중");
		System.out.println("짝수의 합 : " + even);
		System.out.println("홀수의 합 : " + odd);

/*
1부터 100까지의 정수중
짝수의 합 : 2550
홀수의 합 : 2500
*/
	}
}

1부터 100까지 정수의 합을 구하되 10의 배수가 될 때 마다 그 시점까지의 결과를 출력하는 프로그램을 구현(047)

실행 예)
1 ~ 10 까지의 합 : xx
1 ~ 20 까지의 합 : xxx
1 ~ 30 까지의 합 : xxx
:
1 ~ 100 까지의 합 : xxxx
계속하려면 아무 키나 누르세요

public class Test047
{
	public static void main(String[] args)
	{
		//내 풀이
		int n = 1;
		int sum = 0;

		while (n <= 100)
		{
			sum += n;
			if(n % 10 == 0)
				System.out.printf("1 ~ %d 까지의 합 : %d\n", n, sum);
			
			n++;
		}
// 실행 결과
/*
1 ~ 10 까지의 합 : 55
1 ~ 20 까지의 합 : 210
1 ~ 30 까지의 합 : 465
1 ~ 40 까지의 합 : 820
1 ~ 50 까지의 합 : 1275
1 ~ 60 까지의 합 : 1830
1 ~ 70 까지의 합 : 2485
1 ~ 80 까지의 합 : 3240
1 ~ 90 까지의 합 : 4095
1 ~ 100 까지의 합 : 5050
*/
	}
}

8일차

/2 + 2/3 + 3/4 + 4/5 + ... + 9/10 의 연산 처리 결과를 출력하는 프로그램을 구현(048)

실행 예)
연산 결과 : ????? <- 실수 기반 연산
계속하려면 아무 키나 누르세요...

public class Test048
{
	public static void main(String[] args)
	{
		// 내 풀이
/*
		double n = 1.0;
		double sum = 0.0;

		while(n < 10)
		{	
			sum += n / (n + 1);
			n++;
		}
		System.out.println("연산 결과 : " + sum);
*/

		// 수업----------------------------------------
		
		// 주요 변수 선언 및 초기화
		int n = 0;				// 1부터 1씩 증가하게 될 변수
		double sum = 0;			// 누적합을 담아낼 변수(실수 형태로 처리)

		
		// 연산 및 처리
		while (n < 9)			// 0 1 2 3 4 5 6 7 8
		{
			// 증감식 구성
			// 최종적으로 반복문의 조건을 무너뜨리게 되는 열쇠가 되는 구문
			n++;				// 1 2 3 4 5 6 7 8 9

			sum += (double)n / (n + 1);
			// 정수 기반 나눗셈 연산은 몫을 반환하기 때문에
			// 실수 기반 연산을 수행하도록 처리하기 위해서
			// 나눗셈 연산자를 중심으로 피연산자 중 하나를
			// 실수 형태로 만들어주는 것이 중요하다.
		}

		// 결과 출력
		System.out.printf("연산 결과 : %f\n", sum);
		System.out.println("연산 결과 : " + sum);

	}
}

반복문을 활용하여 누적곱 연산 수행(049)

실행 예)
연산 결과 : xxxx
계속하려면 아무 키나 누르세요...


public class Test049
{
	public static void main(String[] args)
	{

		int n = 0;
		int sum = 1;

		while(n < 10)
		{
			n++;
			sum *= n;
		}
		System.out.println("연산 결과 : " + sum);
//== 연산 결과 : 3628800
	}
}

소수 판별 프로그램 구현(050)

실행 예)
임의의 정수 입력 : 10
10 -> 소수 아님

임의의 정수 입력 : 11
11 -> 소수
계속하려면 아무 키나 누르세요...

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Test050
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		//내 풀이

		int n = 0;		// 입력 받을 숫자

		System.out.print("임의의 정수 입력 : ");
		n = Integer.parseInt(br.readLine());

		if(n == 2)
		{
			System.out.println(n + " → 소수 ");
			return;
		}
		
		int i = 1;
		while(i < n)
		{
			i++;

			if(n % i == 0 || n == 1)
			{
				System.out.println(n + " →  소수 아님");
				break;
			}
			else if( i == n / 2)
			{
				System.out.println(n + " → 소수 ");
				break;
			}
		}
		// 수업 ----------------------------------------------------------
/*
		// 주요 변수 선언
		int num;		// 사용자의 입력값을 담아낼 변수
		int n = 2;		// 입력값을 대상으로 나눗셈 연산을 수행할 변수
						// 2부터 시작해서 1씩 증가
						// ex) 입력값 27 -> n : 2 3 4 5 6 7 8 .. 25 26

		// 연산 및 처리
		System.out.print("임의의 정수 입력 : ");
		num = Integer.parseInt(br.readLine());
		
		// 어떤 값을 입력받은 상태인지 알 수 없지만
		// 이 입력값을 소수로 간주한다.
		// String result = "소수다";
		boolean flag = true;			// num은 소수일 것이다.
		
		while (n < num)
		{
			// 테스트
			//System.out.println("반복문 수행 -> n : " + n);

			// 확인 연산
			//-- n 으로 num 을 나누어 떨어지는지 확인 -> 나머지가 0인지 확인
			if(num % n == 0)	// 즉, 나누어 떨어지는 상황
			{
				flag = false;
				break;			// 멈추고 빠져나간다
								// break를 감싸는 가장 가까운 반복문
			}
			n++;
		}

		// 테스트
		// System.out.println("flag : " + flag);


		// 결과 출력
		// (최종 결과를 출력하기 전에 추가 확인 -> 1인지 아닌지에 대한 추가 검토)
		if(flag == true && num != 1) //flag 자체가 true 혹은 false이기 때문에 == true는 필요없다.
		{
			// 소수
			System.out.printf("%d → 소수\n", num);
		}
		else
		{
			// 최종적으로 소수 아님
			System.out.printf("%d → 소수 아님\n", num);
		}
*/
// 결과 실행
/*
임의의 정수 입력 : 991
991 → 소수
계속하려면 아무 키나 누르십시오 . . .
*/
	}
}

입력받은 두 정수 중 작은 수 부터 큰 수 까지의 합을 구하여 결과를 출력하는 프로그램을 구현(051)

실행 예)
첫 번째 정수 입력 : 100
두 번째 정수 입력 : 200
100 ~ 200 까지의 합 : xxxxx
계속하려면 아무 키나 누르세요....

첫 번째 정수 입력 : 1000
두 번째 정수 입력 : 2
2 ~ 1000 까지의 합 : xxxxx

첫 번째 정수 입력 : 10
두 번째 정수 입력 : 10
2 ~ 1000 까지의 합 : 10

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test051
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
/*
		int a,b;			// 입력 받을 값
		int sum = 0;		// 누적합
		int c;				// flag
		
		System.out.print("첫 번째 정수 입력 : ");
		a = Integer.parseInt(br.readLine());

		System.out.print("두 번째 정수 입력 : ");
		b = Integer.parseInt(br.readLine());
		

		// 내 풀이

		if (a > b)
		{
			c = b;
			while(b <= a)
			{
				sum += b;
				b++;
			}
			System.out.printf(">> %d ~ %d 까지의 합 : %d\n", c, a, sum);
		}
		else if(a < b)
		{
			c = a;
			while(a <= b)
			{

				sum += a;
				a++;
			}
			System.out.printf(">> %d ~ %d 까지의 합 : %d\n", c, b, sum);
		}
		else
		{
			sum = a;
			System.out.printf(">> %d ~ %d 까지의 합 : %d\n", a, b, sum);
		}

		// 다른 풀이
		if(a > b)
		{
			a = a ^ b;
			b = b ^ a;
			a = a ^ b;
		}
		int i = a;

		while (a <= b)
		{	
			sum += a;
			a++;
		}
		System.out.printf(">> %d ~ %d 까지의 합 : %d\n", i, b, sum);
*/
		// 주요 변수 선언

		int n;
		int su1, su2;
		int result = 0;		// 누적합

		// 연산 및 처리
		System.out.print("첫 번째 정수 입력 : ");
		su1 = Integer.parseInt(br.readLine());

		System.out.print("두 번째 정수 입력 : ");
		su2 = Integer.parseInt(br.readLine());

		// 입력받은 두 수의 크기 비교 및 자리 바꿈
		if(su1 > su2)
		{
			// 자리 바꿈
			su1 = su1 ^ su2;
			su2 = su2 ^ su1;
			su1 = su1 ^ su2;
		}

		// 반복 연산 수행
		// 반복 연산을 수행하기 전에
		// 작은 수를 따로 저장하여 루프 변수로 활용한다.
		// (결과 출력 과정에서 입력받은 작은 수가 필요한데...
		// 그 수를 반복 과정에서 사용하게 되면...
		// 원래 처음 입력된 값을 확인할 수 없기 때문에..)
		n  = su1

		while(n <= su2)
		{
			result += n;
			n++;
		}

		// 결과 출력
		System.out.printf(">> %d ~ %d 까지의 합 : %d\n", su1, su2);		

	}
}

1 부터 입력받은 그 정수까지의 전체 합과, 짝수의 합과, 홀수의 합을 각각 결과값으로 연산하여 출력하는 프로그램을 구현(052)

실행 예)
임의의 정수 입력 : 396
1 ~ 396 까지 정수의 합 : xxxxx
1 ~ 396 까지 짝수의 합 : xxxx
1 ~ 396 까지 홀수의 합 : xxxx
계속하려면 아무 키나 누르세요...

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test052
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		int n;											// 입력받을 값
		int sum = 0, oSum = 0, eSum = 0;				// 정수합, 홀수합, 짝수합

		System.out.print("임의의 정수 입력 : ");
		n = Integer.parseInt(br.readLine());

		int i = 1;
		while (i <= n)
		{
			sum += i;									// 정수의 합
			if(i % 2 == 0)								// i가 짝수라면
				eSum += i;								// 짝수를 모아 누적합
			else										// i가 짝수가 아니라면
				oSum += i;								// 홀수를 모아 누적합
			i++;										// i를 1 더해준다
		}
		System.out.printf(">> 1 ~ %d 까지 정수의 합 : %d\n", n, sum);
		System.out.printf(">> 1 ~ %d 까지 짝수의 합 : %d\n", n, eSum);
		System.out.printf(">> 1 ~ %d 까지 홀수의 합 : %d\n", n, oSum);

	}
}

구구단 출력(053)

사용자로부터 원하는 단(구구단)을 입력받아
해당하는 구구단을 출력하는 프로그램을 구현한다.
단, 1단 ~ 9단 사이의 수를 입력받은 상황이 아니라면
이에 대한 안내를 한 후 프로그램을 종료할 수 있도록 처리한다.

실행 예)
원하는 단(구구단) 입력 : 7
7 1 = 7
7 2 = 14
7 3 = 21
:
7 9 = 63
계속하려면 아무 키나 누르세요...

원하는 단(구구단) 입력 : 11
1부터 9까지의 정수만 입력이 가능합니다.
계속하려면 아무 키나 누르세요...

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Test053
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
/*
		int n;		// 입력 받을 값
		System.out.print("원하는 단(구구단) 입력 : ");
		n = Integer.parseInt(br.readLine());

		if(n > 9 || n < 1)
		{
			System.out.println("1부터 9까지의 정수만 입력이 가능합니다.");
			return;
		}

		int i = 1;
		while(i <= 9)
		{
			System.out.printf("%d * %d = %d\n", n, i, n * i);
			i++;
		}
*/		// 수업 ------------------------------------------------------------------

		int dan;			// 사용자로부터 입력값을 정수 형태로 담아둘 변수 (단)

		// 연산 및 처리
		System.out.print("원하는 단(구구단) 입력 : ");
		dan = Integer.parseInt(br.readLine());

		if(dan < 1 || dan > 9)
		{
			System.out.println("1부터 9까지의 정수만 입력이 가능합니다.");
			return;
		}

		int n = 0;

		// 결과 출력(반복 출력)
		while (n < 9)
		{
			n++;
			System.out.printf("%d * %d = %d\n", dan, n, dan * n);
		}
	}
}

do while문(054)

/*
○ 개요
   do ~ while문은 while문과 마찬가지로
   특정한 영역을 반복 수행하는 반복문이다.
   다만, while문과 다른 점은
   조건식에 대한 검사를 반복문을 수행한 이후에 한다는 것이다.
   이와 같은 성격으로 인해 반드시 한 번은 수행하게 되는 특징을 갖게된다.

○ 형식 및 구조

   do
   {
	   실행문;
   }
   while(조건식);
*/
public class Test054
{
	public static void main(String[] args)
	{
		// while 반복문을 통해 구현했던 내용들을
		// do~while 문을 통해서도 구현할 수 있다.
		
/*
		int n = 1;
		do
		{
			System.out.println("n=" + n);
			n++;
		}
		while (n <= 10);
*/
/*
		int n = 1;
		do
		{
			n++;
			System.out.println("n=" + n);
		}
		while (n <= 10);
*/
/*
		int n = 0;
		do
		{
			n++;
			System.out.println("n=" + n);
		}
		while (n < 10);
*/
/*
		int n = 0;
		do
		{
			System.out.println("n=" + ++n);
		}
		while (n <= 10);
*/
		
		// do~while 문의 활용 모델
		// 예를 들어
		// 사용자로부터 특정 범위의 정수가 입력될 때 까지
		// 입력받는 행위 자체를 반복해서 수행해야 하는 상황이라 가정한다.

		// 즉, 최소 한 번은 사용자의 입력값을 받아오는 처리를 수행해야
		// 원하는 범위의 값을 제대로 입력했는지 아닌지를 확인할 수 있고
		// 이로 인해 반복을 추가로 수행할지 말지의 여부를 결정할 수 있는 상황이다.

		java.util.Scanner sc = new java.util.Scanner(System.in);

		int num;

		do
		{
			System.out.print("100 이상의 정수를 입력하세요 : ");
			num = sc.nextInt();
		}
		while (num < 100);

		System.out.println(num + " → 100 이상의 정수 입력 완료~!!!");
		
	} 
}

여러 개의 양의 정수를 입력받고 그 합을 계산하여 출력하는 프로그램을 구현(055)

단, 사용자에 의해 -1이 입력되는 순간
입력 행위를 중지하고
그동안 입력된 정수들의 합을 출력해주는 프로그램을 구현한다.
즉, -1 을 입력 중지 커맨드로 활용한다
do~while 문을 활용하여 문제를 해결할 수 있도록 한다.

실행 예)
1번째 정수 입력(-1 종료) : 10
2번째 정수 입력(-1 종료) : 5
3번째 정수 입력(-1 종료) : 8
4번째 정수 입력(-1 종료) : 9
5번째 정수 입력(-1 종료) : 1
6번째 정수 입력(-1 종료) : 1
7번째 정수 입력(-1 종료) : -1

현재까지 입력된 정수의 합 : 34
계속하려면 아무 키나 누르세요...

1번째 정수 입력(-1 종료) : -1

현재까지 입력된 정수의 합 : 0

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Test055
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
/*		내 풀이

		int sum = 0; // 합
		int n;		 // 입력받을 값

		int i = 1;	 // i번째
		do
		{
			System.out.printf("%d번째 정수 입력(-1 종료) : ",i);
			i++;
			n = Integer.parseInt(br.readLine());
			if(n != -1)
				sum += n;
		}
		while (n != -1);

		System.out.printf("\n >> 현재까지 입력된 정수의 합 : %d\n", sum);
*/

		// 수업	----------------------------------------------------------

		// 주요 변수 선언 및 초기화
		int num;			// 사용자의 입력값을 받아낼 정수
		int sum = 0;		// 누적합을 담아낼 변수
		int n = 1;			// 루프 변수로 활용하여 몇 번째 입력값인지를 담아낼 변수
		
		// 연산 및 처리

		do
		{
			System.out.printf("%d번째 정수 입력(-1 종료) : ",n);
			num = Integer.parseInt(br.readLine());
			sum += num;

			n++;
		}
		while (num != -1);		// num이 -1이 아닐 경우

		// 확인(테스트)
		// System.out.println("-1 입력 확인");


		// 결과 출력
		System.out.printf("\n >> 현재까지 입력된 정수의 합 : %d\n", sum + 1);
	}
}

for문(056)

/*
○ 개요

   for 문은 정해진 횟수만큼 반복해야 하는 경우
   유용하게 사용되어지는 반복문으로
   while 문과 마찬가지로 반복 실행해야 하는 구문이
   조건에 맞지 않을 경우 한 번도 수행하지 않을 수 있으며
   루프 변수의 초기값, 조건식, 증감식 등을 한 지점에서 확인할 수 있기 때문에
   가독성이 높은 반복문에 해당한다.


○ 형식 및 구조

   for (수식1; 수식2; 수식3)
   {
	   실행문;
   }

   수식1은 루프 변수의 초기화를 위해 사용되며,
   		   최초 단 한 번만 실행된다.
   수식2는 조건식을 나타내는 것으로 이 조건식(수식2)이 만족하면
           루프를 반복해서 수행하게 된다.
		   for 문의 진행 순서는 수식2가 참이면 반복문을 수행하고
		   수식3을 실행한 후 수식2의 조건식을 다시 검사하는 구조로 진행된다.
		   따라서 처음에 조건식의 처리 결과가 거짓일 경우
		   for 루프를 한 번도 수행하지 않게 되는 것이다.
   수식3은 루프 변수의 재초기화(갱신)를 위해 사용되어지며,
           반복문의 조건식을 무너뜨리게 되는 증감식으로 처리하는 것이 일반적이다.
		   컴마 , 를 이용하여 여러 문장을 동시에 수행할 수도 있다.
*/

public class Test056
{
	public static void main(String[] args)
	{
		int n = 1, m;		// n은 while문 m은 for문에서 사용할 것임

		while (n <= 10)
		{
			System.out.println("n=" + n);
			n++;
		}

		System.out.println();

		// 위의 while문을 for문으로 바꾼다.

		for (m = 1; m <= 10; m++)
			System.out.println("m=" + m);
	}
}

1 부터 100 까지의 정수 중에서 4 의 배수만 출력하는 프로그램을 구현한다.(057)

단, for 문을 활용해야 하며
한 줄에 5개씩만 출력할 수 있도록 한다.

실행 예)
4 8 12 16 20
24 28 32 36 40

public class Test057
{
	public static void main(String[] args)
	{
		// 내 풀이
/*
		for(int i = 1; i <= 100; i++)
		{	
			if(i % 4 == 0)
				System.out.printf("%5d", i);
			if(i % 20 == 0)
				System.out.println();
		}
*/
		for(int n = 4; n <= 100; n+=4)
		{
			System.out.printf("%4d",n);
			if(n % 20 == 0)
				System.out.println();
		}
	}
}

구구단 실습(058)

public class Test058
{
	public static void main(String[] args)
	{
		int i,j;					// 루프 변수

		// 웅 웅 웅
		for (i = 2; i <= 9; i++)	// 단 처리
		{
			//테스트
			//System.out.println("==[ i : " + i + " ]==");
			System.out.printf("\n===[%d단]===\n", i);
			// 쑝쑝쑝
			for (j = 1; j <= 9; j++)				// 곱해지는 수 처리
			{
				//테스트
				//System.out.println("j : " + j);
				System.out.printf("%d * %d = %d\n", i, j, i * j);
			}//end for j
		}//end for i
	}//end main
}// close class Test058

다중 for문 (059)

2 * 1 =  2 3 * 1 =  3 4 * 1 =  4 5 * 1 =  5
2 * 2 =  4 3 * 2 =  6 4 * 2 =  8 5 * 2 = 10
                    :    
2 * 9 = 18 3 * 9 = 27 4 * 9 = 18 5 * 9 = 45

6 * 1 =  6 7 * 1 =  7 8 * 1 =  8 9 * 1 =  9
6 * 2 = 12 7 * 2 = 14 8 * 2 = 16 9 * 2 = 18
					:
6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
  1. 2중첩 두 번
  2. 3중첩 한 번
public class Test059
{
	public static void main(String[] args)
	{
/*		내 풀이

		for(int j = 1; j <= 9; j++)
		{
			for(int i = 2; i <= 5; i++)
			{
				System.out.printf("%d * %d = %2d  ", i, j, j * i);
			}
			System.out.println();
		}

		System.out.println();

		for(int j = 1; j <= 9; j++)
		{
			for(int i = 6; i <= 9; i++)
			{
				System.out.printf("%d * %d = %2d  ", i, j, j * i);
			}
			System.out.println();
		}
*/
/*
		for(int i = 0; i <= 1; i++)
		{
			for(int j = 1; j <= 9; j++)
			{
				for(int k = 2 + i * 4; k <= 5 + i * 4; k++)
				{
					System.out.printf("%d * %d = %2d  ", k, j, k * j);
				}
				System.out.println();
			}
			System.out.println();
		}
*/		// 수업 ------------------------------------------------------------------
		
		// 1.Test058과 비교하여
		//  출력 방향(출력의 순서)가 다르기 때문에
		//  반복문의 제어 흐름도 달라져야 한다.
		//  (한 방향으로 처리되는 콘솔 기반의 출력 환경이기 때문)

		// 2.1에따라
		//   단과 곱해지는 수의 위치가
		//   달라진 상태에서의 반복문 구성
/*
		for (int i = 1; i <= 9; i++)		// 곱해지는 수 1 2 3 4 5 6 7 8 9
		{
			for (int j = 2; j <= 5; j++)	// 단
			{
				System.out.printf("%4d * %d = %2d", j, i, (j * i));
			}
			System.out.println();
		}
		System.out.println();
		for (int i = 1; i <= 9; i++)		
		{
			for (int j = 6; j <= 9; j++)	
			{
				System.out.printf("%4d * %d = %2d", j, i, (j * i));
			}
			System.out.println();
		}
*/
		// 3. 2에서 처리한 결과를
		//    두 문단으로 반복하는 반복문 구성
		//    check 두 번 반복하는 반복문에 2의 결과를 삽입
/*
		for (int h = 0; h <= 1; h++)	// 문단 구성 check
		{
			for(int j = 1; j <= 9; j++)
			{
				for(int k = 2; k <= 5; k++)
				{
					System.out.printf("%d * %d = %2d  ", k, j, k * j);
				}
				System.out.println();
			}
		}
*/
		
		// 4. 같은 구문을
		//    두 문단으로 나누어 처리하는 과정에서
		//    문단에 따라 다르게 주어지는 환경(h의 값)을 활용하는 방법으로
		//    최종 반복문 3중첩 구성

		for (int h = 0; h <= 1; h++)	
		{
			for(int i = 1; i <= 9; i++)
			{
				for(int j = 2; j <= 5; j++)
				{
					System.out.printf("%d * %d = %2d  ", j + (h * 4), i, i  * (j + (h * 4)));
				}
				System.out.println();
			}
			System.out.println();
		}
	}
}

// 실행 결과
/*
2 * 1 =  2  3 * 1 =  3  4 * 1 =  4  5 * 1 =  5
2 * 2 =  4  3 * 2 =  6  4 * 2 =  8  5 * 2 = 10
2 * 3 =  6  3 * 3 =  9  4 * 3 = 12  5 * 3 = 15
2 * 4 =  8  3 * 4 = 12  4 * 4 = 16  5 * 4 = 20
2 * 5 = 10  3 * 5 = 15  4 * 5 = 20  5 * 5 = 25
2 * 6 = 12  3 * 6 = 18  4 * 6 = 24  5 * 6 = 30
2 * 7 = 14  3 * 7 = 21  4 * 7 = 28  5 * 7 = 35
2 * 8 = 16  3 * 8 = 24  4 * 8 = 32  5 * 8 = 40
2 * 9 = 18  3 * 9 = 27  4 * 9 = 36  5 * 9 = 45

6 * 1 =  6  7 * 1 =  7  8 * 1 =  8  9 * 1 =  9
6 * 2 = 12  7 * 2 = 14  8 * 2 = 16  9 * 2 = 18
6 * 3 = 18  7 * 3 = 21  8 * 3 = 24  9 * 3 = 27
6 * 4 = 24  7 * 4 = 28  8 * 4 = 32  9 * 4 = 36
6 * 5 = 30  7 * 5 = 35  8 * 5 = 40  9 * 5 = 45
6 * 6 = 36  7 * 6 = 42  8 * 6 = 48  9 * 6 = 54
6 * 7 = 42  7 * 7 = 49  8 * 7 = 56  9 * 7 = 63
6 * 8 = 48  7 * 8 = 56  8 * 8 = 64  9 * 8 = 72
6 * 9 = 54  7 * 9 = 63  8 * 9 = 72  9 * 9 = 81
*/

9일차

별찍기 실습(60 ~ 63)

/*==========================================
   ■■■ 실행 흐르믜 컨트롤(제어문) ■■■
 - 반복문(for문) 실습 및 관찰
==========================================*/

// ○ 다중 for문(반복문의 중첩)을 활용한 별찍기 실습

// ○ 과제
//    다음과 같은 내용이 출력될 수 있도록
//    반복문의 중첩 구문을 작성하여 프로그램을 구현한다.

// 실행 예)
/*
    *
   **
  ***
 ****
*****
*/

public class Test060
{
	public static void main(String[] args)
	{
/*
		for(int i = 5; i >= 1; i--)				// 다섯 줄 출력
		{
			for(int k = 1; k <= i - 1; k++)		// 공백이 4칸부터 나와야 하므로 i값인 5값에 1부터 빼준다
				System.out.print(" ");
			for(int j = 1; i <= 6 - j; j++)		//
				System.out.print("*");

			System.out.println();
		}
*/
		for(int j = 1; j <= 5; j++)				// 다섯 줄 출력
		{
			for(int i = 1; i <= 5 - j; i++)		// 공백이 4칸부터 갈수록 줄어야 하므로 5에서 j 를 빼준다
			{
				System.out.print(" ");			// 공백 출력
			}
			for(int k = 1; k <= j; k++)			// 별이 1개로 시작해서 5개까지 출력되야 하므로 ,
				System.out.print("*");			// j번째 줄이면 j번만큼 출력되도록 함

			System.out.println();				// 개행
		}

	}
}
/*==========================================
   ■■■ 실행 흐르믜 컨트롤(제어문) ■■■
 - 반복문(for문) 실습 및 관찰
==========================================*/

// ○ 다중 for문(반복문의 중첩)을 활용한 별찍기 실습

// ○ 과제
//    다음과 같은 내용이 출력될 수 있도록
//    반복문의 중첩 구문을 작성하여 프로그램을 구현한다.

// 실행 예)
/*
    *
   ***
  *****
 *******
*********
*/

public class Test061
{
	public static void main(String[] args)
	{
		for(int j = 0; j <= 4; j++)					// 다섯 줄 출력
		{
			for(int i = 1; i <= 4 - j; i++)			// 4개의 공백으로 시작해서 내려갈 때 마다 줄어야 하므로 
			{										// 줄을 나타내는 j를 빼준다
				System.out.print(" ");
			}
			for(int k = 1; k <= 1 + (2 * j); k++)	// 0번째 줄 부터 시작하여 1+(2+j)가 별의 수 이므로 적용한다
				System.out.print("*");

			System.out.println();					// 개행
		}
	}
}
/*==========================================
   ■■■ 실행 흐르믜 컨트롤(제어문) ■■■
 - 반복문(for문) 실습 및 관찰
==========================================*/

// ○ 다중 for문(반복문의 중첩)을 활용한 별찍기 실습

// ○ 과제
//    다음과 같은 내용이 출력될 수 있도록
//    반복문의 중첩 구문을 작성하여 프로그램을 구현한다.

// 실행 예)
/*

*********
 *******
  *****
   ***
    *

*/

public class Test062
{
	public static void main(String[] args)
	{
		for(int j = 4; j >= 0; j--)
		{
			for(int i = 0; i <= 3 - j; i++)
				System.out.print(" ");
			for(int k = 1; k <= 1 + (2 * j); k++)
				System.out.print("*");
	

			System.out.println();
		}
	}
}
/*==========================================
   ■■■ 실행 흐르믜 컨트롤(제어문) ■■■
 - 반복문(for문) 실습 및 관찰
==========================================*/

// ○ 다중 for문(반복문의 중첩)을 활용한 별찍기 실습

// ○ 과제
//    다음과 같은 내용이 출력될 수 있도록
//    반복문의 중첩 구문을 작성하여 프로그램을 구현한다.

// 실행 예)
/*
    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

*/

public class Test063
{
	public static void main(String[] args)
	{
		for(int j = 0; j <= 4; j++)					// 다섯 줄 출력
		{
			for(int i = 1; i <= 4 - j; i++)			// 4개의 공백으로 시작해서 내려갈 때 마다 줄어야 하므로 
			{										// 줄을 나타내는 j를 빼준다
				System.out.print(" ");
			}
			for(int k = 1; k <= 1 + (2 * j); k++)	// 0번째 줄 부터 시작하여 1+(2+j)가 별의 수 이므로 적용한다
				System.out.print("*");
			
			System.out.println();	
			
		}
	}
}

입력받은 수의 합을 구하는 프로그램을 구현(064)

실행 예)

임의의 정수 입력 : -10

임의의 정수 입력 : 0

임의의 정수 입력 : 2023

임의의 정수 입력 : 10
1 ~ 10 까지의 합 : 55
계속하시겠습니까(Y/N)? : y

임의의 정수 입력 : 100
1 ~ 10 까지의 합 : 55
계속하시겠습니까(Y/N)? : N
계속하려면 아무 키나 누르세요 -> 프로그램 종료

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;

public class Test064
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
/*	
		int n;		// 입력 받을 정수
		int sum = 0;
		char c;		// y,Y,n,N
		
		내 풀이 
		do
		{
			do
			{
				System.out.print("임의의 정수 입력 : ");
				n = Integer.parseInt(br.readLine());
				
			}
			while (n < 1 || n > 100);
			sum = 0;
			for(int i = 1; i <= n; i++)
				sum += i;

			System.out.printf(">> 1부터 %d 까지의 합 : %d\n", n, sum);
			System.out.print("계속하시겠습니까(Y/N)? : ");
			c = (char)System.in.read();
			System.in.skip(2);

		}
		while (c == 'y' || c == 'Y');

		수업-----------------------------------------------------------
*/
		// 누적합 변수의 초기화 위치 check
		//int n, s = 0, i;		// n 입력값 s 누적합 i 1부터 1씩 n만큼 증가
		int n,i,s;

		char ch;
		// 프로세스를 계속 진행할지 말지의 여부를 담아둘 변수
		
		while(true)
		{
			// 무한 루프
			do
			{
				System.out.print("\n임의의 정수 입력 : ");
				n = Integer.parseInt(br.readLine());
			}
			while (n < 1 || n > 100);

			// 테스트
			// System.out.println("유효한 정수 입력 완료");

			// 누적합 변수의 초기화 위치 check
			s = 0;

			for(i = 1; i <= n; i++)
				s += i;		// 누적합 연산

			System.out.printf(">> 1 ~ %d 까지의 합 : %d\n", n, s);
			
			System.out.print("계속하시겠습니까(Y/N)? : ");
			ch = (char)System.in.read();	// 계속할지 여부
			
			// 그만이면 빠져나감
			//if (ch == 'n' || ch == 'N')

			if (ch != 'y' && ch != 'Y')		// Y 또는 y 입력한게 아닌거 맞아?
			// || 로 하면 y를 입력했을 때 대문자 Y가 아닌거 맞으므로 true로 처리될 수 있다.
			{
				// 반복문을 멈추고 빠져나갈 수 있는 코드 작성 필요
				// 즉 위와 같은 의사 표현을 했다면
				// 그동안 수행했던 반복문을 멈추고 빠져나가야 한다.
				break;
				// 멈춘다 + 빠져나간다
			}// end if

			// 엔터값(\r\n) 처리
			System.in.skip(2);		
		
		}// end while(true)
	
	}
}

continue 를 활용하여 다음과 같은 처리와 출력이 이루어질 수 있도록 프로그램을 구현(065)

실행 예)

1 : 1
3 : 4
5 : 9
7 : 16
9 : 25
:
99 : 2500
계속하려면 아무 키나 누르세요

public class Test065
{
	public static void main(String[] args)
	{
/*
		int n,m = 0;


		for(int i = 1; i <= 50; i++)
			System.out.printf("%d : %d\n", i + (i - 1), i * i);
		
		int i = 0;
		while(i <= 99)
		{
			i++;
			if(i % 2 == 0)
				continue;		
			m += i;
			System.out.printf("%d : %d\n", i, m);
		}
*/
		int n = 0, s = 0;

		while(n < 100)
		{
			n++;

			if(n % 2 == 0)				// 짝수라면 continue
				continue;

			s += n;
			System.out.println(n + " : " + s);
		}		
	}
}

return 실습(066)

// return 실습

// return 키워드가 지니는 두 가지 의미
//  1. 값의 반환
//  2. 메소드 종료

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Test066
{
	public static void main(String[] args) throws IOException
	{	
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int n,s;

		System.out.print("임의의 정수 입력(10 이상) : ");
		n = Integer.parseInt(br.readLine());

		if (n < 10)
		{
			System.out.println("10 이상의 정수를 입력해야 합니다.");
			return; // 메소드 종료(main 메소드)
		}


		s = 0;
		for (int i = 1; i <= n; i++)
		{
			s+=i;
		}

		System.out.println("결과 : " + s);
	}
}

메소드의 재귀 호출(067)

public class Test067
{
	public static void main(String[] args)
	{	
		showHi(3);
	}

	// showHi() 메소드의 코드 내에서 두 군데 위치 바꾸기
/*	
	public static void showHi(int cnt)
	{
		System.out.println("Hi~ ");
		showHi(cnt--);
		if(cnt == 1)
			return;
	}
*/

	public static void showHi(int cnt)
	{
		System.out.println("Hi~ ");
		if(cnt == 1)
			return;
		showHi(--cnt);
		
	}
}
profile
Organ
이전 포스트

JAVA 1주차

다음 포스트

JAVA 3주차

0개의 댓글