Java ) java 연산자

Chapter 3 : 🧮 계산 하기 (연산자)

📌 Java 프로그래밍 에서는 변수, 상수 들을 계산하기 위해서 연산자를 사용

어떤 연산자들이 있고, 어떻게 연산을 하는지 보기

• 1. 연산자와 피연산자에 대한 이해
     • 연산자 : 덧셈, 뺄셈 처럼 계산할 기호 ➕
     • 피연산자 : 연산자로 인해 계산되는 숫자 🔢
     
     • [코드 스니펫] 계산 코드
     • int x = 5; int y = 10; int z = x + y; // 5(피연산자) +(연산자) 10(피연산자) 계산 System.out.println(z); // 출력값 : 15
  2. 계산할때 계산의 대상이 되는것이 피연산자 이며, 계산의 목적이 되는것이 연산자
  2. 연산자 종류
     • 연산자는 사칙연산 외에도 여러가지 연산자가 있습니다.

     산술 연산자	+ - * / % << >>	사칙 연산과 비트연산
     비교 연산자	> < >= <= == !=	크고 작음과 같고 다름을 비교
     논리 연산자	&&
     대입 연산자	= ++ —-	우변의 값을 좌변에 저장, 연산 복합 대입
     기타 연산자	(type) ? : instance of	형변환 연산자, 삼항 연산자, instance of 연산자
     - 산술 연산자
     - 사칙 연산 및 비트연산을 포함합니다. (비트연산은 다른 챕터에서 다뤄보아요.)
     - 사칙 연산을 계산한 결과값을 응답합니다.
     - +(덧셈), - (뺄셈), *(곱셈), /(나눗셈/몫), % (나눗셈/나머지)
     - [코드 스니펫] 사칙 연산

        ```java
        // 사칙 연산
        System.out.println(4 + 2); // 6
        System.out.println(4 - 2); // 2
        System.out.println(4 * 2); // 8
        System.out.println(4 / 2); // 2
        System.out.println(5 / 2); // 2
        System.out.println(2 / 4); // 0
        System.out.println(4 % 2); // 0
        System.out.println(5 % 2); // 1
     
        // 우선 순위 연산
        System.out.println(2 + 2 * 2); // 6
        System.out.println((2 + 2) * 2); // 8
        System.out.println(2 + (2 * 2)); // 6
     
        // 변수를 이용한 연산
        int a = 20;
        int b = 10;
        int c;
     
        // 덧셈
        c = a + b;
        System.out.println(c); // 30
     
        // 뺄셈
        c = a - b;
        System.out.println(c); // 10
     
        // 곱셈
        c = a * b;
        System.out.println(c); // 200
     
        // 나눗셈 (몫)
        c = a / b;
        System.out.println(c); // 2
     
        // 나눗셈 (나머지) = 나머지 연산
        c = a % b;
        System.out.println(c); // 0
        ```

     • 비교 연산자
       • 값의 크고/작음을 비교하거나 같고/다름 을 비교하여 참(true)/거짓(false) 값인 boolean 값을 출력합니다.
       • > (크다) , < (작다), >= (크거나 같다), <= (작거나 같다), == (같다), != (다르다)
       • [코드 스니펫] 비교 연산
       • // 비교 연산자 (참이면 true, 거짓이면 false) System.out.println(10 > 9); // 10 는 9 보다 크다 (참이면 true, 거짓이면 false) System.out.println(10 >= 9); // 10 는 9 보다 크거나 같다 (true) System.out.println(10 < 9); // 10 는 9 보다 작다 (false) System.out.println(10 <= 9); // 10 는 9 보다 작거나 같다 (false) System.out.println(10 == 10); // 10 는 10 와 같다 (true) System.out.println(10 == 9); // 10 는 9 과 같다 (false) System.out.println(10 != 10); // 10 는 10 와 같지 않다 (false) System.out.println(10 != 9); // 10 는 9 과 같지 않다 (true)
     • 논리 연산자
       • 비교 연산의 결과값으로 받을 수 있는 boolean 값을 연결하는 연산자 입니다.
       • 조건을 연결 하였을때의 boolean 값들을 조합하여 참(true)/거짓(false) 값인 boolean 값을 출력합니다.
       • && (AND = 피연산자 모두 참), ||(OR = 피연산자 둘중 하나라도 참), !(피연산자의 반대 boolean 값)
       • [코드 스니펫] 논리 연산
       • // 논리 연산자 boolean flag1 = true; boolean flag2 = true; boolean flag3 = false; System.out.println(flag1); // true System.out.println(flag2); // true System.out.println(flag3); // false // 피연산자 중 하나라도 true 이면 true System.out.println(flag1 || flag2); // true System.out.println(flag1 || flag2 || flag3); // true // 피연산자 모두 true 이면 true System.out.println(flag1 && flag2); // true (flag1, flag2 모두 true 라서) System.out.println(flag1 && flag2 && flag3); // false (flag3은 false 라서) // And 연산 System.out.println((5 > 3) && (3 > 1)); // 5 는 3 보다 크고, 3 은 1 보다 크다 (true) System.out.println((5 > 3) && (3 < 1)); // 5 는 3 보다 크고, 3 은 1 보다 작다 (false) // Or 연산 System.out.println((5 > 3) || (3 > 1)); // 5 는 3 보다 크거나, 3 은 1 보다 크다 (true) System.out.println((5 > 3) || (3 < 1)); // 5 는 3 보다 크거나, 3 은 1 보다 작다 (true) System.out.println((5 < 3) || (3 < 1)); // 5 는 3 보다 작거나, 3 은 1 보다 작다 (false) // System.out.println(1 < 3 < 5); // 불가능한 코드 // 논리 부정 연산자 System.out.println(!flag1); // false (flag1 값의 반대) System.out.println(!flag3); // true (flag3 값의 반대) System.out.println(!(5 == 5)); // false System.out.println(!(5 == 3)); // true
     • 대입 연산자
       • 변수를 바로 연산해서 그자리에서 저장하는 연산자
       • 기본 대입 연산자인 = 와 다른 연산을 함께쓰는 복합 대입 연산자가 있습니다. (+=, -=, *= …)
       • 복합 대입 연산자는 기본 대입 연산자를 심플하게 작성하게 해주는것이지 기능은 같습니다.
       • 추가로, += 1 는 ++ 과 동일합니다. (피연산자에 1 더해주기)
       • 똑같이 -= 1 은 —-와 동일합니다. (피연산자에 1 빼주기)
       • [코드 스니펫] 대입 연산자
       • // 대입 연산자 int number = 10; number = number + 2; System.out.println(number); // 12 number = number - 2; System.out.println(number); // 10 number = number * 2; System.out.println(number); // 20 number = number / 2; System.out.println(number); // 10 number = number % 2; System.out.println(number); // 0 number = number++; System.out.println(number); // 2 number = number--; System.out.println(number); // 0 // 복합 대입 연산자 number = 10; number += 2; System.out.println(number); // 12 number -= 2; System.out.println(number); // 10 number *= 2; System.out.println(number); // 20 number /= 2; System.out.println(number); // 10 number %= 2; System.out.println(number); // 0

    <aside>
    🔥 **대입 연산자 중에 증감 연산자 쓸때 주의할점!**

    - `++` 또는 `—-` 를 붙이면 피연산자가 1 더해지거나 1 빼기가 된다고 말씀드렸는데요.
    - 주의할 점은, 피연산자 뒤에 붙이냐, 앞에 붙이냐에 따라서 연산순서가 달라집니다!!

    | 연산자 | 연산자 위치 | 기능 | 연산 예 |
    | --- | --- | --- | --- |
    | ++ | ++{피연산자} | 연산 전에 피연산자에 1 더해줍니다. | val = ++num; 
    num값+1 후에 val변수에 저장 |
    | ++ | {피연산자}++ | 연산 후에 피연산자에 1 더해줍니다. | val = num++;
    num값을 val변수에 저장 후 num+1 |
    | — | —{피연산자} | 연산 전에 피연산자에 1 빼줍니다. | val = —num;
    num값-1 후에 val변수에 저장 |
    | — | {피연산자}— | 연산 후에 피연산자에 1 빼줍니다. | val = num—;
    num값을 val변수에 저장 후 num-1 |
    - 이처럼 대입연산할때 뿐만아니라 연산을 직접할때도 마찬가지로 선/후적용이 나뉩니다.
    - 실습 코드를 통해 실습해볼까요?
    - [코드 스니펫] 대입 증감 연산자

        ```java
        // 대입 증감 연산자

        public class Main {

            public static void main(String[] args) {
                int a = 10;
                int b = 10;
                int val = ++a + b--; // a 는 연산전에 +1, b 는 연산후에 -1

                System.out.println(a); // 11
                System.out.println(b); // 9
                System.out.println(val); // 21

                // 11 + 9 가 왜 21이 나오는거죠??
                // 그 이유는 
                // a 는 val 연산전에 ++ 가 수행되어서 11로 연산되었지만
                // b 는 val 연산후에 -- 가 수행되어서 기존값이 10으로 연산된 후 -- 가 수행되었습니다.
                // 따라서 연산된 a값인 11과 연산되기전 b값인 10이 더해져서 21이 된겁니다!

                int c = a--; // c 에 a 값 대입 후 a-1  (즉, a=10, c=11)
                int d = ++b; // b 값 +1 후에 d 에 대입 (즉, b=10, d=10)
                int val = c-- * ++d; // c 는 연산후에 -1, d 는 연산전에 +1

                System.out.println(a); // 10
                System.out.println(b); // 10
                System.out.println(c); // 11
                System.out.println(d); // 10
                System.out.println(val); // 11 * 11 = 121

                // 11 * 10 이 왜 121이 나오는거죠??
                // 그 이유는 
                // c 는 val 연산후에 -- 가 수행되어서 기존값이 11로 연산된 후 -- 가 수행되었지만
                // d 는 val 연산전에 ++ 가 수행되어서 11로 연산되었습니다.
                // 따라서 연산전 a값인 11과 연산된 b값인 11이 곱해져서 121이 된겁니다!
            }

        }
        ```

    </aside>

