자바(java)의 연산자(연산 기호)

나머지 연산자 : %

나눗셈 연산자 : /

정수 / 정수  = 정수

ex) 3 / 2 = > 1

실수형태의 값을 얻고 싶으면 피연산수를 실수로 선언해야 한다.

 

나머지 연산자와 나눗셈 연산자를 이용해 숫자의 각 자리수를 구할 수 있다.

int i = 2567;             // i의 십의 자리 수 구하기
int k = (i / 10) % 10;    // i / 10 = 256,  256 % 10 = 6

소수를 판별하기 위해서 역시 나머지 연산이 필요하다.

이는 나중에 반복문을 배울때 다시 알아보도록 하자.

 

public class ex22 {
    public static void main(String[] args) {
        // 나머지 연산자 %
        // 나눗셈을 해서 나머지 값을 반환하는 연산자임.
        // 10을 3을 나누면? 몫은 3이고, 나머지는 1이다.
        // 콘솔에 출력해보세요~
        System.out.println( "몫:" + (10/3) );
        System.out.println( "나머지:" + (10%3) );
        // 10을 나머지 연산을 할 때
        // 10 % 1 = 0
        System.out.println( "몫:" + (10/1) );
        System.out.println( "나머지:" + (10%1) );
        // 10 % 2 = 0 나머지 0이 나왔다는 의미는? 약수이고, 나누어 떨어졌다.
        // 10의 약수 : 10,1 2,5
        // 약수(divisor) : 어떤 수를 나누어 떨어지게 하는 수
        // 소수(prime) : 약수가 1과 자기 자신만 있는 자연수를 소수
        //
        System.out.println( "나머지:" + (10%2) );
        //소수 : 2,3,5,7,11...
        //2의 약수는 1,2
        //3의 약수는 1,3
        //소수인지 아닌지 판별하려면, 1부터 자기자신까지 나머지연산을 계속한다.
        //나머지가 0인 갯수가 2이상이면 소수가 아님.
        //예를 들어 4의 약수는 1,4,2 갯수가 3
    }
}

public class ex21 {
    public static void main(String[] args) {
        //연습문제 9
        // 12345 정수형변수의 자릿수 찾기
        // 1. 만의 자릿수를 출력하시오.  결과값) 1
        // 2. 천의 자릿수를 출력하시오.  결과값) 2
        // 3. 백의 자릿수를 출력하시오.  결과값) 3
        // 4. 십의 자릿수를 출력하시오.  결과값) 4
        // 5. 일의 자릿수를 출력하시오.  결과값) 5
        // 6. 각 자릿수를 이용하여 "1만2천3백4십5"로 출력하시오.

        //나머지 연산자 %, 산술연산자 +-*/ 사용
        int i = 12345; //10000 ~ 99999
        //만의 자릿수
        int k = i / 10000;
        System.out.println("만의 자릿수:" + k);
        //천의 자릿수
        int k2 = (i / 1000) % 10 ; //12 % 10 = 2
        System.out.println("천의 자릿수:" + k2);
        //백의 자릿수
        int k3 = (i / 100) % 10; //123 % 10 = 3
        System.out.println("백의 자릿수:" + k3);
        //십의 자릿수
        int k4 = (i / 10) % 10; //1234 % 10 = 4
        System.out.println("십의 자릿수:" + k4);
        //일의 자릿수
        int k5 = i % 10; // 5
        System.out.println("일의 자릿수:" + k5);
        System.out.println( k+"만"+k2+"천"+k3+"백"+k4+"십"+k5);
    }
}

비교 연산자

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

오직 불리언(boolean) 형식으로만 값이 나온다.

 

최소 두개의 피연산자를 비교하는 연산자이다.

컴퓨터를 다룰때 이 연산자들은 하나의 질문으로 이해하는게 더 편하다.

        System.out.println( 10 > 20);    / 결과 : false

> : 왼쪽이 더 큰가?

< : 오른쪽이 더 큰가?

>= : 왼쪽이 더 크거나 같은가?

<= : 오른쪽이 더 크거나 같은가?

== : 둘이 같은가?

!= : 같지 않은가?

public class ex23 {
    public static void main(String[] args) {
        //비교,논리 연산자는 결과값이 논리값으로 나옴. true/false
        //다른 모든 연산자는 결과값이 수치값으로 나옴.

        //비교연산자 : 왼쪽기준으로 A < B이면, A가 B보다 작은가? true/false
        //          : < 작은가?  > 큰가?
        //          : == 같은가?  = 대입연산자
        //          : != 같지않은가?
        //          : <= 같거나 작은가? ( < OR == )
        //             같으면 true, 작으면 true, 크면 false가 됨.
        //          : >= 같거나 큰가? ( > OR == )
        //             같으면 true, 크면 true, 작으면 false가 됨.
        int i = 10;
        int j = 20;
        System.out.println( i == j ); //연산의 결과는?
        System.out.println( i != j );
        System.out.println( i < j );
        System.out.println( i > j );
        System.out.println( i <= j );  // (i == j) OR (i < j)
        System.out.println( i >= j );  // (i == j) OR (i > j)
        //System.out.println( i =< j ); =< 이런 연산자는 없음.
        //System.out.println( i => j ); =>
        // =! : 이런 연산자는 없음.
    }
}

 

 

