[JAVA] - 연산자

연산자

1. 정의

연산자 : 덧셈, 뺄셈 처럼 계산할 기호 ➕
피연산자 : 연산자로 인해 계산되는 숫자 🔢

int x = 5;
int y = 10;

int z = x + y;  // 5(피연산자) +(연산자) 10(피연산자) 계산

System.out.println(z);  // 출력값 : 15

2. 연산자 종류

연산자는 사칙연산 외에도 여러가지 연산자가 있습니다.

산술 연산자	+, -, *, /, %, <<, >>	사칙 연산과 비트연산
비교 연산자	>, <, >=, <=, ==, !=	크고 작음과 같고 다름을 비교
논리 연산자	&&, \|\|, !	그리고(AND)와 또는(OR)으로 조건을 연결
대입 연산자	=, ++, --	우변의 값을 좌변에 저장, 연산 복합 대입
기타 연산자	(type), ?, :, instance of	형변환 연산자, 삼항 연산자, instance of 연산자

3. 산술 연산자

사칙 연산 및 비트연산을 포함합니다.
사칙 연산을 계산한 결과값을 응답합니다.
+(덧셈), - (뺄셈), *(곱셈), /(나눗셈/몫), % (나눗셈/나머지)

산술 연산자 코드

예시

package Second;

public class FourBasicOperators {
    public static void main(String[] args) {
        /*
        사칙연산
        a+b = x
        a,b는 피연산자 +는 연산자
         */

        // 덧셈
        System.out.println("--------------------덧셈--------------------");
        System.out.println("3 + 5 : " + (3 + 5));
        System.out.println("5 + 7 : " + (5 + 7));
        System.out.println("3 + 7 : " + (3 + 7));

        // 뺄셈
        System.out.println("--------------------뺄셈--------------------");
        System.out.println("3 - 5 : " + (3 - 5));
        System.out.println("7 - 5 : " + (7 - 5));
        System.out.println("7 - 3 : " + (7 - 3));

        // 곱셈
        System.out.println("--------------------곱셈--------------------");
        System.out.println("3 * 5 : " + (3 * 5));
        System.out.println("5 * 7 : " + (5 * 7));
        System.out.println("3 * 7 : " + (3 * 7));

        // 나눗셈 (몫)
        System.out.println("--------------------나눗셈(몫)--------------------");
        System.out.println("5 / 3 : " + (5 / 3));
        System.out.println("5 / 7 : " + (5 / 7));
        System.out.println("7 / 3 : " + (7 / 3));

        // 나눗셈 (나머지)
        System.out.println("--------------------나눗셈(나머지)--------------------");
        System.out.println("3 % 5 : " + (3 % 5));
        System.out.println("5 % 7 : " + (5 % 7));
        System.out.println("3 % 7 : " + (3 % 7));

        // 우선 순위 연산 (*,/,% 가 우선이고 다음으로 +,- 순서입니다.)
        System.out.println("--------------------사칙연산 우선순위--------------------");
        System.out.println("2 * 2 + 2 : " + (2 * 2 + 2));
        System.out.println("2 * 2 + 2 : " + (2 * (2 + 2)));

        // 변수 이용
        int a = 7;
        int b = 5;
        int c = 3;
        int d;

        //덧셈
        System.out.println("--------------------덧셈--------------------");
        System.out.println("a + b : " + (a + b));

        //뺄셈
    System.out.println("--------------------뺼셈--------------------");
        d = a - c;
        System.out.println("a - c : " + (d));

        //곱셈
        System.out.println("--------------------곱셈--------------------");
        System.out.println("b * c : " + (b * c));

        //나눗셈 (몫)
        System.out.println("--------------------나눗셈(몫)--------------------");
        d = a / c;
        System.out.println("a / c : " + (d));

        //나눗셈 (나머지)
        System.out.println("--------------------나눗셈(나머지)--------------------");
        System.out.println("a % c : " + (a % c));
    }
}

/*

--------------------덧셈--------------------
3 + 5 : 8
5 + 7 : 12
3 + 7 : 10
--------------------뺄셈--------------------
3 - 5 : -2
7 - 5 : 2
7 - 3 : 4
--------------------곱셈--------------------
3 * 5 : 15
5 * 7 : 35
3 * 7 : 21
--------------------나눗셈(몫)--------------------
5 / 3 : 1
5 / 7 : 0
7 / 3 : 2
--------------------나눗셈(나머지)--------------------
3 % 5 : 3
5 % 7 : 5
3 % 7 : 3
--------------------사칙연산 우선순위--------------------
2 * 2 + 2 : 6
2 * 2 + 2 : 8
--------------------덧셈--------------------
a + b : 12
--------------------뺼셈--------------------
a - c : 4
--------------------곱셈--------------------
b * c : 15
--------------------나눗셈(몫)--------------------
a / c : 2
--------------------나눗셈(나머지)--------------------
a % c : 1

 */

