JAVA 풀스택 캠프 1주차(2부)

2023년 3월 15일 – 연산자(단항 연산자, 산술 연산자, 비교 연산자, 논리 연산자, 대입 연산자, 삼항 연산자, 연산자 우선 순위)

단항 연산자

package com.multi.ex01.single_operator;

//단항연산자
public class SingleOperator {

	public static void main(String() args) {
		// 1. not(!) 연산자: 논리값을 토글(Toggle)하는 용도로 활용
		boolean isTrue = true;

		System.out.println(isTrue);
		System.out.println(!isTrue);
		System.out.println(!!isTrue);

		isTrue = !isTrue;
		System.out.println(isTrue);
		System.out.println("--------------------------");

		// 2. 증감 연산자 ++ --, 전위증감연산자, 후위증감연산자
		int a = 10;

		// 후위 연산은 세미클론 기준으로 뒤에서 더해진다
		System.out.println("a++");
		System.out.println(a++); // 10
		System.out.println(a); // 11

		a = 10;
		System.out.println("++a");
		System.out.println(++a); // 11
		System.out.println(a); // 11

		// ++가 없이 연산하는 전위 연산
//		System.out.println("++a");
//		a = a + 1;
//		System.out.println(a);
//		System.out.println(a);

		// ++가 없이 연산하는 후위 연산
//		System.out.println("a++");
//		a = a + 1;
//		System.out.println(a);
//		System.out.println(a);

	}
}

산술 연산자

package com.multi.ex02.arithmetic_operator;

public class ArithmeticOperator {

	public static void main(String() args) {
		int a = 10;
		int b = 2;
		int c = 0;
		
		System.out.println("사칙연산");
		System.out.println(a + b);
		System.out.println(a - b);
		System.out.println(a * b); //곱셈
		System.out.println(a / b); //나눗셈
		System.out.println(a / 3); // int Type으로 소수점이 버려짐
		System.out.println(a / 3.0); // 소수점 표현법 1 - double로 3.0 사용
		System.out.println(a / (double)3); // 소수점 표현법 2 - 3을 명시적으로 3.0으로 바꾼 문법
		System.out.println((double)(a / 3)); // 안되는 표현법! - 3 -> 3.0 됨

		// /by zero
//		System.out.println(a / 0); //java.lang.ArithmeticException
		
		System.out.println("% 모듈러 연산");
		c = 10 % 3 ; //나머지 연산
		System.out.println(c);
		c = 10 % 2; // 짝수인지 활용할때
		System.out.println(c); //0 = 짝수
		c = 11 % 2; // 홀수인지 활용할때
		System.out.println(c); //1 = 홀수
		
		c = 9 % 3; // 3의 배수인가?
		System.out.println(c); //3의 배수면 0
		
		//if문으로 짝수 필터링하는 방법
		c = 4;
		if(c % 2 == 0) { // 짝수일떼
			System.out.println(c + "는 짝수입니다.");
		
		} else {
			System.out.println(c + "는 홀수입니다.");
		}
		
		
		// 정수 + 실수 사용시 주의점
		// - 사칙연산시 type의 크기가 큰쪽으로 자동으로 형변환됨
		// - double > float > long > int > short > byte
		
		float pi = 3.14f;
		double x = 1.23456789;
		int i = 10;
		
		
		System.out.println(pi + i); // float
		System.out.println(pi + x); // double
		System.out.println(pi + (float)x); // float
		System.out.println((float)(pi + x)); // float

	
	}
}

비교 연산자

package com.multi.ex03.compare_operator;

// 비교연산자
public class CompareOperator {
	public static void main(String() args) {
		int a = 100;
		int b = 200;
		
		System.out.println( a == b ); // a와 b가 같은가?
		System.out.println( a != b ); // a와 b가 같지 않은가?
		System.out.println("----------------------------------");
		
		//문자열 비교 ... *주의 : 이해하기 매우 어려움!!!
		String str1 = "안녕하세요?";
		String str2 = "안녕하세요?";
		String str3 = new String("안녕하세요?");
		
		System.out.println(str1 == str2); // 예측 : true
		System.out.println(str1 == str3); // 예측 : true -> 틀림! false 로 나옴
		
		// String 비교시에는 항상 주의 필요, '=='를 사용하면 틀린결과가 나올 수 있다~
		// 문자열 비교는 equals 메소드를 사용할 것! ★★★★★
		System.out.println(str1.equals(str2)); // 예측 : true
		System.out.println(str1.equals(str3)); // 예측 : true -> 성공
		
		
		// 문자열을 포함하는지 확인하는 함수 = contains
		String str4 = "안녕";
		System.out.println(str1.contains(str2)); // 안녕하세요? - 안녕하세요? 가지고 있는지?
		System.out.println(str1.contains(str4)); // 안녕하세요? - 안녕 가지고 있는지?
		System.out.println("안녕하세요?".contains("하이")); // 안녕하세요? - 하이 가지고 있는지?

		
	}
}

