JAVA 단항 연산자 [코딩백과 with JAVA]

단항 연산자 (Unary Operators)

단항 연산자는 하나의 피연산자를 받아 결과를 반환하는 연산자입니다. Java에서는 다음과 같은 주요 단항 연산자들을 제공합니다:

1. 단항 플러스(+)
2. 단항 마이너스(-)
3. 전위 증가(++)
4. 후위 증가(++)
5. 전위 감소(--)
6. 후위 감소(--)
7. 논리 부정(!)

단항 연산자 사용 예시

public class AdvancedUnaryOperators {
    public static void main(String[] args) {
        // 부호 연산자 (+, -)
        int positiveNumber = +5;
        int negativeNumber = -positiveNumber;
        System.out.println("Positive number: " + positiveNumber);
        System.out.println("Negative number: " + negativeNumber);

        // 증감 연산자 (++ , --)
        int counter = 5;
        System.out.println("Initial counter: " + counter);
        System.out.println("Pre-increment: " + ++counter);
        System.out.println("Post-decrement: " + counter--);
        System.out.println("After post-decrement: " + counter);

        // 논리 부정 연산자 (!)
        boolean flag = true;
        System.out.println("Original flag: " + flag);
        System.out.println("Negated flag: " + !flag);
        System.out.println("Double negation: " + !!flag);

        // 비트 반전 연산자 (~)
        int bitPattern = 15; // 이진수 1111
        System.out.println("Original bit pattern: " + Integer.toBinaryString(bitPattern));
        System.out.println("Bitwise complement: " + Integer.toBinaryString(~bitPattern));

        // 문자열의 논리 부정
        String str = "";
        System.out.println("!str: " + !str.isEmpty());

        // 복잡한 표현식에서의 단항 연산자 사용
        int x = 5;
        int y = 3;
        System.out.println("x++ * --y: " + (x++ * --y));
        System.out.println("After complex operation: x = " + x + ", y = " + y);
    }
}

출력 결과는 다음과 같습니다:

Positive number: 5
Negative number: -5
Initial counter: 5
Pre-increment: 6
Post-decrement: 6
After post-decrement: 5
Original flag: true
Negated flag: false
Double negation: true
Original bit pattern: 1111
Bitwise complement: ffffffe0
!str: true
x++ * --y: 15
After complex operation: x = 6, y = 2

증감 연산자의 순서 의존성

증감 연산자(++와 --)는 피연산자 앞(전위) 또는 뒤(후위)에 배치할 수 있습니다. 이 두 방식의 차이는 연산자의 평가 시점에 있습니다.

public class IncrementDecrementOrderDependence {
    public static void main(String[] args) {
        int x = 5;
        int y = 5;

        // 전위 증가 연산자
        System.out.println("전위 증가 연산자:");
        System.out.println(++x); // 출력: 6
        System.out.println(x); // 출력: 6

        // 후위 증가 연산자
        System.out.println("\n후위 증가 연산자:");
        System.out.println(y++); // 출력: 5
        System.out.println(y); // 출력: 6

        // 복잡한 표현식에서의 차이
        x = 5;
        y = 5;
        System.out.println("\n복잡한 표현식에서의 차이:");
        System.out.println((++x) + (y++)); // 출력: 11
        System.out.println(x + y); // 출력: 12

        // 할당 연산자와 함께 사용
        x = 5;
        y = 5;
        System.out.println("\n할당 연산자와 함께 사용:");
        x = ++y;
        System.out.println("x = " + x); // 출력: x = 6
        System.out.println("y = " + y); // 출력: y = 6

        x = 5;
        y = 5;
        x = y++;
        System.out.println("x = " + x); // 출력: x = 5
        System.out.println("y = " + y); // 출력: y = 6
    }
}

이 예제에서:

1. 전위 증가 연산자(++x)와 후위 증가 연산자(x++)의 차이
2. 복잡한 표현식에서 증감 연산자의 순서가 결과에 미치는 영향
3. 할당 연산자와 함께 사용된 증감 연산자의 동작

출력 결과는 다음과 같습니다:

전위 증가 연산자:
6
6

후위 증가 연산자:
5
6

복잡한 표현식에서의 차이:
11
12

할당 연산자와 함께 사용:
x = 6
y = 6
x = 5
y = 6

주의사항 및 특징

1. 단항 플러스와 마이너스:

   • +는 양의 값을 나타냅니다. 대부분의 경우 생략 가능합니다.
   • -는 음의 갓을 나타냅니다.

2. 증감 연산자의 위치:

   • 전위 증감(++x, --x)는 먼저 값을 변경한 후 평가됩니다.
   • 후위 증감 (x++, x--)는 먼저 현재 값을 사용하고 나서 값을 변경합니다.

3. 논리 부정:

   • 항상 boolean 값을 반환합니다.
   • 조건문에서 자주 사용됩니다.

4. 연산 순서:

   • 단항 연산자는 일반적으로 다른 이항 연산자보다 높은 우선순위를 가집니다.

5. 복잡한 표현식에서의 사용:

   • 증감 연산자가 포함된 복잡한 표현식에서는 전위와 후위의 차이가 중요한 영향을 미칠 수 있습니다.

사용 예시

public class AdvancedUnaryOperations {
    public static void main(String[] args) {
        // 부호 연산자의 특징
        int positive = +5;
        int negative = -positive;
        System.out.println("Positive: " + positive);
        System.out.println("Negative: " + negative);

        // 증감 연산자의 위치에 따른 차이
        int x = 5;
        int y = 10;
        System.out.println("x++ + y: " + (x++ + y)); // 출력: 15
        System.out.println("x: " + x); // 출력: 6
        x = 5;
        y = 10;
        System.out.println("++x + y: " + (++x + y)); // 출력: 16
        System.out.println("x: " + x); // 출력: 6

        // 논리 부정의 사용
        boolean flag = false;
        System.out.println("!flag: " + !flag);
        System.out.println("!!flag: " + !!flag);

        // 비트 반전 연산자의 효과
        int bitPattern = 255; // 이진수 11111111
        System.out.println("Original bit pattern: " + Integer.toBinaryString(bitPattern));
        System.out.println("Bitwise complement: " + Integer.toBinaryString(~bitPattern));

        // 복잡한 표현식에서의 단항 연산자 사용
        int a = 5;
        int b = 3;
        int result = ++a * b-- + a++;
        System.out.println("Result: " + result);
        System.out.println("Final values: a=" + a + ", b=" + b);

        // 문자열과 함께 사용되는 논리 부정
        String str = "";
        System.out.println("!str.isEmpty(): " + !str.isEmpty());
        str = "Hello";
        System.out.println("!str.isEmpty(): " + !str.isEmpty());

        // 배열 인덱싱에서 증감 연산자의 사용
        int[] scores = {90, 85, 95};
        int index = 0;
        System.out.println(scores[index++]); // 출력: 90
        System.out.println(index); // 출력: 1
        System.out.println(scores[++index]); // 출력: 95
        System.out.println(index); // 출력: 2
    }
}

출력 결과는 다음과 같습니다:

Positive: 5
Negative: -5
x++ + y: 15
x: 6
++x + y: 16
x: 6
!flag: true
!!flag: false
Original bit pattern: 11111111
Bitwise complement: ffffffff
Result: 24
Final values: a=7, b=2
!str.isEmpty(): true
!str.isEmpty(): false
90
1
95
2

---

편히 모아진 글 보시려면 아래 위키독스 링크 >>
https://wikidocs.net/book/17111