- 기타 연산자
    - 형변환 연산자
        - 1일차 강의에서 배운내용으로 괄호 안에 변환할 타입을 넣으면 피연산자의 타입이 변경 됩니다.

        ```java
        // 형변환 연산자
        int intNumber = 93 + (int) 98.8; // 93 + 98

        double doubleNumber = (double) 93 + 98.8; // 93.0 + 98.8
        ```

    - 삼항 연산자
        - 비교 연산의 결과값에 따라 응답할 값을 직접 지정할 수 있는 연산자 입니다.
        - 삼항 연산자는 3가지 피연산자가 존재하여 삼항 연산자 라고 합니다. (`조건`/`참결과`/`거짓결과`)
        - `(조건)` `?` `(참결과)` `:` `(거짓결과)`

        ```java
        // 삼항 연산자
        int x = 1;
        int y = 9;

        boolean b = (x == y) ? true : false;
        System.out.println(b); // false

        String s = (x != y) ? "정답" : "땡";
        System.out.println(s); // 땡

        int max = (x > y) ? x : y;
        System.out.println(max); // 9

        int min = (x < y) ? x : y;
        System.out.println(min); // 1
        ```

    - instance of 연산자
        - 3주차에 배울 클래스관련 내용으로 해당 주차때 배우도록 하겠습니다.
        - 간단히 설명드리면 피연산자가 조건에 명시된 클래스의 객체인지 비교하여 참/거짓을 응답해주는 연산자 입니다.
        - `(객체명)` `instance of` `(클래스명)`

