JAVA - Basic_02 연산자(Operator)

연산자(Operator)

단항 연산자

- , + : 부호대입 연산자

변수앞에 써주면 음수와 양수로 전환할 수 있다.

++ : 증가 연산자

값이 1씩 증가한다.

-- : 감소 연산자

값이 1씩 감소한다.

public class Operator_01 {
    public static void main(String[] args) {
        /**
         * 단항연산자 예제
         */
        int num = 200;
        int mNum = -num;    //변수가 음수라면 양수로 / 양수라면 음수로 전환된다.
        int pNum = +mNum;    //변화없음 그냥 존재함(진짜로...진짜진자로...)

        System.out.println(num);
        System.out.println(mNum);   //양수가 음수로 전환됨
        System.out.println(pNum);   //음수가 양수로 바뀌지도 않음

        System.out.println(num);    //200
        //num++;                      // num에 1을 더함
        num = num+1; //과 같음
        System.out.println(num);    //201
        //num--;                      // num에서 1을 뺌
        num = num-1; //과 같음;
        System.out.println(num);    //200

        System.out.println("후위연산 : " + num++);  //200출력   후위 연산   현제 행을 실행하고 해당 변수를 1증가시킴
        System.out.println(num);    //201출력
        System.out.println("전위연산 : " + --num);  //202출력   전위 연산   현제 행을 실행하기 전에 해당변수에서 1을 감소시키고 실행
    }
}

---

사칙 연산자

+ : 더하기 연산자

• 1+2 와 같이 두항의 값을 더하는데 사용
• 문자열과 문자열을 이어붙일때도 사용한다.
• "오범수"+"짱짱맨" 이때 값은 "오범수 짱짱맨"가 된다.단순히 뒤에 이어붙이며 더하기 연산에 문자열이 포함되면 무조건 무자열로 반환된다.

- : 빼기 연산자

• 1-2 와 같이 두항의 값을 빼는데 사용하며, 빼기는 문자에는 사용할 수 없다.

* : 곱하기 연산자

두 항의 값을 곱한다.

/ : 나누기 연산자

두 항의 값을 나눈다.

% : 나머지 연산자

두항의 값을 나누고 나머지를 결과값으로 반환한다.

+=, -=, *=, /=, %= : 연산결과를 자동으로 변수에 저장한다.

int num = 10;
num+=5; //num = num+=5;와 같다  num은 15가 됨
num-=5; //num = num-=5;와 같다  num은 10이 됨
num*=5; //num = num*=5;와 같다  num은 50이 됨
num/=5; //num = num/=5;와 같다  num은 10이 됨
num%=5; //num = num%=5;와 같다  num은 0이 됨

public class Operator_02 {
    public static void main(String[] args) {
        char aa = 'a';
        System.out.println(aa);
        /**
         *  사칙연산자
         */
        int a = 8;
        int j = 3;

        System.out.println("a = "+ a + " / j = "+j);
        System.out.println("a 더하기 j 는 " + (a + j));
        System.out.println("a 빼기 j 는 " + (a - j));
        System.out.println("a 곱하기 j 는 " + a * j);
        System.out.println("a 나누기 j의 몫은 " + a / j);
        System.out.println("a 나누기 j의 나머지 는 " + a % j);

        System.out.println("a = "+a);
        System.out.println("a += 5 / a = " + (a+=5));   // a = a+5; 와 같다
        System.out.println("a -= 5 / a = " + (a-=5));   // a = a-5; 와 같다
        System.out.println("a *= 5 / a = " + (a*=5));   // a = a*5; 와 같다
        System.out.println("a /= 5 / a = " + (a/=5));   // a = a/5; 와 같다
        System.out.println("a %= 5 / a = " + (a%=5));   // a = a%5; 와 같다

        System.out.println("====================== 문자열 더하기 ==============");
        System.out.println("오범수"+"짱짱맨");
        System.out.println(123+"짱짱맨");       // 123짱짱맨
        System.out.println(123+2+"짱짱맨");     // 125짱짱맨
        System.out.println("짱짱맨"+123);       // 짱짱맨123
        System.out.println("짱짱맨"+123+2);     // 짱짱맨1232
        System.out.println("짱짱맨"+(123+2));   // 짱짱맨125
        System.out.println("짱짱맨"+123*2);     // 짱짱맨246 / 사칙연산에서 곱하기(*)와 나누기(/)는 제일먼저 계산된다.

    }
}

비교연산자

>, < ,==, <=, >=

두 항을 비교하여 true나 false를 반환한다.

> , <

A > B