논리 연산자

package com.multi.ex04.logical_operator;

// 논리연산자 = boolean으로만 가능!
public class LogicalOperator {

	public static void main(String() args) {
		boolean x = true;
		boolean y = false;
		boolean z = true;
		
		System.out.println(x && y); // AND 연산: 둘다 참일때만 참
		System.out.println(x || y); // OR 연산: 둘 중 하나라도 참이면 참
		System.out.println(x && y && z); // 3항 AND 연산이 가능!
		System.out.println(x || y || z); // 3항 OR 연산이 가능!
		System.out.println(x || y && z); // 우선순위는 AND가 높음!, 순서 y && z -> x || y, 참!
		System.out.println((x || y) && z); // 연산자 우선순위가 명확하지 않으면 괄호사용!
		System.out. println("---------------------------------------------------");
		// * 괄호는 습관적으로 쳐도 문제 없음! ★★★★★
		
		// 비교 연산자, number만 가능!
		int a = 100;
		int b = 50;
		System.out.println(a > b); //a가 b보다 큰가?
		System.out.println(a < b); //a가 b보다 작은가?
		System.out.println(a >= 100); //a가 100보다 크거나 같은가?
		System.out.println(a <= 100); //a가 100보다 작거나 같은가?
		System.out. println("---------------------------------------------------");
		
		// 비교 연산자 응용
		int c = 70;
		// c는 a보다 작고, b보다는 큰가?
//		System.out.println(a > c > b); //안됨!
//		System.out.println((a > c) > b); //안됨!
		System.out.println(c < a && c > b); //관례적으로 외워야 하는 문법! ★★★★★
		
		// a는 50보다 크고, 150보다 작은가?
		System.out.println(a > 50 && a < 150);
		
		// b는 20이상, 100 미만인가?
		System.out.println(b >= 20 && b < 100);
		
	}
}

작업 관리자

package com.multi.ex05.assignment_operation;

//대입 연산자
public class AssignmentOperator {

	public static void main(String() args) {
	// 가장 기초적인 대입(Assign) 방법
	int a = 10;
	int b = 10;
	
	a = a + 10;
	System.out.println(a);
	
	b += 10; // 위에 표현과 논리적으로 동치하다. 
	System.out.println(b);
		
//	*주의: 앞뒤 바꿔서 사용하면 못잡는다!
//	b =+ 10; // 잘못된 문법이 아니고, b에 +10을 대입한 연산
	System.out.println(b);	// 30? 아니고 10이 출력됨!
		
	// 오칙연산	
	b += 10;        
	b -= 10;        
	b *= 10;        
	b /= 10;        
	b %= 10;        
	
	// Selection mode -> alt + shift + a
	// Selection mode에서는 한글이 잘 안먹힌다. 주의할것!
	
	// 잘못된 연산법 주의 필요!!
	b =+ 10; //b = (+10)
	b =- 10; //b = (-10)
//	b =* 10; //b = (*10) // 문법 오류 발생!
//	b =/ 10; //b = (/10) // 문법 오류 발생!
//	b =% 10; //b = (%10) // 문법 오류 발생!

	}
}

삼항 연산자

package com.multi.ex06.ternary_operator;

// 삼항연산자 + if
public class TernaryOperator {

