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;
// }
//
// 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("남성입니다.
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 + "는 짝수입니다.
단, 밖은 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("잘못된 숫자가 입력되었습니다.
");
}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("찾지 못했습니다");
}
}
}
