Java 연산자(Operator) 완전 정리

지난 글에서 타입 변환을 살펴봤다. 이번에는 Java 코드 어디서나 등장하는 **연산자(Operator)**를 카테고리별로 체계적으로 정리한다. 연산자는 단순히 기호를 외우는 것을 넘어, 우선순위와 평가 순서를 이해해야 실제 코드에서 예상치 못한 버그를 피할 수 있다.

산술 연산자

가장 기본적인 계산을 담당한다. +, -, *, /, % 다섯 가지와 증감 연산자 ++, --로 이루어진다.

int a = 17, b = 5;
System.out.println(a + b);  // 22
System.out.println(a - b);  // 12
System.out.println(a * b);  // 85
System.out.println(a / b);  // 3  (정수 나눗셈: 소수점 버림)
System.out.println(a % b);  // 2  (나머지)

// 전위(pre) vs 후위(post) 증감
int x = 10;
System.out.println(++x);  // 11 (먼저 증가, 그 값 반환)
System.out.println(x++);  // 11 (반환 후 증가)
System.out.println(x);    // 12

정수끼리 나눌 때 /는 소수점을 버린다. 실수 나눗셈이 필요하면 한쪽을 double로 캐스팅해야 한다.

double result = (double) 17 / 5;  // 3.4

비교 연산자

두 값을 비교해 boolean을 돌려준다. ==, !=, >, <, >=, <= 여섯 가지다.

int score = 85;
System.out.println(score >= 80);  // true
System.out.println(score == 100); // false

String s1 = "hello";
String s2 = new String("hello");
System.out.println(s1 == s2);       // false (참조 비교)
System.out.println(s1.equals(s2));  // true  (값 비교)

==는 기본형에서는 값을, 참조형에서는 메모리 주소를 비교한다. 문자열이나 객체의 내용을 비교할 때는 반드시 equals()를 써야 한다.

논리 연산자와 단락 평가

&&, ||, !, ^가 있으며, &&와 ||는 **단락 평가(short-circuit evaluation)**를 수행한다.

int divisor = 0;
// divisor != 0 이 false → 오른쪽(10/divisor)은 평가하지 않음 → ArithmeticException 방지
boolean safe = divisor != 0 && 10 / divisor > 2;

// true || ... → 오른쪽은 평가되지 않음
boolean flag = true || someExpensiveMethod();

&와 |는 단락 평가 없이 양쪽을 모두 평가하는 비단락 연산자다. 사이드 이펙트가 반드시 필요한 경우가 아니면 &&, ||를 쓰는 것이 일반적이다.

비트 연산자와 시프트

비트 수준 조작이 필요할 때 사용한다. 플래그 관리, 해시 계산, 저수준 알고리즘 등에서 등장한다.

int flags = 0b0000_1010;  // 비트 2, 3이 켜진 상태

// 비트 OR로 플래그 추가
flags |= 0b0000_0001;  // 0b0000_1011

// 비트 AND로 특정 비트 확인
boolean bit1Set = (flags & 0b0000_0010) != 0;  // true

// 시프트
int n = 8;
System.out.println(n << 1);  // 16  (×2)
System.out.println(n >> 1);  // 4   (÷2, 부호 유지)
System.out.println(-8 >>> 1); // 양수 (부호 비트 포함해 0으로 채움)

>> 는 산술 우측 시프트로 부호 비트를 복사하고, >>> 는 논리 우측 시프트로 최상위 비트를 항상 0으로 채운다.

대입 연산자

= 기본 대입과 복합 대입(+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=)이 있다.

int val = 10;
val += 5;   // val = val + 5  → 15
val *= 2;   // val = val * 2  → 30
val >>= 1;  // val = val >> 1 → 15

복합 대입 연산자는 내부적으로 묵시적 캐스팅이 포함되어 있어 주의가 필요하다.

byte b = 10;
b += 5;  // OK: (byte)(b + 5) — 컴파일러가 자동 처리
// b = b + 5;  // 컴파일 에러: int를 byte에 직접 대입 불가

삼항 연산자

condition ? valueIfTrue : valueIfFalse 형태로 간결한 조건부 값 선택에 쓴다.

int temp = 36;
String status = temp >= 37.5 ? "발열" : "정상";

// 중첩 삼항 (가독성을 위해 switch expression 권장)
int score = 82;
String grade = score >= 90 ? "A"
             : score >= 80 ? "B"
             : score >= 70 ? "C"
             : "F";
// grade = "B"

instanceof 와 패턴 매칭

instanceof는 객체의 런타임 타입을 검사한다. Java 16부터 패턴 매칭 instanceof가 정식 도입돼 캐스팅 코드를 제거할 수 있다.

Object obj = "Hello, Java";

// 전통적인 방식
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// 패턴 매칭 (Java 16+)
if (obj instanceof String s) {
    System.out.println(s.length());  // 캐스팅 불필요
}

연산자 우선순위

우선순위가 헷갈릴 때는 괄호 ()를 명시적으로 사용하는 것이 가장 안전하다.

높음	() [] .	후위 ++ --	전위 ++ -- ! ~
↓	산술 * / %	산술 + -	시프트 << >> >>>
↓	비교 < > <= >= instanceof	동등 == !=	비트 & ^ |
낮음	논리 && ||	삼항 ?:	대입 = += …

오버플로와 부동소수점 주의

int max = Integer.MAX_VALUE;  // 2_147_483_647
System.out.println(max + 1);  // -2_147_483_648 (오버플로 — 예외 없음!)

// 큰 수 연산은 long 또는 BigInteger 사용
long safe = (long) max + 1;   // 2_147_483_648

// 부동소수점 정밀도 문제
System.out.println(0.1 + 0.2);  // 0.30000000000000004
// 정확한 금융 계산은 BigDecimal 사용

Java의 정수 연산은 오버플로가 발생해도 예외를 던지지 않고 조용히 래핑(wrap-around)된다. 큰 수를 다룰 때는 long이나 BigInteger를 선택해야 한다.

정리

Java 연산자의 핵심은 세 가지다. 첫째, &&/||의 단락 평가를 활용하면 null 검사나 나눗셈 가드를 간결하게 쓸 수 있다. 둘째, ==는 참조형에서 참조를 비교하므로 **내용 비교엔 equals()**를 쓴다. 셋째, 정수 오버플로는 예외 없이 발생하므로 범위를 의식해야 한다. 우선순위가 불분명하면 괄호로 명확히 하는 습관이 버그를 미연에 방지한다.

---

지난 글: Java 타입 변환(Type Conversion) 완전 정리

다음 글: Java 제어 흐름(Control Flow) 완전 정리

읽어주셔서 감사합니다. 😊