• 3. 연산자 우선순위
     • 연산자 여러개가 함께 있는 연산을 계산할때는 우선순위가 있습니다.
     • 위 우선순위에 따라서 최종적인 응답값이 결정됩니다.
     • 단, 괄호로 감싸주면 괄호안의 연산이 최우선순위로 계산됩니다.
     • [코드 스니펫] 연산자 우선순위
     • // 연산자 우선순위 int x = 2; int y = 9; int z = 10; boolean result = x < y && y < z; // <,> 비교연산자 계산 후 && 논리 연산자 계산 System.out.println(result); // true result = x + 10 < y && y < z; // +10 산술연산자 계산 후 <,> 비교연산자 계산 후 && 논리 연산자 계산 System.out.println(result); // false result = x + 2 * 3 > y; // 산술연산자 곱센 > 덧셈 순으로 계산 후 > 비교연산자 계산 System.out.println(result); // false (8>9) result = (x + 2) * 3 > y; // 괄호안 덧셈 연산 후 괄호 밖 곱셈 계산 후 > 비교연산자 계산 System.out.println(result); // true (12>9)
  4. 📌 연산자 우선순위 : 산술 > 비교 > 논리 > 대입
  4. 산술변환
  5. 📌 연산 전에 피연산자의 타입을 일치시키는 것
     • 두 피연산자의 타입을 같게 일치시킨다. (둘중에 저장공간 크기가 더 큰 타입으로 일치
  6. 피연산자의 타입이 int 보다 작은 short 타입이면 int 로 변환
  7. 피연산자의 타입이 long 보다 작은 int, short 타입이면 Long 으로 변환
  8. 피연산자의 타입이 float보다 작은 long, int, short 타입이면 float 으로 변환
  9. 피연산자의 타입이 double 보다 작은 float, long, int, short 타입이면 double 으로 변환
  10. 이처럼, 변수여러개를 연산했을때 결과값은 피연산자 중 표현 범위가 가장 큰 변수 타입을 가지게 됩니다.
  11. [코드 스니펫] 산술변환
  12. // 산술변환 public class Main { public static void main(String[] args) { short x = 10; int y = 20; int z = x + y; // 결과값은 더 큰 표현타입인 int 타입의 변수로만 저장할 수 있습니다. long lx = 30L; long lz = z + lx; // 결과값은 더 큰 표현타입인 long 타입의 변수로만 저장할 수 있습니다. float fx = x; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다. float fy = y; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다. float fz = z; // 결과값은 더 큰 표현타입인 float 타입의 변수로만 저장할 수 있습니다. System.out.println(lz); System.out.println(fx); System.out.println(fy); System.out.println(fz); } }
  5. 비트 연산
  • Byte 를 8등분한게 Bit 라고 말씀 드린거 기억하시죠?
  • Bit 는 0,1 둘중의 하나의 값만을 저장하는 컴퓨터가 저장(표현)가능한 가장 작은 단위라고 말씀드렸습니다.
  • 컴퓨터의 가장작은 단위인 Bit이기 때문에 연산중에서 Bit 연산이 제일 빠릅니다.
  • 물론 이전에 배운대로 0,1 값으로 산술연산을 하거나, 비교연산을 할 수 있지만 비트 연산을 통해 자리수를 옮길수도 있습니다.
  • 이처럼 Bit의 자리수를 옮기는 것을 비트 연산이라고 합니다.
  • <<(왼쪽으로 자리수 옮기기), >>(오른쪽으로 자리수 옮기기)
  • 0,1 은 2진수 값이기 때문에,
    • 자리수를 왼쪽으로 옮기는 횟수만큼 2의 배수로 곱셈이 연산되는것과 동일합니다.
    • 자리수를 오른쪽으로 옮기는 횟수만큼 2의 배수로 나눗셈이 연산되는것과 동일합니다.
  • [코드 스니펫] 비트 연산
    
    

// 비트 연산

// 참고, 3의 이진수값은 11(2) 입니다. 12의 이진수값은 1100(2) 입니다.
// (2) 표기는 이 숫자가 이진수값이라는 표식 입니다.

System.out.println(3 << 2); 
// 3의 이진수값인 11(2) 에서 왼쪽으로 2번 옮겨져서 1100(2) 인 12값이 됩니다.


System.out.println(3 >> 1); 
// 3의 이진수값인 11(2) 에서 오른쪽으로 1번 옮겨져서 1(2) 인 1 값이 됩니다.