	public static void main(String() args) {
		int a = 100;
		int b = 50;
		int c = 30;

		// 삼항연산자
		// 문법 : (조건절) ? (참일때 실행되는 문장) : (거짓일때 실행되는 문장)
		String result = a > b ? "a가 b보다 큽니다." : "a가 b보다 작습니다.";
		System.out.println(result);

		// 중첩 사용 -> 권장하지 않음.. 가독성이 좋지 않음 -> if문으로 변경
		// a, b, c를 비교하는 방법
		result = a > b ? (b > c ? "a가 b보다 크고 b는 c보다 큼" : "a가 b보다 크고 b는 c보다 작음")
				: (b > c ? "a가 b보다 작고 b는 c보다 큼" : "a가 b보다 작고 b는 c보다 작음");
		System.out.println(result);

		// 삼항연산자는 if문으로 완벽히 호환된다!
		// if문이란? 논리값을 비교해주는 문법
		// if(조건식) {조건식이 참이면 실행되는 문장}
		// else {조건식이 거짓이면 실행되는 문장!}

		if (a > b) {
			result = "a가 b보다 큽니다";
		} else {
			result = "a가 b보다 작습니다";
		}
		System.out.println(result);

		// 복잡한 삼항연산자 if문으로 바꾸기
//		result = a > b ? (b > c ? "a가 b보다 크고 b는 c보다 큼" : "a가 b보다 크고 b는 c보다 작음") 
//				: (b > c ? "a가 b보다 작고 b는 c보다 큼" : "a가 b보다 작고 b는 c보다 작음");
		if (a > b) {
			if (b > c) {
				result = "a가 b보다 크고 b는 c보다 큼";
			} else {
				result = "a가 b보다 크고 b는 c보다 작음";
			}
		} else {
			if (b > c) {
				result = "a가 b보다 작고 b는 c보다 큼";
			} else {
				result = "a가 b보다 작고 b는 c보다 작음";
			}
		}
		System.out.println(result);

	}
}

운영자 우선순위

package com.multi.ex07.operator_precedence;


// 연산자 우선순위
public class OperatorPrecedence {
	
	public static void main(String() args) {
		// 1. 사칙연산 우선순위
		System.out.println(1 + 2 * 3); // 곱셈이 높음!!
		
		//2. 단항 연산자 우선순위
		int a = 10;
		System.out.println(++a * 10); //단항이 높다!
		
		// 3. 산술 논리 복합될때
		System.out.println(3 + 4 > 5); // 산술이 높음, 7 > 5 = true
		System.out.println((3 + 4) == 5); // 괄호를 통해 우선순위 명시적으로 사용 권장!
		
		// 결론: 복잡하거나 헷갈리면 괄호() 써라!
		
	
	}
}

2023년 3월 16일 – 제어(If 문, Swtich 문, 루프 문, 분기 문)

if 문

package com.multi.ex01.conditional;

public class IfStatement1 {
		// if문 문법
		// if(조건식1) {
		// 		(조건식1이 참일때 실행되는 문장)
		// }
		// else if(조건식2){
		// 		(조건식2가 참일때 실행되는 문장)
		// }
		// .....
		// else {
		// 		(모든 조건이 해당되지 않을때 실행되는 문장)
		// }
		//
		// 조합1 : if
		// 조합2 : if - else
		// 조합3 : if - else if - else
		// 조합4 : if - else if
	
	public static void main(String() args) {
		int a = 6;
		
		// 가장 기본적인 if문 스타일
		if(a == 6) {
			System.out.println("6입니다.");
		}
		
		// if - else문 java 스타일
		if(a % 2 == 0) {
			System.out.println("짝수입니다");
		} else {
			System.out.println("홀수입니다");
		}
		
		// if - else문의 c 스타일 (고전 스타일), 추천 X
		if(a % 2 == 0) 
		{
			System.out.println("짝수입니다");
		} 
		else 
		{
			System.out.println("홀수입니다");
		}
		
		// 중괄호가 없어도 if문 활용 가능!
		// 단, if문이나 else문의 바로 아래 한줄만 실행
		// * 권장하지 않는다!!!
		
		if(a % 2 == 0) 
			System.out.println("짝수입니다");
		 else 
			System.out.println("홀수입니다");
	
		
	}
}


import java.util.Scanner;

public class IfStatement2 {
	public static void main(String() args) {
		Scanner sc = new Scanner(System.in);
		
		System.out.println("숫자를 입력해주세요.");
		int value = sc.nextInt();
		
		//양수, 0, 음수 판별하는 방법
		if(value > 0) {
			System.out.println("양수입니다");
		} else if (value ==0) {
			System.out.println("0입니다");
		} else {
			System.out.println("음수입니다");
			
		}
		
		
		
		// 100, 1000, 10000 보다 작거나 10000보다 큰수를 구별
		if(value < 100) {
			System.out.println("100보다 작습니다");
		} else if (value < 1000) {
			System.out.println("1000보다 작습니다");
		} else if (value < 10000) {
			System.out.println("10000보다 작습니다");
		} else { /*else if (value >= 10000)*/			
			System.out.println("10000이거나 10000보다 큰수입니다");
		}
		
		if (value > 10000) {
			System.out.println("10000보다 큰수입니다");
		} else if(value <= 10000 && value > 1000) {
			System.out.println("10000보다 작습니다");
		}else if(value <= 1000 && value > 100) {
			System.out.println("1000보다 작습니다");
		} else {
			System.out.println("100보다 작습니다");
		}
		
		// 결론: 순서를 정리하면 깔끔하게 짤 수 있고, 순서가 잘못된 경우 조건절이 복잡해진다!
	}
}


