Live Study - Java 가 제공하는 다양한 연산자

학습내용

• 연산자 우선순위
• 산술 연산자
• 비트 연산자
• 관계 연산자
• 논리 연산자
• 삼항 연산자
• assignment(=) operator
• instanceof
• 화살표(->) 연산자
• (optional) Java 13. switch 연산자

---

용어 정리

• 피연산자 - 연산자가 연산을 수행하려면 연산의 대상이 있어야 한다. 이 대상을 '피연산자' 라고 한다. 피연산자로 상수, 변수, 식 등을 사용할 수 있다.
• 식 - 식은 연산자와 피연산자를 조합해 계산하고자 하는 바를 표현한 것을 '식'이라고 한다.
  예) 10 * x + 20

연산자의 종류

종류	연산자
산술 연산자	+, -, *, /, %, <<, >>
비교 연산자	>, <, >=, <=, ==, !=
논리 연산자	&&, ||, !, &, |, ^, ~
대입 연산자	=
기타	(type) 형변환 연산자, ? : 삼항 연산자, instanceof

피연산자의 개수로 연산자를 분류하기도 한다.
피연산자의 개수가 하나면 단항 연산자 두 개면 이항 연산자, 세 개면 삼항 연산자 라고 부른다.

예) -3-10
위의 식은 두 개의 - 연산자가 있다. 둘 다 같은 기호 - 이지만 처음의 - 는 '부호 연산자' 이고, 두번째 - 는 뺄셈 연산자이다.
서로 다른 연산자(부호 연산자, 뺄셈 연산자)의 기호가 같은데, 이때는 피연산자의 개수로 구분할 수 있다.

---

연산자 우선순위

기본적으로 어떤 연산자가 먼저 실행될지는 상식적으로 보고 판단이 가능한 것 같다. 상식적으로 판단이 가능한 예시들을 쭉 훑어보고 특별히 기억해야할 순서를 따로 공부하는 것이 좋을 것 같다.

-x + 10	단항 연산자가 이항 연산자보다 우선순위가 높기 때문에, x 의 부호를 바꾸고 + 연산이 수행된다.
x + y * 5	*, / 연산자가 +, - 연산자보다 우선순위가 높다.
x + 5 > y * 2	산술연산자 (+, -, *, /, %) 가 비교 연산자 (>, <, >=, <=, ==, !=) 보다 우선순위가 높다.
3 < x && x < 10	비교 연산자가 논리 연산자 (&&, ||) 보다 우선순위가 높다.
result = x + y * 5	대입 연산자 (=) 는 연산자들 중에서 우선순위가 제일 낮다. = 연산자 오른쪽 식의 결과가 result 에 저장된다.

특별히 봐둘 것

x << 3 + 5	비트 연산자 >>, << 는 다른 산술 연산자보다 우선순위가 낮다. 그래서 3 + 5가 먼저 수행되고 비트 연산을 수행한다.
number & 5 == 0	논리 연산자는 비교 연산자보다 우선순위가 낮다. 그래서 5 == 0 이 먼저 수행된다.
x > 0 || x > 5 && x < 10	AND (&&) 연산자는 OR (||) 연산자보다 우선순위가 높다. 이런 경우 괄호를 사용하면 좀 더 명확히 표현할 수 있다. (x > 0 || x > 5) && x < 10

한번 쓱 보기.. 위에서부터 우선순위가 내려간다.

단항 연산자	++  --  +  -  ~  !  (형변환)
산술 연산자	*  /  %
	+  -
	<<  >>
비교 연산자	<  >  <=  >=  instanceof
	==  !=
논리 연산자	&
	^
	|
	&&
	||
삼항 연산자	? :
대입 연산자	=  +=  -=  *=  /=  %=  <<=  >>=  &=  ^=  |=

산술 > 비교 > 논리 > 대입 연산자 순서
단항 > 이항 > 삼항 연산자 순서

산술 연산자에 대해 알아보기 전에 알아야 할 규칙이 있다. '산술 변환'이라는 규칙이라고 한다.

☑︎ 이항 연산자는 두 피연산자의 타입이 일치해야 연산이 가능하다. 때문에 두 피연산자의 타입이 다른 경우 보다 큰 타입으로 일치시킨다.

: byte + int => int + int
: float + int => float + float
: double + float => double + float

☑︎ 피연산자의 타입이 int 보다 작은 타입인 경우 int 로 변환된다.

: int 가 가장 효율적으로 처리할 수 있는 타입이라고 한다.
: char, byte 의 표현범위가 좁아서 연산 중에 오버플로우가 발생할 가능성의 높기 때문이다.

산술 연산자

산술 연산자는 +, -, *, /, % 연산자가 있다.
사칙연산은 일상생활에서도 많이 사용하기 때문에, 프로그램 개발 시 주의해야하는 것들을 위주로 정리해보려고 한다.

