스터디/whiteship - live-study
[백기선님 라이브 스터디] 3주차 - 연산자
똧이
2022. 4. 11. 02:41
반응형
목차
(optional) Java 13. switch 연산자
산술 연산자(+ - * / %)
사칙 연산자(+,-,*,/)와 나머지 연산자(%)
public class OperatorEx5 {
public static void main(String[] args) {
int a = 10;
int b = 4;
// + 덧셈 연산자 (정수형, 실수형 리터럴, 문자열 연산에도 사용 가능)
System.out.printf("%d + %d = %d%n", a, b, a + b); // 10 + 4 = 14
// - 뺄셈 연산자
System.out.printf("%d - %d = %d%n", a, b, a - b); // 10 - 4 = 6
// * 곱하기 연산자
System.out.printf("%d * %d = %d%n", a, b, a * b); // 10 * 4 = 40
// / 나누기 연산자
System.out.printf("%d / %d = %d%n", a, b, a / b); // 10 / 4 = 2
// / 나누기 연산자(타입이 다른 두 수)
System.out.printf("%d / %f = %f%n", a, (float)b, a / (float)b); // 10 / 4.000000 = 2.500000
// % 나머지 연산자
System.out.printf("%d %% %d = %d%n", a, b, a % b); // 10 % 4 = 2
}
}
- 나누기 연산자: int 타입은 소숫점 아래를 저장하지 못하므로 실수형으로 변환해 연산을 수행해야 함
- ex. 10 / 4.0f → 10.0f / 4.0f ⇒ 2.5f
- 연산 결과 역시 float타입
- 피연산자가 정수형인 경우 나누는 수를 0으로 사용 불가
- 0으로 나누면 컴파일은 정상적으로 되지만 실행 시 오류(ArithmeticException) 발생
- 실수형으로 나눌 경우 결과는 Infinity(무한대)
- 피연산자가 유한수가 아닌 경우 연산 결과
x y x/y x%y 유한수 +-0.0 +-Infinity NaN 유한수 +-Infinity +-0.0 x +-0.0 +-0.0 NaN NaN +-Infinity 유한수 +-Infinity NaN +-Infinity +-Infinity NaN NaN
비트 연산자(& | ^ ~ << >>)
피연산자를 비트 단위로 논리 연산. 피연산자로 실수는 허용 X, 정수(문자 포함)만 허용됨
- & (AND연산자): 피연산자 양 쪽 모두 1이어야만 1을 결과로 얻음. 그 외에는 0을 얻음
- | (OR연산자): 피연산자 중 한 쪽의 값이 1이면, 1을 결과로 얻음. 그 외에는 0을 얻음
- ^ (XOR연산자): 피연산자의 값이 서로 다를 때만 1을 결과로 얻음. 같을 때는 0을 얻음
- ~ (비트전환연산자): 피연산자를 2진수로 표현했을 때 0은 1, 1은 0으로 바꿈. 논리부정연산자 !와 유사
- 10진수 10을 비트전환 연산한 결과: -11
- A<<B (쉬프트 연산자, left shift): A의 비트를 왼쪽으로 N만큼 이동
- x << n은 x * $2^n$
- 피연산자의 부호에 상관없이 각 자리를 왼쪽으로 이동시키며 빈칸을 0으로 채움
- ex. 8 << 2 → 왼쪽 피연산자인 10진수 8의 2진수를 왼쪽으로 2자리 이동
- A>>B (쉬프트 연산자, right shift): A의 비트를 오른쪽으로 N만큼 이동
- x >> n은 x / $2^n$
- 부호있는 정수는 부호를 유지하기 위해 왼쪽 피연산자가 음수인 경우 빈자리를 1로 채움. 양수일 때는 0으로 채움
- A>>>N (부호가 없는 시프트 연산자, unsigned right shift): A의 2진수를 우측으로 비트를 N만큼 이동
- 부호를 신경쓰지 않고 모든 비트 값들을 오른쪽으로 이동시킨 후에 왼쪽의 빈 공간은 모두 0으로 채움
public class OperatorEx6 {
public static void main(String[] args) {
int a = 15; // 1111
int b = 6; // 0110
int c = -15; // 11111111111111111111111111110001
int n = 2;
// & AND 연산
System.out.println("a & b = " + (a & b)); // 6 (0110)
// | OR 연산
System.out.println("a | b = " + (a | b)); // 15 (1111)
// ^ XOR 연산
System.out.println("a ^ b = " + (a ^ b)); // 9 (1001)
// ~ 반전 연산자
System.out.println("~c = " + ~c); // -16
// << 시프트 연산자 (좌측으로 비트를 이동(
System.out.println("a << n = " + (a << n)); // 60 (111100)
// >> 시프트 연산자 (우측으로 비트를 이동)
System.out.println("a >> n = " + (a >> n)); // 3 (0011)
// >>> 부호가 없는 시프트 연산자
System.out.println("a >>> n = " + (a >>> n)); // 3 (0011)
System.out.println("c >>> n = " + (c >>> n)); // 1073741820 (00111111111111111111111111111100)
}
}
관계 연산자(< > <= >= == !=, 비교 연산자)
- 연산 결과 타입: boolean
- 대소비교 연산자: < > <= >=
- 기본형 중에서 boolean형을 제외한 나머지 자료형에 사용 가능. 참조형 사용 불가
- 등가비교 연산자: == !=
- 기본형, 참조형 등 모든 자료형에 사용 가능
- == : 두 값이 같으면 true, 다르면 false
- != : 두 값이 다르면 true, 같으면 false
- A < B : B 값이 크면 true, 아니면 false
- A > B : A 값이 크면 true, 아니면 false
- A <= B : B 값이 크거나 같으면 true, 아니면 false
- A >= B : A 값이 크거나 같으면 true, 아니면 false
public class OperatorEx7 {
public static void main(String[] args) {
int a = 12;
int b = 5;
int c = 12;
String str = "5";
// ==
System.out.println("a == b = " + (a == b)); // a == b = false
System.out.println("a == c = " + (a == c)); // a == c = true
System.out.println("'A' == 'B' = " + ('A' == 'B')); // 'A' == 'B' = false
// !=
System.out.println("a != b = " + (a != b)); // a != b = true
System.out.println("a != c = " + (a != c)); // a != c = false
System.out.println("'A' != 'B' = " + ('A' != 'B')); // 'A' != 'B' = true
// A < B
System.out.println("a < b = " + (a < b)); // a < b = false
System.out.println("b < a = " + (b < a)); // b < a = true
// A > B
System.out.println("a > b = " + (a > b)); // a > b = true
System.out.println("b > a = " + (b > a)); // b > a = false
// A <= B
System.out.println("a <= b = " + (a <= b)); // a <= b = false
System.out.println("b <= a = " + (b <= a)); // b <= a = true
System.out.println("a <= c = " + (a <= c)); // a <= c = true
// A >= B
System.out.println("a >= b = " + (a >= b)); // a >= b = true
System.out.println("b >= a = " + (b >= a)); // b >= a = false
System.out.println("a >= c = " + (a >= c)); // a >= c = true
}
}
논리 연산자(&& || !)
- && (AND 결합): 피연산자 양쪽 모두 true여야 true 결과를 얻음
- || (OR 결합): 피연산자 중 어느 한 쪽만 true여도 true 결과를 얻음
- ! (논리 부정 연산자): 피연산자가 true면 false, false면 true 반환
public class OperatorEx8 {
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 5;
// &&
System.out.println("a == b && a > 5 = " + (a == b && a > 5)); // a == b && a > 5 = true
System.out.println("a == b && a == 5 = " + (a == b && a == 5)); // a > b && a == 5 = false
// ||
System.out.println("a == b || a > 5 = " + (a == b || a > 5)); // a == b || a > 5 = true
System.out.println("a == b || a == 5 = " + (a == b || a == 5)); // a == b || a == 5 = true
// !
System.out.println("a == b = " + (a == b)); // a == b = true
System.out.println("!(a == b) = " + !(a == b)); // !(a == b) = false
}
}
instanceof
참조변수가 참조하고 있는 인스턴스의 실제 타입을 알아보기 위해 사용, 주로 조건문에 사용
참조변수 instanceof 타입(클래스명)
- 결과값 boolean 반환
- Reference Type 만 사용 가능
class Animal {}
class Dog extends Animal{}
class OperatorEx9 {
public static void main(String[] args) {
Animal animal = new Animal();
Dog dog = new Dog();
System.out.println("animal instanceof Animal: " + (animal instanceof Animal)); // animal instanceof Animal: true
System.out.println("animal instanceof Dog: " + (animal instanceof Dog)); // animal instanceof Dog: false
System.out.println("dog instanceof Animal: " + (dog instanceof Animal)); // dog instanceof Animal: true
System.out.println("dog instanceof Dog: " + (dog instanceof Dog)); // dog instanceof Dog: true
}
}
assignment(=) operator
- 오른쪽의 값을 왼쪽 피연산자에 할당
- 객체 참조를 할당하기 위해 사용
화살표(->) 연산자
자바 8 이상의 람다식에서 익명함수를 만들 때 사용
(파라미터) -> { Body }
- 함수형 프로그래밍 표현
- 코드가 간결해 진다는 장점
- @FunctionalInterface 어노테이션을 붙인 인터페이스의 구현체로도 사용 가능
import java.util.Arrays;
public class OperatorEx10 {
public static void main(String[] args) {
int[] arr = new int[5];
Arrays.setAll(arr, (i) -> (int)(Math.random()*5)+1);
// 배열을 채우는데 인터페이스를 매개변수로 받아서 지정
}
// (i) -> (int)(Math.random()*5)+1 부분을 직접 작성한다면
int method(){
return (int)(Math.random()*5)+1;
}
}3항 연산자(Ternary Operator)
- 변수 = (조건) ? true 인 경우 : false 인 경우
public class OperatorEx11 {
public static void main(String[] args) {
int a = 12;
String answer = a > 6 ? "크다" : "작다";
System.out.println("answer = " + answer); // answer = 크다
String answer2 = a > 18 ? "크다" : "작다";
System.out.println("answer2 = " + answer2); // answer2 = 작다
}
}
- 항 연산자 사용 VS if-else 사용
- 3항 연산자: expression
- if-else: statement
연산자 우선 순위
- →: 왼쪽에서 오른쪽으로 결합
- ←: 오른쪽에서 왼쪽으로 결합
| 우선순위 | 연산자 | 내용 | 결합 방향 |
| 1 | (), [] | 괄호 / 대괄호 | → |
| 2 | expr++, expr— | 후위 증가/감소 연산자 | → |
| 3 | ++expr, --expr, +expr , -expr, ~, ! | 전위 증가/감소 연산자, 양/음 부호, 논리/비트 NOT 연산자 | ← |
| 4 | *, /, % | 곱셈 / 나눗셈 /나머지 연산자 | → |
| 5 | +, - | 덧셈 / 뺄셈 연산자 | → |
| 6 | <<, >>, >>> | 비트 왼쪽/오른쪽 Shift 연산자, Unsigned Shift 연산자 | → |
| 7 | <, <=, >, >=, instanceof | 관계 연산자, instanceof | → |
| 8 | ==, != | 와 같은/와 다른 관계 연산자 | → |
| 9 | & | 비트 AND 연산자 | → |
| 10 | ^ | 비트 XOR 연산자 | → |
| 11 | | | 비트 OR 연산자 | → |
| 12 | && | 논리 AND 연산자 | → |
| 13 | || | 논리 OR 연산자 | → |
| 14 | () ? true : false | 삼항 조건 연산자 | ← |
| 15 | =, +=, -=, /=, %=, <<=, >>=, &=, ^=, ~= | 대입/할당 연산자 | ← |
(optional) Java 13. switch 연산자
- Java 12 에서는 콜론(:) 대신 화살표(->) 연산자 사용 가능
- break을 통해 값을 반환
- Java 13 에서는 기존에 사용하던 break이라는 키워드를 yield로 대체(확장)
- Java 14 에서는 해당 기능을 표준으로 제공
public class OperatorEx12 {
public static String monthCheck(int num) {
int days = 0;
switch (num) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
days = 31;
break;
case 4:
case 6:
case 9:
case 11:
days = 30;
break;
case 2:
days = 28;
break;
default:
days = -1;
}
return "입력하신 달은 " + days + "일 입니다.";
}
public static String monthCheck12_1(int num) {
int days = switch (num) {
case 1, 3, 5, 7, 8, 10, 12:
break 31;
case 4, 6, 9, 11:
break 30;
case 2:
break 28;
default:
break -1;
}; return "입력하신 달은 " + days + "일 입니다.";
}
public static String monthCheck12_2(int num) {
int days = switch (num) {
case 1, 3, 5, 7, 8, 10, 12 -> 31;
case 4, 6, 9, 11 -> 30;
case 2 -> 28;
default -> -1;
};
return "입력하신 달은 " + days + "일 입니다.";
}
public static String monthCheck13_1(int num) {
int days = switch (num) {
case 1, 3, 5, 7, 8, 10, 12:
yield 31;
case 4, 6, 9, 11:
yield 30;
case 2:
yield 28;
default:
yield - 1;
}; return "입력하신 달은 " + days + "일 입니다.";
}
public static String monthCheck13_2(int num) {
int days = switch (num) {
case 1, 3, 5, 7, 8, 10, 12 -> 31;
case 4, 6, 9, 11 -> 30;
case 2 -> 28;
default -> {
System.out.println("잘못 입력했습니다.");
yield - 1;
}
};
return "입력하신 달은 " + days + "일 입니다.";
}
}
단항 연산자
- 증감 연산자: ++ --
- 증가 연산자(++): 피연산자의 값을 1 증가
- 감소 연산자(--): 피연산자의 값을 1 감소
타입 설명 사용예 전위형 값이 참조되기 전에 증가 j = ++i; 후위형 값이 참조된 후에 증가 j = i++; public class OperatorEx1 { public static void main(String[] args) { int i = 5; i++; // i = i + 1; System.out.println("i = " + i); // i = 6 i = 5; ++i; System.out.println("i = " + i); // i = 6 } } class OperatorEx2 { public static void main(String[] args) { int i = 5, j = 0; j = i++; System.out.println("i++; 실행 후, i = " + i + ", j = " + j); // i++; 실행 후, i = 6, j = 5 i = 5; j = 0; j = ++i; System.out.println("++i; 실행 후, i = " + i + ", j = " + j); // ++i; 실행 후, i = 6, j = 6 } } class OperatorEx3 { public static void main(String[] args) { int i = 5, j = 5; System.out.println(i++); // 5 System.out.println(++j); // 6 System.out.println("i = " + i + ", j = " + j); // i = 6, j = 6 } }
- 부호 연산자: + -
- boolean, char형을 제외한 기본형에만 사용 가능
- : 피연산자의 부호를 반대로 변경한 결과를 반환(음수면 양수, 양수면 음수)
class OperatorEx4{ public static void main(String[] args) { int i = -10; i = +i; System.out.println(i); // -10 i = -10; i = -i; System.out.println(i); // 10 } } - boolean, char형을 제외한 기본형에만 사용 가능
출처
https://lob-dev.tistory.com/entry/Live-StudyWeek-03-연산자
https://github.com/sombrero104/java-study/blob/master/w3.md
https://www.notion.so/3-f3a94e0092664d8aa1debe7e88dec43b
https://kils-log-of-develop.tistory.com/336#산술-연산자
https://www.aladin.co.kr/shop/wproduct.aspx?ItemId=76083001 자바의 정석 - 남궁성
728x90