• A항이 B항보다 크면 true
• A항이 B항보다 작거나 같으면 false

A < B

• B항이 A항보다 크면 true
• B항이 A항보다 작거나 같으면 false

==

A == B

• A항과 B항이 완전히 같을때 true 다르면 false

>=, <=

A >= B

• A항이 B항보다 크거나 같으면 true
• A항이 B항보다 작으면 false

A <= B

• A항이 B항보다 작거나 같으면 true
• A항이 B항보다 크면 false

논리 연산자

or연산자(||)

양쪽 항 중 하나라도 true라면 true를 반환한다.

• true || false = true
• true || true = true
• false || false = false

and연산자(&&)

양쪽 모두 true일때 true를 반환한다.

• true && true = true
• true && false = false
• false && false = false

!부정 연산자(!)

논리연산의 결과를 반전시킨다.

• !false = true
• !true = false
• !(true && false) = true
• !(true || false) = false

등호(=)와 함께 쓰면 같지않다로 해석된다.

• 10 != 20 = true
• 10 != 10 = false

public class Operator_03 {
    public static void main(String[] args) {
        /**
         * 논리 연산자
         */
        int i = 100;
        int j = 200;

        if(i > j){  //거짓
            System.out.println(i>j);
            System.out.println("100은 200보다 크다");
        }
        // if(i > j)   
        //     System.out.println("100은 200보다 크다");

        if(i >= j){ //거짓
            System.out.println(i>=j);
            System.out.println("100은 200보다 크거나 같다");
        }
        // if(i >= j)  
        //     System.out.println("100은 200보다 크거나 같다");

        if(i < j){  //참
            System.out.println(i<j);
            System.out.println("100은 200보다 작다");
        }
        // if(i < j)
        //     System.out.println("100은 200보다 작다");

        if(i <= j){ //참
            System.out.println(i<=j);
            System.out.println("100은 200보다 작거나 같다");
        }
        // if(i <= j)
        //     System.out.println("100은 200보다 작거나 같다");

        if(i == j){ //거짓
            System.out.println(i==j);
            System.out.println("100은 200보다 같다");
        }
        // if(i == j)
        //     System.out.println("100은 200보다 같다");
        System.out.println("==================== 논리 연산 ==========================");

        /**
         * or (||)
         * and (&&) 
         * 연산자
         */
        System.out.println("=================== or 연산 / and 연산 ===================");
        if( i > j || i == 100 ){
            System.out.println(" i는 j보다 크거나 i는 100이다");
        }

        if( i > j && i == 100 ){
            System.out.println(" i는 j보다 크고 i는 100이다");
        }

        /**
         * 부정연산자
         */
        System.out.println("=================== !연산(부정/not) ===================");

        boolean notOper = true;

        if(!notOper){   //notOper는 true지만 부정연산자(!) 때문에 false로 연산된다.
            System.out.println("true");
        }else{
            System.out.println("'!true' : false");
        }

        if( 10 !=20 ){
            System.out.println("'10 != 20' : 10은 20과 같지 않다");
        }


        /**
         * 삼항연산자 ( 조건식 ? true : false )
         */
        System.out.println("==================삼항 연산자==================");
        System.out.println(i>j?"i는 j보다 크다":"i는 j보다 작다");
        System.out.println(i<j?"i는 j보다 크다":"i는 j보다 작다");
        System.out.println(i>=j?"i는 j보다 크거나 같다":"i는 j보다 작거나 같다");
        System.out.println(i<=j?"i는 j보다 크거나 같다":"i는 j보다 작거나 같다");
        System.out.println(i==j?"i는 j와 같다":"i는 j와 다르다");
        System.out.println(i!=j?"i는 j와 같지 않다":"i는 j와 같다");

        int result = i>j ? (i+j) : (i-j);
        System.out.println(result);

        System.out.println("===================== 조건문 ====================");
        boolean bool = true;
        if(bool){
            //참일때 실행
            System.out.println("트루");
        }

        bool = false;

        if(bool){
            System.out.println("트루");
        }else{
            //거짓일때 실행
            System.out.println("펄스");
        }

        if(!bool){
            System.out.println("트루");
        }else{
            //거짓일때 실행
            System.out.println("펄스");
        }

        if(i>90){

        }else if(i>100){
            //if문이 거짓일때 다음 조건문
        }else if(i>100){
            System.out.println("아님");
        }else if(i>100){

        }

        System.out.println("================ switch 조건문 ====================");
        // i=90;
        i=0;

        switch(i){
            case 90:
                System.out.println("i는 90");
            break;
            case 100:
                System.out.println("i는 100");
            case 300000:
                System.out.println("브레이크 없잖아");
                break;
            default:
                System.out.println("디폴트");
        }

    }

}