논리 연산자

&&, ||, !, &, |, ^(비트단위 논리연산자)

오직 불리언 형식으로만 값이 나온다.

 

&& : (AND)연산. 둘 모두 참(ture)일때 참이다.

|| : (OR) 연산.  둘중 하나만 참이여도 참이다.

! : (NOT) 연산. 부정 연산. 논리값을 부정한다.

& : 비트단위 논리 연산자. 두 데이터가 비트단위에서 같은 위치에 1의 값을 가지고 있다면 1의 값을 만든다.

| : 비트단위 논리 연산자. 두 데이터가 비트단위에서 같은 위치에 한곳에라도 1의 값을 가지고 있다면 1의 값을 갖는다.

^: 비트 단위 논리 연산자. 두 데이터가 비트단위에서 같은 위치에 서로 다른 값(0,1)을 가지고 있다면 1의 값을 갖는다.

 

public class ex28 {
    public static void main(String[] args) {
        //& | ^(비트단위 논리연산자)
        // 비트단위 AND : &
        // 비트단위 OR : |
        // 비트단위 XOR : ^
        int i = 1;     // 0000...0001
        int j = 2;     // 0000...0010
        int k = i & j; // 0000...0000  0
        int m = i | j; // 0000...0011  3
        int n = i ^ j; // 0000...0011  3
        System.out.println( k );
        System.out.println( m );
        System.out.println( n );
    }
}

 

 

비트단위 연산자를 제외하면 모두 중학교, 고등학교때 배운 내용이다.

프로그램을 짜는데 거의 모든것이라고 봐도 무방한 if조건문에서 논리 연산은 아주 요긴하게 쓰이니 헷갈리지 말자.

 

 

public class ex24 {
    public static void main(String[] args) {
        //논리연산자 : AND OR
        // AND 로직 : &&  엔퍼센트2개
        // OR 로직 : ||  세로바2개

        // AND 논리표
        // T && T => T  둘다 True일때만 True
        // T && F => F
        // F && T => F
        // F && F => F
        System.out.println( true && true );
        System.out.println( true && false );
        System.out.println( false && true );
        System.out.println( false && false );
        // OR 논리표
        // T || T => T
        // T || F => T
        // F || T => T
        // F || F => F  둘다 False일때만 False
        System.out.println( true || true );
        System.out.println( true || false );
        System.out.println( false || true );
        System.out.println( false || false );
        //논리반전 연산자
        // !T => F
        // !F => T
        System.out.println( !true );
        System.out.println( !false );
        // XOR ^ (비트단위 논리연산자)
        // 1 ^ 1 = 0
        // 1 ^ 0 = 1 서로 값이 다른 때만 1이다.
        // 0 ^ 1 = 1 서로 값이 다른 때만 1이다.
        // 0 ^ 0 = 0
        // 이진수 0000...0001
        //       0000...0010  XOR
        //       0000...0011
        System.out.println( 1 ^ 2 );
        System.out.println( Integer.toBinaryString(1) );
        System.out.println( Integer.toBinaryString(2) );
        System.out.println( Integer.toBinaryString(1 ^ 2 ) );

        //0000...0011 로 출력하고 싶으면,
        String str = String.format("%032d",
                Integer.parseInt(Integer.toBinaryString(1^2)));
        System.out.println( str );

    }
}

^ (XOR)은 본격적으로 이용하려고 하면 정말 헷갈리고 골치아프다.

하지만 일반적으로는 이런 비트단위의 데이터를 조작할 일이 없기 때문에 지금은 그냥 이런것이 있구나, 수준으로 넘어가면 된다.

 

 

 

비트단위 산술연산자

<<, >>, >>>(비트단위 이동연산자) - 쉬프트 연산자

 

<< : 오른쪽에서 왼쪽으로 n 비트만큼 이동함.

       컴퓨터는 2진수의 세계이기 때문에, 앞으로 한자리수 이동한다는 것은 숫자 * 2 된다는 의미이다. 

       c언어의 잔재. 처리 속도가 빨라서 사용했으나 컴퓨터 사양이 발전한 지금은 의미없는 소리다.

0001 >>1    =>     0010            - 1이 2가 되었다.
0001 >>2    =>     0100            - 1이 4가 되었다

>> : 왼쪽에서 오른쪽으로 n비트만큼 이동함.

       마찬가지로 /2가 됨.

       -1이나 +1에는 적용이 안됨.

 