1. 0으로 나누면 에러가 발생한다.

> 5 / 0 => 에러

2. 10 / 4 의 결과는 2.5가 아니라 2 이다.

> 나누기 연산자의 피연산자 모두 int 타입인 경우 연산결과 역시 int 타입이기 때문에 소수점을 저장하지 않는다. 
반올림 하지도 않는다.
이런 경우 한 쪽을 실수형으로 형변환을 해야한다. 한 쪽을 형변환하면 다른 한 쪽은 자동 형변환이 되어 올바른 결과를 얻을 수 있다.

> 10 / 4.0f == 2.5f

3. 크기가 작은 자료형의 변수를 큰 자료형의 변수에 저장할 때는 자동으로 형변환되지만, 큰 자료형의 값을 작은 자료형의 변수에 저장하려면 명시적으로 형변환 연산자를 사용해야한다.

@Test
public void test() {
    byte a = 10;
    byte b = 20;
    byte c = a + b; // 오류
}

> a, b는 int 로 형변환되어 계산하기 때문에 연산 결과는 int 형이다.
byte c = (byte)(a + b); 와 같이 변경해야한다.

4. 큰 자료형에서 작은 자료형으로 형변환하면 데이터의 손실이 생길 수 있다.

@Test
public void test() {
    byte a = 10;
    byte b = 30;
    byte c = (byte)(a * b);

    System.out.println(c); // 44
}

> byte의 표현 범위를 벗어나, 300 이 아니라 다른 값이 출력된다.
> byte => int 변환은 2진수 8자리에서 32자리로 변환하는 것이라 데이터 손실이 일어나지 않는다. 원래의 데이터는 유지하고 나머지 비트 자리를 0으로 채우기 때문이다. 반면 int 를 byte 로 변환하면 비트 손실이 발생한다.

byte	10	00001010
int	10	00000000  00000000  00000000  00001010

int	300	00000000  00000000  00000001  00101100
byte	44	00101100

5. 이미 오버플로우가 발생한 값을 더 큰 자료형으로 받아도 원하는 값이 들어가지 않는다.

@Test
public void test() {
    int a = 1_000_000;
    int b = 2_000_000;

    long c = a * b;
    System.out.println(c); // -1454759936
}

> 계산하기 전에 (long) a 와 같이 변환해줘야 한다.

6. 5번과 같은 이유로 연산의 순서에 따라 다른 결과를 얻을 수도 있다.

@Test
public void test() {
    int a = 1_000_000;

    int result1 = a * a / a;
    int result2 = a / a * a;

    System.out.println(result1); // -727
    System.out.println(result2); // 1_000_000
}

 

7. 리터럴, 상수 간의 연산은 Run Time 시에 변하는 값이 아니기 때문에, 컴파일 할 때 컴파일러가 계산한다.

@Test
public void test() {
    char c1 = 'a';

    char c2 = c1 + 1; // 오류 발생
    char c3 = 'a' + 1; // b
}

> 컴파일시에 컴파일러가 미리 덧셈연산을 수행하기 때문에 Run Time 시엔 'b'를 c3에 저장할 뿐이다.
> 컴파일러가 대신 계산해서 대체하기 때문에 코드를 더 효율적으로 만든다. (고 한다) 아래는 어떻게 더 효율적으로 만드나 싶어 .class 파일을 역어셈블 해보았다..
자세하게 이해는 안되지만 일단 더 짧은 것이 눈에 보인다. 위쪽이 리터럴 간의 연산이다.

Compiled from "HelloJava.java"
public class HelloJava {
  public HelloJava();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        98
       2: istore_1
       3: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
       6: iload_1
       7: invokevirtual #13                 // Method java/io/PrintStream.println:(C)V
      10: return
}

Compiled from "HelloJava2.java"
public class HelloJava2 {
  public HelloJava2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        97
       2: istore_1
       3: iload_1
       4: iconst_1
       5: iadd
       6: i2c
       7: istore_2
       8: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      11: iload_2
      12: invokevirtual #13                 // Method java/io/PrintStream.println:(C)V
      15: return
}

 

8. 나머지 연산자 % 는 왼쪽 피연산자를 오른쪽 피연산자로 나누고 난 뒤의 나머지를 반환하는 연산자이다.

> 5 % 3 == 2
> 피연산자로 정수만 허용된다.

 

관계 연산자

두 피연산자를 비교하는데 사용된다. 결과값은 true, false 중 하나이다.
관계연산자 역시 이항 연산자이므로 비교하는 두 피연산자의 자료형이 다른 경우 더 큰 자료형으로 자동 변환해 비교하는 것을 주의해야 한다.

대소비교 연산자

>	왼쪽 값이 크면 true, 아니면 false
<	왼쪽 값이 작으면 true, 아니면 false
>=	왼쪽 값이 크거가 같으면 true, false
<=	왼쪽 값이 작거나 같으면 true, false