그 외 연산자

삼항연산자

A>B?true:false

• A와 B를 비교하여 true면 true자리에 있는 값을 반환하고, false면 false자리에 있는 값을 반환한다.age가 13보다 크면 grade에는 중딩을 저장하고, 아니면 초딩을 저장한다.
• String age = 10; String grade = age > 13 ? "중딩":"초딩";

비트 연산자

2진수 비트 단위로 연산한다.

2진수인 0과 1로만 연산하기때문에 모든 데이터를 2진수로 변환후 계산한다.

컴퓨터는 모든 데이터를 2진수로 다루기때문에 모든 프로그램은 기본적으로 2진수로 다뤄진다는점을 생각하면 컴퓨터가 작업을 처리하기에 용이한 형태이다.

때문에 좀더 효과적인 프로그램을 만들어야한다면 최종적으로 고려해 보아야하는 부분이다.

~ 비트 반전연산자

비트를 반대로 전환한다.(0은 1로 / 1은 0으로 전환)

& 비트 AND연산

두항이 모두 1일때 1반환

| 비트 OR연산

두 항이 하나라도 1이면 1반환

^ 비트 단위 XOR연산(Exclusive)

두항이 다르면 1반환

<< 왼쪽 shift

a<<2 변수 a를 2비트 만큼 왼쪽으로 이동한다.

>> 오른쪽 shift

a>>2 변수 a를 2비트 만큼 오른쪽으로 이동한다.

>>> 오른쪽 shift

a>>>2 변수 a를 2비트 만큼 오른쪽으로 이동하고 채워지는 비트 부호에상관없이 0을 채운다.

public class Operator_04 {
    public static void main(String[] args) {
        //비트연산
        int a = 5; // 101
        int b = 11;//1011

        System.out.printf("10진수 a = %d \n",a);
        System.out.printf("2진수 a = %s \n",Integer.toBinaryString(a));
        System.out.printf("10진수 b = %d \n",b);
        System.out.printf("2진수 b = %s \n",Integer.toBinaryString(b));

        /**
         * ~비트 연산
         * 2진수 5  : ~   101
         * ------------------
         * 11111111111111111111111111111010
         */
        System.out.println("========= ~ 비트 연산 ========");
        System.out.println("\t10진수 : ~a = " +(~a));
        System.out.println("\t 2진수 : ~a = " +Integer.toBinaryString(~a));

        /**
         * 2진수 5  :     101
         * 2진수 11 : |  1011
         * ------------------
         * =             1111
         */
        System.out.println("========= | 비트 연산 ========");
        System.out.println("\t10진수 : a|b = " +(a|b));
        System.out.println("\t 2진수 : a|b = " +Integer.toBinaryString(a|b));

        /**
         * 2진수 5  :     101
         * 2진수 11 : &  1011
         * ------------------
         * =             0001
         */
        System.out.println("========= & 비트 연산 ========");
        System.out.println("\t10진수 : a&b = " +(a&b));
        System.out.println("\t 2진수 : a&b = " +Integer.toBinaryString(b&a));

        /**
         * 2진수 5  :     101
         * 2진수 11 : ^  1011
         * ------------------
         * =             1110
         */
        System.out.println("========= ^ 비트 연산 ========");
        System.out.println("\t10진수 : a^b = " +(a^b));
        System.out.println("\t 2진수 : a^b = " +Integer.toBinaryString(b^a));

        /**
         * 2진수 5  :   101
         * shift연산:   <<2 
         * ----------------
         *            10100
         */
        System.out.println("========= << 비트 연산 ========");
        System.out.println("\t10진수 : a<<2 = " +(a<<2));
        System.out.println("\t 2진수 : a<<2 = " +Integer.toBinaryString(a<<2));

        /**
         * 2진수 5  :   101
         * shift연산:   >>2 
         * ----------------
         *                1
         */
        System.out.println("========= >> 비트 연산 ========");
        System.out.println("\t10진수 : a>>2 = " +(a>>2));
        System.out.println("\t 2진수 : a>>2 = " +Integer.toBinaryString(a>>2));

        /**
         * 2진수 11  :   1011
         * shift연산:    >>>2 
         * ------------------
         *                 10
         */
        System.out.println("========= >>> 비트 연산 ========");
        System.out.println("\t10진수 : b>>>2 = " +(b>>>2));
        System.out.println("\t 2진수 : b>>>2 = " +Integer.toBinaryString(b>>2));


    }
}