(3) 연산자
백기선님의 온라인 스터디 "스터디 할래" 3주차 정리 문서입니다. 이 문서는 자바 오라클 문서를 토대로 만들었습니다.
목표
자바가 제공하는 다양한 연산자를 학습하세요.
학습할 것
- 산술 연산자
- 비트 연산자
- 관계 연산자
- 논리 연산자
- instanceof
- assignment(=) operator
- 화살표(->) 연산자
- 3항 연산자
- 연산자 우선 순위
- (optional) switch 연산자 (Java 13)
산술 연산자
자바의 산술 연산자는 다음과 같다.
| 연산자 | 설명 |
|---|---|
| + | 덧셈 연산자 |
| - | 뺄셈 연산자 |
| * | 곱셈 연산자 |
| / | 나눗셈 연산자 |
| % | 나머지 연산자 |
산술 연산자는 "이항 연산자"이다. 기본적으로 다음과 같이 작성한다.
# 피연산자1 연산자 피연산자2
a + b여기서 a, b는 피연산자 +는 연산자이다. 이 때 a, b는 실수형, 정수형 타입이다.(코틀린, 스칼라에서는 연산자를 재정의할 수 있기 때문에 더 많은 타입이 들어갈 수 있다.) 각 연산자는 다음과 같이 작성할 수 있다.
덧셈
@Test
public void test_add(){
int a = 5, b = 3;
// 아래 코드가 덧셈 연산자 쓰는 곳!
int res = a + b;
assertEquals(8, res);
}뺄셈
@Test
public void test_sub(){
int a = 5, b = 3;
// 아래 코드가 뺼셈 연산자 쓰는 곳!
int res = a - b;
assertEquals(2, res);
}곱셈
@Test
public void test_mul(){
int a = 5, b = 3;
// 아래 코드가 곱셈 연산자 쓰는 곳!
int res = a * b;
assertEquals(15, res);
}나눗셈
@Test
public void test_div(){
int a = 5, b = 3;
// 아래 코드가 나눗셈 연산자 쓰는 곳!
int res = a / b;
assertEquals(1, res);
}나머지
@Test
public void test_rem(){
int a = 5, b = 3;
// 아래 코드가 나머지 연산자 쓰는 곳!
int res = a % b;
assertEquals(2, res);
}나눗셈과 나머지 연산은 만약, "피연산자 2"가 0이면 ArithmeticException을 발생시킨다.
// 테스트 코드 실행 중 발생하는 `Exception`을 테스트
// 나눗셈과 나머지 연산은 피연산자 2가 0이면 예외가 발생한다.
@Test(expected = ArithmeticException.class)
public void test_div_failed(){
int a = 5, b = 0;
// 아래 코드가 나눗셈 연산자 쓰는 곳! 피연산자 2(b)가 0
int res = a / b;
assertEquals(1, res);
}
@Test(expected = ArithmeticException.class)
public void test_rem_failed(){
int a = 5, b = 0;
// 아래 코드가 나머지 연산자 쓰는 곳! 피연산자 2(b)가 0
int res = a % b;
assertEquals(2, res);
}비트 연산자
비트 연산자는 정수형 타입에 대해서 "비트 연산"을 한다. 이들은 "산술 연산자"와 마찬가지로 "이항 연산자"이다. 자바에서 제공되는 비트 연산자는 다음과 같다.
| 연산자 | 설명 |
|---|---|
| & | AND 연산 |
| | | OR 연산 |
| ^ | XOR 연산 |
| << | left shift 연산 |
| >> | right shift 연산 |
여기서 비트 연산 AND, OR, XOR은 1, 0에 대해서 다음과 같이 연산된다.
AND
| 0 | 1 | |
| 0 | 0 | 0 |
| 1 | 0 | 1 |
예를 들어 0001 과 0011 을 AND 연산을 하면, 0001의 결과를 가질 수 있다. 코드로 표현하면 다음과 같다.
@Test
public void test_bit_and(){
int a = 0x0001;
int b = 0x0011;
int res = a & b;
assertEquals(0x0001, res);
}OR
| 0 | 1 | |
| 0 | 0 | 1 |
| 1 | 1 | 1 |
예를 들어 0001 과 0011 을 OR 연산을 하면, 0011의 결과를 가질 수 있다. 코드로 표현하면 다음과 같다.
@Test
public void test_bit_or(){
int a = 0x0001;
int b = 0x0011;
int res = a | b;
assertEquals(0x0011, res);
}XOR
| 0 | 1 | |
| 0 | 0 | 1 |
| 1 | 1 | 0 |
예를 들어 0001 과 0011 을 XOR 연산을 하면, 0010의 결과를 가질 수 있다. 코드로 표현하면 다음과 같다.
@Test
public void test_bit_xor(){
int a = 0x0001;
int b = 0x0011;
int res = a ^ b;
assertEquals(0x0010, res);
}Left Shift
Left Shift 비트 연산자는 비트를 왼쪽으로 1bit씩 민다. 예를 들어 0001이 있다면, 0010이 된다. 코드로 표현하면 다음과 같다.
@Test
public void test_bit_left_shift(){
int a = 0x0001; // 0x0001 = 00000001
int res = a << 1;
assertEquals(0x0002, res); // 0x0002 = 00000010
}Right Shift
Right Shift 비트 연산자는 비트를 오른쪽으로 1bit씩 민다. 예를 들어 0010이 있다면, 0001이 된다. 코드로 표현하면 다음과 같다.
@Test
public void test_bit_right_shift(){
int a = 0x0002; // 0x0002 = 00000010
int res = a >> 1;
assertEquals(0x0001, res); // 0x0001 = 00000001
}Right Shift 비트 연산자는 조금 특별한게 있는데, ">>", ">>>" 이렇게 두 가지가 있다. 각각 ">>"는 sign 비트를 유지하고, ">>>" 0을 넣어준다. 무슨 뜻이냐면 코드를 보면 이해할 수 있다.
@Test
public void test_bit_right_shift2(){
int a = -2; // 11111111111111111111111111111110
int res = a >> 1; // 11111111111111111111111111111111
assertEquals(-1, res);
}오른쪽으로 쉬프트할 때, 가장 최상위의 bit가 유지된다. 반면에 ">>>" 연산자를 써보자.
@Test
public void test_bit_right_shift3(){
int a = -2; // 11111111111111111111111111111110
int res = a >>> 1; // 01111111111111111111111111111111
assertEquals(2147483647, res);
}이때는, 상위비트가 유지되지 않고 0으로 채워지며 오른쪽으로 비트가 이동되는 것을 확인할 수 있다.
관계 연산자
각 값을 비교하는 것이 이 연산자의 역할이다. 자바가 제공하는 관계 연산자는 다음과 같다. 역시 이항 연산자이다.
| 연산자 | 설명 |
|---|---|
| == | equal to |
| != | not equal to |
| > | greater than |
| >= | greater than or equal to |
| < | less than |
| <= | less than or equal to |
== 연산자
이 연산자는 기본 타입의 경우 값이 같은지 여부를 판단한다. 참조 타입의 경우 같은 참조를 가지고 있는지 여부를 판단한다.
@Test
public void test_equal_to_primitive_type() {
int a = 5, b = 5;
assertTrue(a == b);
}
@Test
public void test_equal_to_reference_type() {
// 같은 값을 가지나, 참조가 다르다.
Person p1 = new Person(29, "gurumee");
Person p2 = new Person(29, "gurumee");
// 이 연산자의 결과는 실패를 가진다.
assertFalse(p1 == p2);
}!= 연산자
이 연산자는 == 연산자의 반대이다. 값이 다른지 여부를 판단한다. 역시 기본 타입일 때는, 그 값을 참조 타입일 때는 참조에 대해서 판단한다.
@Test
public void test_not_equal_to_primitive_type() {
int a = 5, b = 5;
// a == b 이기 때문에 실패를 반환한다.
assertFalse(a != b);
}
@Test
public void test_not_equal_to_reference_type() {
Person p1 = new Person(29, "gurumee");
Person p2 = new Person(29, "gurumee");
// 서로 다른 참조이기 때문에 참을 반환한다.
assertTrue(p1 != p2);
}> 연산자
이 연산자는 피연산자 1이 피연산자 2보다 큰지 여부를 판단한다.
@Test
public void test_greater_than() {
int a = 7, b = 5;
assertTrue(a > b);
a = 5;
assertFalse(a > b);
}>= 연산자
이 연산자는 피연산자 1이 피연산자 2보다 크거나 같은지 여부를 판단한다.
@Test
public void test_greater_than_or_equal_to() {
int a = 7, b = 5;
assertTrue(a >= b);
a = 5;
assertTrue(a >= b);
}< 연산자
이 연산자는 피연산자 1이 피연산자 2보다 작은지 여부를 판단한다.
@Test
public void test_less_than() {
int a = 3, b = 5;
assertTrue(a < b);
a = 5;
assertFalse(a < b);
}<= 연산자
이 연산자는 피연산자 1이 피연산자 2보다 작거나 같은지 여부를 판단한다.
@Test
public void test_less_than_or_equal_to() {
int a = 3, b = 5;
assertTrue(a <= b);
a = 5;
assertTrue(a <= b);
}논리 연산자
논리 연산자는 AND, OR, NOT이며, 참과 거짓에 대해서 판단한다. 자바에서 제공하는 논리 연산자는 다음과 같다.
| 연산자 | 설명 |
|---|---|
| && | AND |
| || | OR |
| ! | NOT |
AND 연산자
논리적으로 피연산자 2개가 모두 참일 때, 참 그 외에는 거짓을 나타낸다. 피연산자1이 거짓일 경우, 연산은 피연산자1만 하고 넘어간다.
| true | false | |
| true | true | false |
| false | false | false |
코드로 보면 다음과 같다.
@Test
public void test_and() {
int a = 1, b = 2;
assertTrue(a == 1 && b==2);
// a == 1이 거짓이 되기 때문에 False를 반환한다.
a = 3;
assertFalse(a == 1 && b==2);
}OR 연산자
논리적으로 피연산자 2개가 하나라도 참일 때, 참 모두 거짓일 때만 거짓을 나타낸다. 피연산자 1이 참일 경우 연산은 피연산자1만 하고 넘어간다.
| true | false | |
| true | true | true |
| false | true | false |
코드로 보면 다음과 같다.
@Test
public void test_or() {
int a = 1, b = 2;
assertTrue(a == 1 || b==2);
// a == 1이 거짓이 되더라도 b == 2를 만족하기 때문에 True를 반환한다.
a = 3;
assertTrue(a == 1 || b==2);
// a == 1, b == 2를 둘다 불만족하기 때문에 False를 반환한다.
b = 7;
assertFalse(a == 1 || b==2);
}NOT 연산자
피연산자 1개의 논리를 반전시킨다. 참이라면 거짓을, 거짓이라면 참을 반환한다.
| NOT | |
| true | fasle |
| false | true |
코드로 보면 다음과 같다.
@Test
public void test_not() {
int a = 7;
// a == 7 의 논리를 반전시키기 때문에 False가 나온다.
// 아래 코드의 경우 a != 7 로 쓰는게 관례이다.
assertFalse(!(a == 7));
}instanceof
instanceof 연산자는 객체가 어떤 클래스인지 여부를 판단한다. 코드는 다음과 같이 쓸 수 있다.
@Test
public void test_instanceof() {
String s = "test";
assertTrue(s instanceof String);
}인터페이스를 구현 혹은 상위 클래스를 상속하는 하위 클래스가 여러 개 일때 각 클래스마다 다른 동작을 부여하고 싶을 때, 좋은 연산자이다. 이런 식으로 말이다.
@Test
public void test_instanceof2(){
Object [] arr = new Object[] {
1,
"test",
2.0
};
for (Object o : arr) {
if (o instanceof Integer) {
System.out.println("Integer");
} else if (o instanceof Double) {
System.out.println("Double");
} else if (o instanceof String) {
System.out.println("String");
} else {
System.out.println("I don't know type");
}
}
}assignment(=) operator
이거는 값을 할당하는 연산자이다. 여태까지 코드를 봤을 때 쭉 써왔다.
타입 변수 = 값;이런 형태로 쓰는데 코드로 보면 다음과 같다.
int a = 7;위의 경우 a라는 정수형 변수에 7이라는 값을 할당 시킨 것이다. 또한 산술 연산자와 합쳐질 수도 있다.
+=, -=, *=, /=, %=, &=, ^=, !=, <<=, >>=, >>>=화살표(->) 연산자
이것은 자바 8에 추가된 "람다"를 지원하기 위한 연산자이다. 자바에서 람다는 무명 인터페이스와 같다. 먼저 다음의 인터페이스가 있다고 해보자.
public interface IntOperator {
int operate(int a, int b);
}이를 구현하는 클래스를 만들어도 되지만 간단하게 무명 인터페이스를 구현할 수 있다. 다음처럼 말이다.
@Test
public void test_lambda() {
IntOperator op = new IntOperator() {
@Override
public int operate(int a, int b) {
return a + b;
}
};
int res = op.operate(5, 3);
assertEquals(8, res);
}이를 람다식으로 다음과 같이 표현할 수 있다.
@Test
public void test_lambda() {
IntOperator op = (a, b) -> a + b;
int res = op.operate(5, 3);
assertEquals(8, res);
}간단하게 무명 인터페이스 코드를 축약하는 연산자라고 보면 된다. 여기서 무명 인터페이스가 구현하는 인터페이스는 딱 1개의 메소드를 가지고 있어야 한다.
또한, Java 13에서 switch 식과 함께 쓸 수 있다. 이는 아래 절을 참고한다.
3항 연산자
3항 연산자는 if-else문을 축약하는 문법이다. 만약 다음 코드가 있다고 해보자.
@Test
public void test_triple_operator(){
int a = 5, b = 3;
if (a == 5) {
b+=1;
} else {
b-=1;
}
assertTrue(b == 4);
}이 문법을 다음과 같이 축약할 수 있다.
@Test
public void test_triple_operator(){
int a = 5, b = 3;
b = (a == 5) ? (b + 1) : (b - 1);
assertTrue(b == 4);
}기본적으로 다음처럼 쓰면 된다.
(조건문) ? 식1 : 식2조건문이 참일 때 식1이 실행되고 거짓이면 식2가 실행된다.
연산자 우선 순위
다음은 자바가 제공하는 연산자의 우선순위이다.
| 순위 | 연산자 | 표현식 |
|---|---|---|
| 1 | 후위 연산자 | expr++, expr-- |
| 2 | 단항 연산자 | ++expr, --expr, +expr, -expr, ~, ! |
| 3 | 산술 연산자 | *, /, % |
| 4 | 산술 연산자 | +, - |
| 5 | 비트 시프트 연산자 | <<, >>, >>> |
| 6 | 관계 연산자 | <, <=, >, >=, instanceof |
| 7 | 동등 연산자 | ==, != |
| 8 | 비트 연산자 | &, ^, | |
| 9 | 논리 연산자 | &&, || |
| 10 | 삼항 연산자 | ?: |
| 11 | 할당 연산자 | =, +=, -=, *=, /=, %=, &=, ^=, !=, <<=, >>=, >>>= |
switch 표현식 (Java 13)
일반적으로, 자바에서 분기문은 if, if-else, if-else if-else 그리고 switch가 있다. 한 변수에 대해서 여러 분기를 처리할 때 switch문을 쓴다.
@Test
public void test_switch() {
String level = "C";
switch (level) {
case "A":
case "B":
System.out.println("BASIC");
break;
case "C":
System.out.println("EXPERT");
break;
case "D":
case "E":
System.out.println("Professional");
break;
default:
System.out.println("I don't know");
break;
}
}위의 코드는 level에 대해서 "A", "B"면 "BASIC"을, "C"면 "EXPERT"를, "D", "E"면 "Professional"를, 나머지는 "I don't know"를 출력하게 한다.
그런데, 자바 13부터는 switch문이 아니라 switch식이라고 표현된다. 이 말은 switch 가 값을 갖는다는 뜻이다. 다음처럼 쓸 수 있다.
@Test
public void test_switch() {
String level = "C";
String result = switch (level) {
case "A", "B" -> "BASIC";
case "C" -> "EXPERT";
case "D", "E" -> "Professional";
default -> "I don't know";
};
assertEquals("EXPERT", result);
}->이걸 써도 되고 yield를 써도 된다. 다음 처럼 말이다.
@Test
public void test_switch() {
String level = "C";
String result = switch (level) {
case "A", "B": yield "BASIC";
case "C": yield "EXPERT";
case "D", "E": yield "Professional";
default: yield "I don't know";
};
assertEquals("EXPERT", result);
}이 때, 빌드 옵션에 --enable-preview를 주어야 한다. 현재 IDE에서는 에러 표시를 내고 있다. 하하;; 중요한 것은 switch에서 분기되는 값이 result에 할당이 된다는 것이다.