import java.util.Scanner;

public class IfStatement3 {
	//강사의 if문 스타일
	// 1. 예외를 먼저 if + return 문으로 필터링한다
	// 2. 정상적인 상황을 아래에 타이핑하여 코드를 구성한다. (0 level로)
	// 이 스타일의 장점: 코드의 복잡도가 줄어든다! (간결해짐)
	
	public static void main(String() args) {
		//로그인 기능
		//ID를 입력 받고 3글자 미만이면 "id가 짧습니다" -> 실패
		//PW를 입력 받고 8글자 미만이면 실패, PW에 ID가 포함되어 있으면 실패
		
		Scanner sc = new Scanner(System.in);
		
		System.out.println("ID를 입력해주세요.");
		String id = sc.nextLine();
		
		// 스파게티 코드에 가깝다 -> 아래 스타일처럼 나오면 리팩토링이 필요하다
		if(id.length() > 3) {
			System.out.println("pw를 입력해주세요");
			String pw = sc.nextLine();
			if(pw.length() < 8) {
				System.out.println("pw가 짧습니다");
			} else {
				if(pw.contains(id) == true) {
					System.out.println("pw에 아이디가 포함되어 있습니다");
				} else {
					System.out.println("로그인에 성공했습니다");
				}
			}
			
		} else {
			System.out.println("id가 짧습니다.");
		}
		
	}
}

import java.util.Scanner;

public class IfStatement4 {
	//강사의 if문 스타일
	// 1. 예외를 먼저 if + return 문으로 필터링한다
	// 2. 정상적인 상황을 아래에 타이핑하여 코드를 구성한다. (0 level로)
	// 이 스타일의 장점: 코드의 복잡도가 줄어든다! (간결해짐)
	
	public static void main(String() args) {
		//로그인 기능
		//ID를 입력 받고 3글자 미만이면 "id가 짧습니다" -> 실패
		//PW를 입력 받고 8글자 미만이면 실패, PW에 ID가 포함되어 있으면 실패
		
		Scanner sc = new Scanner(System.in);
		
		System.out.println("ID를 입력해주세요.");
		String id = sc.nextLine();
		
		if(id.length() < 3) {
			System.out.println("ID가 짧습니다.");
			return; //main(메소드)를 종료하는 키워드
		} 
		
		System.out.println("PW를 입력해주세요.");
		String pw = sc.nextLine();
//		
//		if(pw.length() < 8) {
//			System.out.println("8글자 미만입니다.");
//			return; 
//		}
//		
//		if(pw.contains(id) == true) {
//			System.out.println("PW에 ID가 포함되어 있습니다");
//			return;
//		}
		
		if(pw.length() < 8 || pw.contains(id) == true) {
			System.out.println("PW가 짧거나 PW에 아이디가 포함되어 있습니다!");
			return;	
		}
		
		//로그인 성공 상태 = 정상적인 상태
		System.out.println("로그인에 성공하였습니다.");
	}
}

switch 문

package com.multi.ex01.conditional;

public class SwitchStatement1 {
	
	public static void main(String() args) {
		// 점수가 1등급 ~ 4등급으로 변환하는 방법
		// 1등급: 100 ~ 80점, 2등급 80 ~ 60점 ...

		double score = 70.3;
		int grade = (int)(score / 20);
		
		// switch (이곳에 사용 가능한 Type : int, char, String, (열거형...) ) // double(실수)는 안됨!
		switch (grade) {
			case 5: // 100점
			case 4: // 100점 미만 ~ 80점
				System.out.println("1등급 입니다");
				break;
			case 3: // 80점 미만 ~ 60점 이상
				System.out.println("2등급 입니다");
				break;
			case 2: // 60점 미만, 40점 이상
				System.out.println("3등급 입니다");
				break;
			case 1: // 40점 미만, 20점 이상
			case 0: // 20점 미만, 0점 이상
				System.out.println("4등급 입니다");
				break;
			default : // 예외값 처리
				System.out.println(grade + "는 예외값입니다.");
				// 끝은 break문이 필요 없다!
		}
	}

}

import java.util.Scanner;