4. 비교 연산자 & 논리 연산자

비교 연산자란
- 값의 크고/작음을 비교하거나 같고/다름 을 비교하여 참(true)/거짓(false) 값인 boolean 값을 출력합니다.
- > (크다) , < (작다), >= (크거나 같다), <= (작거나 같다), == (같다), != (다르다)
논리 연산자란
- 비교 연산의 결과값으로 받을 수 있는 boolean 값을 연결하는 연산자 입니다.
- 조건을 연결 하였을때의 boolean 값들을 조합하여 참(true)/거짓(false) 값인 boolean 값을 출력합니다.
- && (AND = 피연산자 모두 참), ||(OR = 피연산자 둘중 하나라도 참), !(피연산자의 반대 boolean 값)

비교 연산자 & 논리 연산자 코드

예시

package Second;

import java.sql.SQLOutput;
import java.util.zip.DeflaterInputStream;

public class ComparisonOperators_LogicalOperators {
    public static void main(String[] args) {
       /*
    Comparison Operators (비교연산자)
    Logical Operators (논리연산자)
     */
    /*
    논리연산자
    비교 연산의 결과값으로 받을 수 있는 boolean 값을 연결하는 연산자
    조건을 연결 하였을 때 boolean 값들을 조합하여 참(true) 또는 거짓(false) 값인 boolean 값을 출력
    &&(AND), ||(OR), !(NOT)
     */
        boolean flag1 = true;
        boolean flag2 = true;
        boolean flag3 = false;

        // 피연산자 중 하나라도 true면 true => 또는 (OR : ||)
        System.out.println("--------------------OR--------------------");
        System.out.println("flag1 || flag2 : " + (flag1 || flag2));
        System.out.println("flag1 || flag2 || flag3 : " + (flag1 || flag2 || flag3));

        // 피연산자 모두 true면 true => 그리고 (AND : &&)
        System.out.println("--------------------AND--------------------");
        System.out.println("flag1 && flag2 : " + (flag1 && flag2));
        System.out.println("flag1 && flag2 && flag3 : " + (flag1 && flag2 && flag3));

        // AND
        System.out.println("--------------------AND--------------------");
        System.out.println("(5 > 3) && (3 > 1) : " + ((5 > 3) && (3 > 1)));
        System.out.println("(5 > 3) && (3 < 1) : " + ((5 > 3) && (3 < 1)));

        // OR, AND
        System.out.println("--------------------OR--------------------");
        System.out.println("(5 > 3) || (3 > 1) : " + ((5 > 3) || (3 > 1)));
        System.out.println("(5 > 3) || (3 < 1) : " + ((5 > 3) || (3 < 1)));
        System.out.println("(5 < 3) || (3 > 1) : " + ((5 < 3) || (3 > 1)));

        // 논리 부정 연산자 (NOT : !)
        System.out.println("--------------------NOT--------------------");
        System.out.println("!flag1 : " + (!flag1));
        System.out.println("!flag3 : " + (!flag3));
        System.out.println("!(3 == 3) : " + (!(3 == 3)));
    }
}

/*

--------------------OR--------------------
flag1 || flag2 : true
flag1 || flag2 || flag3 : true
--------------------AND--------------------
flag1 && flag2 : true
flag1 && flag2 && flag3 : false
--------------------AND--------------------
(5 > 3) && (3 > 1) : true
(5 > 3) && (3 < 1) : false
--------------------OR--------------------
(5 > 3) || (3 > 1) : true
(5 > 3) || (3 < 1) : true
(5 < 3) || (3 > 1) : true
--------------------NOT--------------------
!flag1 : false
!flag3 : true
!(3 == 3) : false

 */

6. 대입 연산자

변수를 바로 연산해서 그자리에서 저장하는 연산자입니다.
기본 대입 연산자인 = 와 다른 연산을 함께쓰는 복합 대입 연산자가 있습니다. (+=, -=, *= …)
복합 대입 연산자는 기본 대입 연산자를 심플하게 작성하게 해주는것이지 기능은 같습니다.
추가로, += 1 는 ++ 과 동일합니다. (피연산자에 1 더해주기)
똑같이 -= 1 은 —-와 동일합니다. (피연산자에 1 빼주기)

대입 연산자 코드

예시

package Second;