등가비교 연산자

==	두 피연산자가 같으면 true, 아니면 false
!=	두 피연산자가 다르면 true, 아니면 false

= 는 대입 연산자이다.

두 피연산자의 자료형이 다른 경우 큰 쪽으로 형변환되어 계산하기 때문에 다음의 식은 true 이다.
=> 'A' == 65 => true
=> 10 == 10.0f => true

다만 실수형의 비교는 오차가 발생할 수 있기 때문에 주의해야한다. 다음 식은 false 이다.
=> 0.1 == 0.1f => false

논리 연산자

논리 연산자에는 && (AND), || (OR), ! (NOT) 이 있다.
AND 연산자는 두 피연산자 모두 true일 때 true를 반환하고, OR 은 한 쪽만 true 이면 true를 반환한다. NOT은 true 이면 false, false 이면 true 를 반환한다. 논리 연산자는 피연산자로 boolean 형이나 boolean 값을 반환하는 조건식만 허용한다.

&& (AND)	&& 연산자 양쪽의 조건이 모두 true 이어야 true, 한 쪽 이라도 false 이면 false
|| (OR)	|| 양쪽의 조건 중 한 쪽만 true 이면 true, 양 쪽 모두 false 이면 false
! (NOT)	true 이면 false, false 이면 true

논리 연산자를 사용할 땐 피연산자의 위치에 따라 조금 더 효율적인 연산을 하게 만들 수 있다.
&& 연산의 경우 어느 한 쪽이 false 이면 연산결과가 false 이다. 따라서 왼쪽 조건의 결과가 false 이면 오른쪽 조건은 평가하지 않는다.
|| 은 어느 한 쪽이 true 이면 연산결과가 true 이므로 왼쪽 조건의 결과가 true 이면 오른쪽 조건은 평가하지 않는다. 이를 참고해 좀 더 효율적인 연산을 하도록 코드를 작성할 수 있다.

비트 연산자

비트 연산자에는 &, |, ^, ~, <<, >> 가 있다.
비트 연산자는 피연산자를 비트 단위로 논리 연산한다. 피연산자로 정수만 허용되고, 피연산자를 2진수로 표현했을 때 각 자리를 연산자에 따라 연산을 수행한다.

| (OR)	피연산자 중 한 쪽의 값이 1이면 1, 둘 다 0 이어야 0
& (AND)	피연산자 중 양 쪽이 모두 1 이어야 1, 한 쪽 이라도 1 이면 1
^ (XOR)	피연산자 중 값이 서로 다를 때만 1, 같을 때는 0
~	0 은 1 로, 1 은 0으로 바꾼다.

X	Y	X | Y	X & Y	X ^ Y
1	1	1	1	0
1	0	1	0	1
0	1	1	0	1
0	0	0	0	0

비트 연산에서도 피연산자의 타입을 일치시키는 자동 형변환이 일어날 수 있다.
byte 자료형에 대해 비트 연산을 하면 결과값은 int 형이 반환된다.

@Test
public void test() {
    byte a = 10;
    byte b = ~a; // 오류
}

 

X	~X
1	0
0	1

~ 연산자로 비트를 전환하고 나면 부호있는 타입의 피연산자는 부호가 반대로 변경된다. 피연산자의 1의 보수를 얻을 수 있다. 그래서 ~ 연산자를 1의 보수 연산자라고도 한다.

쉬프트 연산자 >>, << 는 피연산자를 2진수로 표현했을 때 각 자리를 >> (오른쪽), << (왼쪽)으로 옮긴다.

예를 들면 
1. 10진수 8은 2진수로 '0 0 0 0 1 0 0 0 (8)' 이다. 
2. 8 << 2 를 하면        '0 0 1 0 0 0 0 0 (32)' 가 된다.
3. 비트 자리 이동으로 저장 범위를 넘어간 값은 버려지고, 빈 자리는 0으로 채워진다.

쉬프트 연산자는 다른 이항연산자들과는 다르게 피연산자의 타입을 일치시킬 필요가 없기 때문에 자동 형변환이 일어나지 않는다.

<< 연산자의 경우 왼쪽 피연산자의 부호에 상관없이 왼쪽으로 이동시키기 때문에 빈칸을 0으로만 채운다. >> 연산자는 오른쪽으로 이동시키기 때문에 왼쪽 피연산자가 음수일 경우 빈자리를 1로 채운다. (양수일 때는 0으로 채운다)

삼항 연산자 ? :

평소 당연히 삼항 연산자는 삼항 연산자! 라고 생각했었는데 다시 생각해보니 삼항 연산자는 피연산자 세 개를 필요로 하는 연산자를 지칭하는 연산자이다. 책을 보니 조건 연산자라는 이름을 발견했다. 삼항 연산자는 조건 연산자 하나뿐이라 자연스럽게 삼항 연산자 삼항 연산자 한 것 같다.