public class SwitchStatement2 {
	public static void main(String() args) {
		// 전공성적 입력받기 // ABCDF
		Scanner sc = new Scanner(System.in);
		System.out.println("전공성적을 입력해주세요!");
		char grade = sc.nextLine().charAt(0); // 앞에 한글자 가져오기!
		
		switch(grade) {
			case 'A' :  
			case 'a' :
				System.out.println("A학점입니다.");
				break;
			case 'B' :  
			case 'b' :
				System.out.println("B학점입니다.");
				break;
			case 'C' :  
			case 'c' :
				System.out.println("C학점입니다.");
				break;
			case 'D' :  
			case 'd' :
				System.out.println("D학점입니다.");
				break;
			default : 
				System.out.println("F학점입니다.");
				break;
		}
		
	}
}

import java.util.Scanner;

public class SwitchStatement3 {
	// 상수를 모든 영역에서 공통적으로 활용할때 사용하는 글로벌 변수
	public static final int MEN   = 1;
	public static final int WOMEN = 2;
	public static final int OTHER = 3;
	
	public static void main(String() args) {
		// 성별을 입력받아서 남성, 여성, 그리고 제3의 성까지 구분하고 코드
		System.out.println("성별을 입력해주세요!");
		Scanner sc = new Scanner(System.in);
		String gender = sc.nextLine();
		int genderValue = 0;
		
		switch(gender) {
		case "남" : 	 case "남자" :   case "남성" : 
		case "소년" : case "아저씨" :
			genderValue = MEN;
			break;
		case  "여" : case  "여자" : 
		case  "여성" : case  "소녀" :
			genderValue = WOMEN;
			break;
		default : 
			genderValue = OTHER;
 		}
		
		if(genderValue == MEN) {
			System.out.println("남성입니다.");
		} else if(genderValue == WOMEN) {
			System.out.println("여성입니다.");
		} else {
			System.out.println("제3의 성입니다.");
		}
		
	}
}

루프 문

package com.multi.ex02.loop;

public class LoopStatement1 {

	public static void myFirstWhileLoop() {
		int count = 0;
		while (true) { // true인 경우를 무한 반복문 혹은 무한 루프문이라고 한다.
			System.out.println("무한 반복문" + count++);
		}
	}

	public static void testWhileLoop() {
		int i = 0; // 초기화문, i = index의 약자

		System.out.println("while 루프 시작");
		while (i < 10) { // 조건절, 동작하는 논리식, i는 0 ~ 9까지 돌고, 10은 도달하지 않는다!
			System.out.println(i++);
		}
		System.out.println("while 루프 끝");
		// while문이 활용되는 케이스
		// 1. 무한루프문
		// 2. 끝이 정해지지 않은 탐색이 필요할때! 아래와 같은 케이스

		// 133의 3번째 배수는 몇인가?
		int count = 0;
		while (true) {
			i++;
			if (i % 133 == 0) {
				count++;
				if (count == 3) {
					System.out.println(i);
					break;
				}
			}
		}
	}

	// doWhile 잘 안씀
	// doWhile은 논리값이 틀려도 최초 한번 실행시켜주는 문법
	public static void testDoWhileLoop() {
		int i = 0;
		do {
			System.out.println(i++);
		} while (i < 10);
		System.out.println("do-While문 끝!");

		i = 100;
		do {
			System.out.println("최초로 한번만 실행되는 출력문!");
		} while (i < 10);
	}

	// for문★★★★★ 제일 많이 활용되는 반복문!
	public static void testForLoop() {
		// 이 패턴을 그대로 손으로 외울때까지 쳐보는것을 권장
		// 0부터 시작하고 10까지 도달하지 않는 for문
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		}
		System.out.println("루프 끝1!");

		// 1 ~ 10까지 루프를 돌리고 싶을때
		// 패턴 1 -> 추천하지 않는 문법! why? 배열 index와 일치하지 않아서!
//		int i = 0; // 라인을 줄이기 위해 for문 안으로 들어감!
		for (int i = 1; i <= 10; i++) { // int i는 반복문에서 돌아가는 지역 변수!
			System.out.println(i);
		}
		System.out.println("루프 끝2!");

		// 패턴 2 -> 항상 기본형을 타이핑하고 i를 조작하여 출력하는 것을 권장!
		for (int i = 0; i < 10; i++) {// 0 ~ 9 -> 1 ~ 10?
			System.out.println(i + 1); // i++이 아님
		}
		System.out.println("루프 끝3!");
	}

	public static void main(String() args) {
//		myFirstWhileLoop(); //메소드(함수) 호출(Call)하는 방법
//		testWhileLoop();
//		testDoWhileLoop();
		testForLoop();

	}

}