public class AssignmentOperator {
    public static void main(String[] args) {
        /*
        Assignment_Operator (대입연산자)
        변수를 연산해서 그 자리에서 저장하는(대입하는) 연산자
        =(기본연산자), +=, -=, *=, /=, %= <- 복합 대입 연산자
         */
        // 기본 대입연산자
        System.out.println("---------------기본 대입 연산자---------------");

        int num = 10;
        num = num + 5;
        System.out.println("num = num + 5 : " + (num));

        num = num - 5;
        System.out.println("num = num - 5 : " + (num));

        num = num * 5;
        System.out.println("num = num * 5 : " + (num));

        num = num / 5;
        System.out.println("num = num / 5 : " + (num));

        num = num % 5;
        System.out.println("num = num % 5 : " + (num));


        // 복합 대입연산자
        System.out.println("---------------복합 대입 연산자---------------");

        num += 15;
        System.out.println("num += 15 : " + (num));

        num -= 5;
        System.out.println("num -= 5 : " + (num));

        num *= 5;
        System.out.println("num *= 5 : " + (num));

        num /= 5;
        System.out.println("num /= 5 : " + (num));

        num %= 5;
        System.out.println("num %= 5 : " + (num));

        // ++, --
        num = 10;
        num++;
        System.out.println("num++ : " + (num));

        num--;
        System.out.println("num-- : " + (num));

        /*
        대입 연산자 주의점
        ++, --
        ++, -- 이 기호의 위치에 따라 연산이 달라집니다.
        ++, -- 연산 기호가 변수 앞에 존재하면 그 변수를 증감 시킨 후 메인 연산을 실행,
        ++, -- 연산 기호가 변수 뒤에 존재하면 그 변수의 메인 연산을 한 후 다시 연산하려고 할 때 적용됩니다.
         */
    }
}

/*

---------------기본 대입 연산자---------------
num = num + 5 : 15
num = num - 5 : 10
num = num * 5 : 50
num = num / 5 : 10
num = num % 5 : 0
---------------복합 대입 연산자---------------
num += 15 : 15
num -= 5 : 10
num *= 5 : 50
num /= 5 : 10
num %= 5 : 0
num++ : 11
num-- : 10

 */

대입 연산자 중에 증감 연산자 쓸때 주의할점

++ 또는 —- 를 붙이면 피연산자가 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

이처럼 대입연산할때 뿐만아니라 연산을 직접할때도 마찬가지로 선/후적용이 나뉩니다.

7. 기타 연산자

형변환 연산자
- 괄호 안에 변환할 타입을 넣으면 피연산자의 타입이 변경 됩니다.
삼항 연산자
- 비교 연산의 결과값에 따라 응답할 값을 직접 지정할 수 있는 연산자 입니다.
- 삼항 연산자는 3가지 피연산자가 존재하여 삼항 연산자 라고 합니다. (조건/참결과/거짓결과)
- (조건) ? (참결과) : (거짓결과)

기타 연산자 코드

예시

package Second;