둘 모두 산술목적의 연산이기 때문에 숫자의 부호(양수인지 음수인지)는 바뀌지 않음.

 

>>> : 비트단위에서 가상의 0이 가장 왼쪽에 들어와 한칸 밀어냄.

ex)

        /// >>> 연산자
        // 맨오른쪽 비트가 무조건 0으로 들어옴.
        // 1111 1111 >>> 1    =>     0111 1111

 이는 부호를 바꾸기도 함.

 

비트단위 연산자는 사용하지 않음.

<< >>는 산술연산에서 사용될수도 있지만, 제약이 존재하고 가독성도 떨어지는데다 이점이 없기 때문에 가급적이면 사용하지 말자.

 

public class ex26 {
    public static void main(String[] args) {
        //산술연산자 : << >> >>>(비트단위 이동연산자) - 쉬프트연산자
        // << : 오른쪽에서 왼쪽으로 n비트 이동함.
        //    : *2의 효과가 있음. 속도가 빠름.
        //    : 0000 0001 << 1 1     0000 0001 << 2
        //      0000 0010 << 1 2     0000 0100
        //      0000 0100      4
        // >> : 왼쪽에서 오른쪽으로 n비트 이동함.
        //    : /2의 효과가 있음.
        int i = 1;
        System.out.println( i << 1 );
        System.out.println( i << 2 );
        i = 8;
        System.out.println( i >> 1 );
        System.out.println( i >> 2 );

        // << >> : 산술을 목적으로 하기 때문에 +/- 기호가 바뀌지 않음.
        i = -1; //이진수는? +1의 2의보수를 구한다.
                // 0000 0001
                // 1111 1110 1의 보수
                // 1111 1111 +1
        System.out.println( Integer.toBinaryString(i) );
        // 1111 1111
        // 1 1111 1111 0
        System.out.println( i << 1 ); // -1 * 2
        System.out.println( Integer.toBinaryString(-2) );
        // 1111 1111
        i = -8;
        System.out.println( i >> 1 );  // -8 / 2 = -4
        System.out.println( i >> 2 );  // -8 / 4 = -2

        /// >>> 연산자
        // 맨오른쪽 비트가 무조건 0으로 들어옴.
        // 1111 1111 >>> 1
        // 0111 1111
        int k = -1;
        k = k >>> 1;
        System.out.println( k );
        System.out.println( Integer.toBinaryString(k) );

    }
}

 

삼항연산자

? :

? 연산자라고도 불림

형식 : 조건절 ? A값 : B값

조건절이 true가 되면 A값을, false면 B값을 준다.

c언어의 잔재. if조건문이 훨씬 보기도 좋고 쓰기도 좋으니 어지간하면 그걸 쓰자.

public class ex29 {
    public static void main(String[] args) {
        //삼항연산자  ? :
        //?연산자라고도 함.
        // 조건절 : 비교,논리연산자로 구성된 코드
        // 형식 : 조건절 ? A값 : B값
        // 조건절이 true이면 A값을 반환, false이면 B값을 반환.
        // * if조건문으로 대체가능하므로, 자꾸 사용하는 것은 권장 안함!
        int n = ( true ) ? 10 : 20;
        System.out.println( n );
        int m = ( false ) ? 10 : 20;
        System.out.println( m );

        //가독성 : 읽기 쉬운 코드인가 나타냄.
        //가독성 안 좋아지는 예)
        int k = ( 10 < 20 ) ? ( 20 < 30 ? 20 : 30 ) : 20;
        System.out.println( k );

        m = ( false ) ? 10 : 20;
        //조건문 if로 바꿔보자.
        if( false ) {
            m = 10;
        }else{
            m = 20;
        }
    }
}

 

 

대입연산자

= += -+ *= /=  >>=  <<=   %=

 

별거 없다.

오른쪽 항에서 왼쪽 항으로 간다는 것만 기억하자.

복합 대입 연산자의 이해를 돕기 위해 예시 하나만 작성하겠다.

A += 10    =>   A = A+10        두 식은 같은 의미다. 나머지 산술연산도 전부 마찬가지다.

 

public class ex30 {
    public static void main(String[] args) {
        // 대입연산자 =
        // A = B 오른쪽의 값을 왼쪽으로 덮어쓰기 한다.
        // 연산의 방향이 Right => Left
        int i = 10;
        int j = 20;
        int k = 30;
        i = j = k = 40;
        System.out.println( i );
        System.out.println( j );
        System.out.println( k );

        //복합대입연산자
        // A += B : A = A + B
        // A -= B : A = A - B
        // A *= B : A = A * B
        // A /= B : A = A / B
        //그외는 동일함. %= <<= >>=
        i = 0;
        i += 10; // i = i + 10
        System.out.println( i );
        i -= 5; // i = i - 5
        System.out.println( i );
        i *= 2; // i = i * 2
        System.out.println( i );
        i /= 2; // i = i / 2
        System.out.println( i );
    }
}