public class LoopStatement2 {
	// 0 ~ 9까지 홀짝 세기를 while, do-while, for문으로 구현하기
	
	public static void testWhileLoop() {
		int i =0;
		while(i < 10) {
			if(i % 2 == 0) {
				System.out.println(i + "는 짝수입니다.");
			} else {
				System.out.println(i + "는 홀수입니다");
			}
			i++;
		}
	}
	
	public static void testDoWhileLoop() {
		int i = 0;
		do {
			if (i % 2 == 0) {
				System.out.println(i + "는 짝수입니다.");
			} else {
				System.out.println(i + "는 홀수입니다");
			}
			i++;
		} while (i < 10);
	}
	 
	 public static void testForLoop() {
		 for(int i = 0; i < 10; i++) { //기계적으로 나와야하는 문장!!!! ★★★★★★
			 if (i % 2 == 0) {
					System.out.println(i + "는 짝수입니다.");
				} else {
					System.out.println(i + "는 홀수입니다");
				}
		 }
	 }
	
		
	
	public static void main(String() args) {
		testWhileLoop();
//		testDoWhileLoop();
//		testForLoop();
	}
}


public class LoopStatement3_GuGuDan {
	public static void main(String() args) {
		// 구구단은 이차원 for문으로 구성되야 한다 (반복문이 중첩되야 한다!!)
		
		// Step1. 2단 for문을 기계적으로 완성한다. 단, 밖은 i로 안은 j로 변수 선언, 참고 i -> j -> k
		for(int i = 0; i < 10; i++) {
			for(int j = 0; j < 10; j++) {
//				System.out.println(i + "X" + j + " = " + (i*j));
			}
		}
		
		// Step2. 출력을 해보고 i와 j의 시작점과 끝점을 조절하면서 구구단을 완성한다.
		for(int i = 2; i < 10; i++) {
			for(int j = 1; j < 10; j++) {
//				System.out.println(i + "X" + j + " = " + (i*j));
			}
		}
		
		// Step3. 안쪽 반복문 위 아래로 공간이 있다는 것을 활용하자!! -> 데코레이션
		for(int i = 2; i < 10; i++) {
			System.out.println("--------" + i + "단 시작! ---------");
			for(int j = 1; j < 10; j++) {
				System.out.println(i + "X" + j + " = " + (i*j));
			}
			System.out.println("------------------------\n");
		}

	}
}


public class LoopStatement4 {
	public static void main(String() args) {
		
		// for문 응용 -> 2씩 증가하는 반복문
		for(int i = 0; i < 10; i += 2) {
			System.out.println(i);
		}
		
		// for문 조건문 지정 안하기
		for(int i = 0;; i +=2) {
			System.out.println(i);
			if(i == 100) {
				break;
			}
		}
		
		// for문 무한루프문 -> 권장되지 않음
		for(;;) {
			System.out.println("무한루프");
		}
		
		
	}
}

분기문

package com.multi.ex03.branch;

public class BranchStatement1 {

	// 분기문 2가지
	// continue : 반복문에서 흐름을 스킵하는고 위로 올라가는 문장 (단, 반복문은 끝나지 않고 다음 스탭으로 넘어감!)
	// break : 반복문을 벗어나는 문장 (끝나는 문장)

	// 반복문 분기를 종료시키는 3가지 방법
	// break : 반복문이 종료되는 문장 -> 반복문은 끝나지만 반복문 아래가 계속 실행 가능
	// return : 반복문이 포함된 함수를 종료하는 문장 -> 함수 자체가 종료되는 문장
	// System.exit(0) : 프로그램 종료!, 권장하지 않음.

	public static void main(String() args) {
		// 짝수가 아닌 31의 배수를 찾아본다. 범위 : 1 ~ 1000
		// 총 10개가 찾아지면 10번째 수를 출력하고 끝낸다.

		int count = 0;
		for (int i = 0; i <= 1000; i++) {
			if (i % 2 == 0) { // 짝수이면 Skip 필요!
				continue; // 해당 문장을 만나면 아래를 실행하지 않고 i++로 이동
			}
			// 홀수만 들어온다!
			if (i % 31 == 0) { // 31의 배수 찾는 방법
				count++;
				if(count == 10) {
					System.out.println(i); // 10번째 31의 배수 출력!
					break; // 반복문을 종료시키는 키워드
//					return;// 메소드를 종료시키는 문장, main 메소드 밖으로 나간다! -> 밑의 count가 출력되지 않음! (게임 종료 버튼)
//					System.exit(0); // 프로그램 자체를 종료시키는 문장! alt + F4
				}
			}

		}
		
		System.out.println("count: " + count);
	}

}