public class OtherOperators {
    public static void main(String[] args) {
        /*
        Other_Operators (기타 연산자)
        1) 형변환 연산자
        2) 삼항 연산자
         */

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

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

        System.out.println("93 + (int) 98.8 : " + (intNumber));
        System.out.println("(double) 93 + 98.8 : " + (doubleNumber));

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

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

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

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

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

/*

93 + (int) 98.8 : 191
(double) 93 + 98.8 : 191.8
1 == 9 : false
1 != 9 : 정답
(x > y) ? x : y : 9
(x < y) ? x : y : 1

 */

8. 연산자 우선 순위

연산자 우선순위 : 산술 > 비교 > 논리 > 대입
연산자 여러개가 함께 있는 연산을 계산할때는 우선순위가 있습니다.
위 우선순위에 따라서 최종적인 응답값이 결정됩니다.
단, 괄호로 감싸주면 괄호안의 연산이 최우선순위로 계산됩니다.

연산자 우선 순위 코드

예시

package Second;

public class OperatorPrecedence {
    public static void main(String[] args) {
        /*
        Operator Precedence (연산자 우선순위)
        연산자 우선순위 : 산술 > 비교 > 논리 > 대입
        연산자 여러개가 함께 있는 연산을 계산할때는 우선순위가 있습니다.
        위 우선순위에 따라서 최종적인 응답값이 결정됩니다.
        단, 괄호로 감싸주면 괄호안의 연산이 최우선순위로 계산됩니다.
         */

        // 연산자 우선순위
        int x = 2;
        int y = 9;
        int z = 10;

        boolean result = x < y && y < z; // <,> 비교연산자 계산 후 && 논리 연산자 계산
        System.out.println("x < y && y < z : " + (result)); // true

        result = x + 10 < y && y < z; // +10 산술연산자 계산 후 <,> 비교연산자 계산 후 && 논리 연산자 계산
        System.out.println("x + 10 < y && y < z : " + (result)); // false

        result = x + 2 * 3 > y; // 산술연산자 곱센 > 덧셈 순으로 계산 후 > 비교연산자 계산
        System.out.println("x + 2 * 3 > y : " + (result)); // false (8>9)

        result = (x + 2) * 3 > y; // 괄호안 덧셈 연산 후 괄호 밖 곱셈 계산 후 > 비교연산자 계산
        System.out.println("(x + 2) * 3 > y : " + (result)); // true (12>9)
    }
}

/*

x < y && y < z : true
x + 10 < y && y < z : false
x + 2 * 3 > y : false
(x + 2) * 3 > y : true

 */

9. 산술 변환

연산 전에 피연산자의 타입을 일치시키는 것입니다.
- 두 피연산자의 타입을 같게 일치시킵다. (둘중에 저장공간 크기가 더 큰 타입으로 일치)
피연산자의 타입이 int 보다 작은 short 타입이면 int 로 변환합니다.
피연산자의 타입이 long 보다 작은 int, short 타입이면 Long 으로 변환합니다.
피연산자의 타입이 float보다 작은 long, int, short 타입이면 float 으로 변환합니다.
피연산자의 타입이 double 보다 작은 float, long, int, short 타입이면 double 으로 변환합니다.
이처럼, 변수여러개를 연산했을때 결과값은 피연산자 중 표현 범위가 가장 큰 변수 타입을 가지게 됩니다.
산술 변환 코드

예시

package Second;

public class ArithmeticConversion {
    public static void main(String[] args) {
        /*
        Arithmetic Conversion (산술 변환)
        연산 전에 피연산자의 타입을 일치시키는 것
        두 피연산자의 타입을 같게 일치시킨다. (둘중에 저장공간 크기가 더 큰 타입으로 일치
        피연산자의 타입이 `int` 보다 작은 `short` 타입이면 `int` 로 변환
        피연산자의 타입이 `long` 보다 작은 `int`, `short` 타입이면 `Long` 으로 변환
        피연산자의 타입이 `float`보다 작은 `long`, `int`, `short` 타입이면 `float` 으로 변환
        피연산자의 타입이 `double` 보다 작은 `float`, `long`, `int`, `short` 타입이면 `double` 으로 변환
        이처럼, 변수여러개를 연산했을때 결과값은 피연산자 중 표현 범위가 가장 큰 변수 타입을 가지게 됩니다.
         */

        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("(10 + 20) + 30L) : " + (lz));
        System.out.println("float_x : " + fx);
        System.out.println("float_y : " + fy);
        System.out.println("float_z : " + fz);
    }
}

/*

(10 + 20) + 30L) : 60
float_x : 10.0
float_y : 20.0
float_z : 30.0

 */

10. 비트 연산

Byte 를 8등분한게 Bit입니다.
Bit 는 0,1 둘중의 하나의 값만을 저장하는 컴퓨터가 저장(표현)가능한 가장 작은 단위입니다.
컴퓨터의 가장작은 단위인 Bit이기 때문에 연산중에서 Bit 연산이 제일 빠릅니다.
물론 이전에 배운대로 0,1 값으로 산술연산을 하거나, 비교연산을 할 수 있지만 비트 연산을 통해 자리수를 옮길수도 있습니다.
이처럼 Bit의 자리수를 옮기는 것을 비트 연산이라고 합니다.
<<(왼쪽으로 자리수 옮기기), >>(오른쪽으로 자리수 옮기기)
0,1 은 2진수 값이기 때문에,
- 자리수를 왼쪽으로 옮기는 횟수만큼 2의 배수로 곱셈이 연산되는것과 동일합니다.
- 자리수를 오른쪽으로 옮기는 횟수만큼 2의 배수로 나눗셈이 연산되는것과 동일합니다.

비트 연산 코드

예시

package Second;

public class BitwiseOperator {
    public static void main(String[] args) {
        /*
        Bitwise Operator (비트 연산자)
        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 값이 됩니다.
    }
}

/*

12
1

 */

'JAVA' 카테고리의 다른 글

[JAVA] - 반복문 (for, while) (0)	2024.01.08
[JAVA] - 조건문 (if, switch) (0)	2024.01.07
[JAVA] - 자바 2차원 배열 (0)	2024.01.06
[JAVA] - 자바 기초 (0)	2024.01.03
[JAVA] - 자바 이해 / JVM이란? (0)	2024.01.03

기술블로그

[JAVA] - 연산자

연산자

1. 정의

2. 연산자 종류

3. 산술 연산자

4. 비교 연산자 & 논리 연산자

6. 대입 연산자

7. 기타 연산자

8. 연산자 우선 순위

9. 산술 변환

10. 비트 연산

'JAVA' 카테고리의 다른 글

티스토리툴바

[JAVA] - 연산자

연산자

1. 정의

2. 연산자 종류

3. 산술 연산자

4. 비교 연산자 & 논리 연산자

6. 대입 연산자

7. 기타 연산자

8. 연산자 우선 순위

9. 산술 변환

10. 비트 연산

'JAVA' 카테고리의 다른 글

관련글

티스토리툴바