조건식 ? 식1 : 식2

조건식이 참이면 식1 을 반환하고 거짓인 경우 식2를 반환한다. 

int result = 5 > 3 ? 5 : 3; 
result => 5

삼항 연산자를 중첩해서 사용할 수도 있다. 아래의 식은 x 가 양수면 1, 0이면 0, 음수면 -1 을 반환한다.

x > 0 ? 1 : x == 0 ? 0 : -1;

삼항 연산자의 결합규칙은 오른쪽에서 왼쪽이다. 그래서 x == 0 ? 0 : -1 연산이 먼저 수행된다. 

삼항 연산자를 여러번 중첩해 코드를 작성하면 간략해지긴 하겠지만, 가독성이 떨어지기 때문에 필요한 경우에만 사용하는 것이 좋겠다.

대입 연산자 =

대입 연산자 = 는 변수와 같은 저장공간에 값이나 식의 결과를 저장하는데 사용된다. = 연산자는 연산자들 중 가장 낮은 우선순위를 가지고 있어서 가장 나중에 수행된다.

= 연산자는 오른쪽 피연산자의 값을 왼쪽 피연산자에 저장한다. 저장된 값을 연산결과로 반환한다.

@Test
public void test() {
    int x;
    System.out.println(x = 5); // 5 출력
}

대입 연산자의 오른쪽 피연산자는 변수, 상수, 식 등 모두 가능하지만 왼쪽 피연산자는 변수처럼 값을 저장할 수 있는 것이어야 한다. 왼쪽 피연산자로 리터럴이나 상수같이 값을 저장할 수 없는 것들은 올 수 없다.

복합 대입 연산자

대입 연산자는 다른 연산자와 결합해 사용될 수 있다. 

+=	i += 5;	i = i + 5;
-=	i -= 5;	i = i - 5;
*=	i *= 5;    i *= 10 + j	i = i * 5;        i = i * (10 + j);
/=	i /= 5;	i = i / 5;
%=	i %= 5;	i = i % 5;
<<=	i <<= 5;	i = i << 5;
>>=	i >>= 5;	i = i >> 5;
&=	i &= 5;	i = i & 5;
^=	i ^= 5;	i = i ^ 5;
|=	i |= 5;	i = i | 5;

 

instanceof

instanceof 연산자는 참조변수가 참조하고 있는 인스턴스의 실제 자료형을 알기 위해 사용한다.
왼쪽에는 참조변수를, 오른쪽에는 타입을 작성한다. 

instanceof 연산의 결과가 true 라는 것은 오른쪽 피연산자의 타입으로 형변환이 가능하다는 것을 뜻한다.
이후에 class 를 학습할 때 더 많은 것을 정리해볼 수 있을 것 같다.

화살표, -> 연산자

화살표 연산자는 java 8 부터 지원하는 람다, lambda 표현식의 일부분이다. 

(n) -> n*n

() -> {
    System.out.println("{ } 사용가능!");
    return true;
}

위의 예시가 람다식인데, -> 는 매개변수와 본문을 구분하는 역할을 한다. 
매개변수가 필요하지 않을 때는 왼쪽 매개변수가 비어있을 수 있고, 람다식 본문은 람다식의 동작을 정의하며 { } 로 감싸서 표현할 수도 있고 식의 결과를 바로 반환하는 경우 { } 를 생략할 수 있다.

Java 13. switch 연산자

Java 12 부터 switch 는 식으로 사용할 수 있게 되었다.
기존의 switch 문은 break; 도 하나하나 사용했어야 하고 반복적인 코드도 많이 들어갔는데 이런 부분이 개선되었고, 특별히 식으로 사용할 수 있게 된 것이 눈에 띈다. 식으로 사용할 수 있기 때문에 결과값을 반환할 수 있다. 위에서 본 화살표 연산자 -> 와 함께 쓰이면 좀 더 명시적으로 보이는 것 같다. yield 키워드도 함께 사용될 수 있고, break 문이 없는게 보인다! yield 는 return 문 같은 느낌이다. 아래는 예시 코드.

아직 preview 단계이기 때문에 컴파일 시나 실행 시에 --enable-preview 옵션을 주어야 한다.

private int getIntValue(String str) {
    int result = switch (mode) {
        case "a", "b" -> 1;
        case "c" -> 2;
        case "d", "e", "f" -> {
            System.out.println("{ } 블록도 사용 가능!");
            yield 3;
        }
        default -> -1;
    };
    return result;
}

 

Reference

- 자바의 정석 (남궁 성) (www.yes24.com/Product/Goods/24259565)
- mkyong.com/java/java-13-switch-expressions/
- nipafx.dev/java-13-switch-expressions/