import java.util.Random;
import java.util.Scanner;

public class BranchStatement2 {
	public static void main(String() args) {
		// 숫자 1 ~ 10까지 랜덤으로 숫자 하나를 뽑고,
		// 여러분들이 5번까지 맞춰서 이기고 지는 게임
		Scanner sc = new Scanner(System.in);
		
//		int randomInt = new Random().nextInt(10); // 0 ~ 9까지 랜덤으로 가져올때 -> 문제에선 틀린 값!
		// 0 1 2 3 4 5 6 7 8 9
		
//		0 = 가위 , 1 = 바위, 2 = 보
		int randomInt = new Random().nextInt(10) + 1; // 1 ~ 10까지 랜덤한 숫자가 뽑힌다.
//		System.out.println(randomInt); // 랜덤 숫자 출력하는 곳
		char randomChar = (char)('A' + new Random().nextInt(5)); // 램덤 문자열 뽑을때!
//		System.out.println(randomChar); //랜덤 문자열 출력하는곳
		
		// 1 2 3 4 5 6 7 8 9 10 
		
//		int randomInt = new Random().nextInt(11); // ? -> 넥슨 사태가 일어난다!! 확률조작...
		
		int i = 5; // 기회 5번!
		boolean isWin = false; // flag = 깃발

		while(i > 0) { // 5 4 3 2 1 ...
			System.out.println("1 ~ 10 숫자 하나를 선택해주세요!");
//			int pickNum = sc.nextInt();
			int pickNum = Integer.parseInt(sc.nextLine());
			
			if(pickNum < 1 || pickNum > 10) {
				System.out.println("잘못된 숫자가 입력되었습니다. 다시 선택해주세요. : " + pickNum);
				continue; // count를 감소시키지 않고 기회 더준다!
			}
			if(pickNum == randomInt) {
				isWin = true;
				break;
			} else {
				System.out.println("틀렸습니다! " + (i-1) + "번 남았습니다.");
			}
			i--;
		}
		
		if(isWin == true) {
			System.out.println("맞췄습니다. 당신이 승리하였습니다.");
		}else {
			System.out.println("당신은 루저입니다!");
		}
		System.out.println("선택 된 숫자 : " + randomInt);
	}
}

2023년 3월 17일 – 배열(기본 배열, 복사 배열, 깊은 배열)

기본 배열

package com.multi.ex01.ArrayBasic;

import java.util.Arrays;

// 배열
public class ArrayBasic {

	public static void main(String() args) {
		System.out.println("1. 배열 기본 생성법");
		
		int() array = null; // null로 초기화가 가능하다? 참조형 변수
		array = new int(10); // 10개 공간을 heap에 생성하고, 0으로 초기화하는 문장
		// 만일 배열을 생성하지 않고 사용하는 경우 -> NullPointerException: Cannot load from int array because "array" is null
		
		System.out.println(array(0));
		System.out.println(array(1));
		
		// 사용자가 직접 배열에 접근하여 초기화하는 방법
		array(0) = 0;
		array(1) = 1;
		array(2) = 2;
		
		//반복문으로 초기화하는 방법
		for(int i = 0; i < 10; i++) { // 정상 문법, in(10)에서 10개 생성했으니 10을 사용하면 된다!
//		for(int i = 0; i <= 9; i++) { // 권장하지 않는 문법! 사용하지 말것!
//		for(int i = 0; i <= 10; i++) { // ArrayIndexOutOfBoundsException : 범위를 벗어난 에러
			array(i) = i;
			System.out.print(array(i) + " ");
		}
		
		System.out.println();
		
		System.out.println("2. 배열 직접 선언하는 방법");
		int() array2 = new int(10); // 표준적인 배열 선언법 ★★★★★
		int() array3 = {1,2,3,4,5,6,7,8,9,10, 11, 12}; // 직접 선언법 ★★★★★
		int() array4 = new int() {1,2,3,4,5,6,7,8,9,10};
//		int() array5 = new int(10) {1,2,3,4,5,6,7,8,9,10}; // 크기를 지정하면 에러 발생!
		
		// Hard 코딩: 사람이 직접 상수나 특정 데이터 값을 기입하는 방법
		// Hard 코딩은 약간 부정적인 표현법으로 문제가 발생할 수 있음.
		// 문제점: 동적인 상황에서 프로그램의 오류를 발생시킴!
		
		//아래의 'i < 20' 이 부분이 하드 코딩되어 있다.
//		for(int i = 0; i < 20; i++) { // 만일 크게 지정한 경우 문제 발생!
//			System.out.println(array3(i));
//		}
		
		// 배열을 순회할 경우 아래의 표현법을 외워야 한다!! ★★★★★
		// array3.length: 배열의 크기를 담은 변수
		for(int i = 0; i < array3.length; i++) {
			System.out.print(array3(i) + " ");
		}
		
		System.out.println("3. 배열 표준적인 사용법");
		int() array5 = new int(12); // 배열 선언 및 크기를 12로 초기화하는 문장
		for(int i = 0; i < array5.length; i++) {
			array5(i) = i;
		}
		
		// 간단하게 출력하는 방법
		System.out.println(Arrays.toString(array5));
		
		// 문자열 배열
		String() strArray1 = new String(5);
		String() strArray2 = {"사과", "바나나", "딸기", "멜론"};
	
		System.out.println(Arrays.toString(strArray2));	
		
	}
}

어레이 복사

package com.multi.ex02.ArrayCopy;

import java.util.Arrays;

public class ArrayCopy {
	// 얕은 복사 : 배열의 주소지만 복사하여 동일한 배열을 활용하는 기법 , 바로가기, link
	// 깊은 복사 : 배열의 주소지가 아니고, 실제 배열을 물리적으로 복사하는 기법, 복사하기, copy
	
	public static void main(String() args) {
		//얕은 복사 해보기
		int() array1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
		int() array2 = array1; //얕은 복사 실행! Shallow copy
		
		System.out.println("변경 전");
		System.out.println(Arrays.toString(array1));
		System.out.println(Arrays.toString(array2));
		
		array1(0) = 5;
		
		System.out.println("변경 후");
		System.out.println(Arrays.toString(array1));
		System.out.println(Arrays.toString(array2));
		
		//깊은 복사 해보기, Deep copy ★★★★★
		int() array3 = null;
		System.out.println("깊은 복사 시작!");

		
		// 1. 고전적인 방법 = 손으로 쓰는 방법
		array3 = new int(array1.length); // 복사 대상과 길이를 똑같이 생성
		for(int i = 0; i < array1.length; i++) {
			array3(i) = array1(i); // 복사!
		}
		
		System.out.println(Arrays.toString(array3));
		
		
		// 2. 복사할때 제일 많이 쓰는 문장 ★★★★★ 매우 유용 -> 길이를 조절할 수 있음
		array3 = Arrays.copyOf(array1, array1.length);

		System.out.println(Arrays.toString(array3));
		
		// 3. 그다음 방법
		array3 = array1.clone();
		
		// 변경
		array1(0) = 10;
		array3(0) = 1000;
		System.out.println("변경 후 1, 3");
		System.out.println(Arrays.toString(array1));
		System.out.println(Arrays.toString(array3));
		
	}
}

행 심화

package com.multi.ex03.Arrays;

import java.util.Arrays;
import java.util.Random;

public class ArraysTest {

		public static void main(String() args) {
			int() array = new int(10);
//			Random r = new Random(System.currentTimeMillis());
			Random r = new Random();
			
			
			//난수로 초기화하는 방법
			for(int i = 0; i < array.length; i++) {
				array(i) = r.nextInt(array.length);
			}
			
			//출력하는 방법
			System.out.println(Arrays.toString(array));
			
			
			//값을 찾는 방법1 - 직접 구현
			int value = 5;
			int index = -1;
			for(int i = 0; i <array.length; i++) {
				if(array(i) == value) {
					index = i;
					System.out.println("탐색 완료!");
					break;
				}
			}
			if(index >= 0) {
				System.out.println("탐색 완료! : " + index);
			} else {
				System.out.println("찾지 못했습니다");
			}
			
			//값을 정렬하는 방법
			Arrays.sort(array);
			System.out.println(Arrays.toString(array));
			
			
			
			
			//값을 찾는 방법2 - binarySearch() // 중복 있으면 안됨!
			int index2 = Arrays.binarySearch(array, value); // 값을 찾으면 index를 반환하고, 없으면 -1을 반환함
			System.out.println(index2);
			if(index2 >= 0) {
				System.out.println("탐색 완료! : " + index2);
			} else {
				System.out.println("찾지 못했습니다");
			}

		}
		
}
error: <b>Alert: </b>Content selection is disabled!!