자바의 정석 3장: 연산자(Operator)

3️⃣

[ 출처 ]
자바의 정석:
https://product.kyobobook.co.kr/detail/S000001550352
자바의 정석 유튜브:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

1. 연산자(operator)

1.1 연산자와 피연산자

1.2 식(式)과 대입연산자

1.3 연산자의 종류

피연산자의 개수에 의한 분류

1.4 연산자의 우선순위와 결합규칙

연산자의 결합규칙

1.5 산술 변환(usual arithmetic conversion)

2. 단항 연산자

2.1 증감 연산자 ++ --

2.2 부호 연산자 + -

3. 산술 연산자

3.1 사칙 연산자 + - *

정수형 - byte, short, int, long

문자형 - char

실수형

3.2 나머지 연산자 %

4. 비교 연산자(p.109)

4.1 대소비교 연산자 < > <= >=

4.2 등가비교 연산자 == !=

5. 논리 연산자

5.1 논리 연산자 - &&, ||, !

효율적인 연산(short circuit evaluation)

논리 부정 연산자 !

5.2 비트 연산자 & | ^ ~ << >>

비트 전환 연산자 ~

쉬프트 연산자 << >>

6. 그 외의 연산자

6.1 조건 연산자 ? :

6.2 대입 연산자 = op=

lvalue와 rvalue

연

6번

1. 연산자(operator)

1.1 연산자와 피연산자

연산자(operator) : 연산을 수행하는 기호(+, -, *, / 등)

피연산자(operand) : 연산자의 연산 수행 대상(변수, 상수, 리터럴, 수식)

연산자는 피연산자로 연산을 수행하고 나면 항상 결과값을 반환한다.

1.2 식(式)과 대입연산자

책 86p. 참고

1.3 연산자의 종류

종류	연산자	설명
산술 연산자	+ - * / % << >>	사칙 연산과 나머지 연산(%)
비교 연산자	> < ≥ ≤ == ≠	크고 작음과 같고 다름을 비교
논리 연산자	&& || ! & | ^ ~	‘그리고(AND)’와 ‘또는(OR)’으로 조건을 연결
대입 연산자	=	우변의 값을 좌변에 저장
기타	(type) ?: instanceof	형변환 연산자, 삼항 연산자, instanceof 연산자

피연산자의 개수에 의한 분류

피연산자의 개수로 연산자를 분류하기도 하는데, 피연산자의 개수가 하나면 ‘단항 연산자’, 두 개면 ‘이항 연산자’, 세 개면 ‘삼항 연산자’라고 부른다. 대부분의 연산자는 ‘이항 연산자’이고 삼항 연산자는 오직 ‘? :’ 하나 뿐이다.

위의 식에는 두 개의 연산자가 포함되어 있는데, 둘 다 같은 기호 ‘-’로 나타내지만 엄연히 다른 연산자이다. 왼쪽의 것은 ‘부호 연산자’이고 오른쪽의 것은 ‘뺄셈 연산자’이다. 이처럼 서로 다른 연산자의 기호가 같은 경우도 있는데, 이럴 때는 피연산자의 개수로 구분이 가능하다.

‘부호 연산자’는 단항 연산자로 피연산자가 ‘3’ 한 개뿐이지만 ‘뺄셈 연산자’는 이항 연산자로 피연산자가 ‘-3’과 ‘5’ 두 개이다.

이처럼 연산자를 기능별, 피연산자의 개수별로 나누어 분류하는 것은 곧이어 배우게 될 ‘연산자의 우선순위’때문이기도 하다. 연산자마다 우선순위가 다르지만, 같은 종류의 연산자들은 우선순위가 비슷하기 때문에 각 종류별로 우선순위를 외우면 기억하기 더쉽다.

1.4 연산자의 우선순위와 결합규칙

연산자의 결합규칙

하나의 식에 같은 우선순위의 연산자들이 여러 개 있는 경우, 어떤 순서로 연산을 수행할까? 우선순위가 같다고 해서 아무거나 먼저 처리하는 것은 아니고 나름대로의 규칙을 가지고 있는데, 그 규칙을 ‘연산자의 결합규칙’이라고 한다.

대부분 왼쪽 → 오른쪽의 순서로 연산을 수행하고, 단항 연산자만 그 반대로, 오른쪽 → 왼쪽의 순서로 연산을 수행한다.

<연산자의 우선순위 정리>

1. 산술 > 비교 > 논리 > 대입. 대입은 제일 마지막에 수행된다.

2. 단항(1) > 이항(2) > 삼항(3). 단항 연산자의 우선순위가 이항 연산자보다 높다.

3. 단항 연산자와 대입 연산자를 제외한 모든 연산의 진행방향은 왼쪽에서 오른쪽이다.

<연산자의 우선순위와 결합규칙>

1.5 산술 변환(usual arithmetic conversion)

책 91p.

산술 변환이란? 연산 수행 직전에 발생하는 피연산자의 자동 형변환
① 두 피연산자의 타입을 같게 일치시킨다.(보다 큰 타입으로 일치)
② 피연산잔의 타입이 int보다 작은 타입이면 int로 변환된다.

첫 번째 규칙은 2장 변수의 자동 형변환 규칙 참고

두 번째 규칙은 2장 변수 정수형의 선택기준 참고

2. 단항 연산자

2.1 증감 연산자 ++ --

❕

증가 연산자(++) 피연산자의 값을 1 증가시킨다.
감소 연산자(--) 피연산자의 값을 1 감소시킨다.

타입	설명	사용예
전위형	값이 참조되기 전에 증가시킨다.	j = ++i;
후위형	값이 참조된 후에 증가시킨다.	j = i++;

그러나 ‘++i;’와 ‘i++;’처럼 증감연산자가 수식이나 메서드 호출에 포함되지 않고 독립적인 하나의 문장으로 쓰인 경우에는 전위형과 후위형의 차이가 없다.

++i; // i의 값을 1 증가시킨다.
i++; // 위의 문장과 차이가 없다.

증감 연산자가 포함된 식을 이해하기 어려울 때는 다음과 같이 증감 연산자를 따로 떼어내면 이해하기가 쉬워진다. 전위형의 경우 증감연산자를 식의 이전으로,

j = ++i; // 전위형

→

++i; // 증가 후에
j = i; // 참조하여 대입

후위형의 경우 증감연산자를 식의 이후로 떼어내면 된다.

j = i++; // 후위형

→

j = i; // 참조하여 대입 후에
i++; // 증가

• ch3 - OperatorEx3.java

  class OperatorEx03 {
  	public static void main(String args[]) {
  		int i=5, j=5;
  
  		System.out.println(i++);	
  		System.out.println(++j);
  		System.out.println("i = " + i + ", j = " +j);
  	}
  }

증감 연산자를 사용하면 코드가 간결해지지만, 지나치면 코드가 복잡해서 이해하기 어려워지기도 한다. 예를 들어 x의 값이 5일 때, 아래 식이 수행된 후의 x의 값은 얼마일까?

x = x++ - ++x; // x의 값은 -1? -2?

생각보다 쉽게 답을 내기 어려울 것이다. 실제 프로그래밍에서는 이러한 코드를 작성할 일이 없고, 이렇게 작성하는 것은 바람직하지 않다. 하나의 식에서 증감연산자의 사용을 최소화하고, 식에 두 번 이상 포함된 변수에 증감연산자를 사용하는 것은 피해야 한다.

감소 연산자(--)는 피연산자의 값을 1 감소시킨다는 것만 빼면 증가 연산자와 동일하다.

2.2 부호 연산자 + -

부호 연산자 -'는 피연산자의 부호를 반대로 변경한 결과를 반환한다. 피연산자가 음수면 양수, 양수면 음수가 연산의 결과가 된다. 부호연산자'+'는 하는 일이 없으며, 쓰이는 경우도 거의 없다. 부호연산자 '-'가 있으니까 형식적으로 '+'를 추가해 좋은 것뿐이다.
부호 연산자는 boolean형과 char형을 제외한 기본형에만 사용할 수 있다.

3. 산술 연산자

산술 연산자에는 사칙 연산자(+, -, *, /)와 나머지 연산자(%)가 있다. 사칙연산은 일상생활에서 자주 사용하는 익숙한 것이라 그리 어렵지 않을 것이다. 다만 몇 가지 주의할 사항들이 있는데, 그것들을 중심으로 설명할 것이다.

3.1 사칙 연산자 + - *

정수형 - byte, short, int, long

int a = 10;
int b = 4;

System.out.printf("%d + %d = %d%n",  a, b, a + b);
System.out.printf("%d - %d = %d%n",  a, b, a - b);
System.out.printf("%d * %d = %d%n",  a, b, a * b);
System.out.printf("%d / %d = %d%n",  a, b, a / b);
System.out.printf("%d / %f = %f%n",  a, (float)b, a / (float)b);

나누기 연산자의 두 피연산자가 모두 int타입인 경우, 연산결과 역시 int타입니다. 그래서 실제 연산결과는 2.5일지라도 int타입의 값인 2를 결과로 얻는다. int타입은 소수점을 저장하지 못하므로 정수만 남고 소스점 이하는 버려지기 때문이다. 이때, 반올림이 발생하지 않는다는 것에 주의하자.

System.out.println(3/0);   // 실행하면, 오류(ArithmeticException) 발생
System.out.println(3/0.0); // Infinity가 출력됨

그리고 피연산자가 정수형인 경우, 나누는 수로 0을 사용할 수 없다. 만일 0으로 나누면 컴파일은 정상적으로 되지만 실행 시 오류(ArithmeticException)가 발생한다.

부동 소수점값인 0.0f, 0.0d로 나누는 것은 가능하지만 그 결과는 Infinity(무한대)이다.

byte a = 10;
byte b = 30;
byte c = a * b; // 에러 발생

System.out.println(c);

이 예제를 컴파일하면 에러가 발생한다. a와 b는 모두 int형보다 작은 byte형이기 때문에 연산자'+'는 이 두 개의 피연산자들의 자료형을 int형으로 변환한 다음 연산(덧셈)을 수행한다.

그래서 'a+b'의 연산결과는 byte형이 아닌 int형(4 byte)인 것이다. 4 byte의 값을 1 byte의 변수에 형변환없이 저장하려고 했기 때문에 에러가 발생하는 것이다.

byte a = 10;
byte b = 30;
byte c = (byte) (a * b); // 44출력

System.out.println(c);

이 예제를 실행하면 화면에 44가 출력된다. ‘10 * 30’의 결과는 300이지만, 형변환에서 배운 것처럼, 큰 자료형에서 작은 자료형으로 변환하면 데이터의 손실이 발생하므로 값이 바뀔 수 있다. 300은 byte형의 범위를 넘기 때문에 byte형으로 변환하면 데이터 손실이 발생하여 결국 44가 byte형 변수 c에 저장된다.

int a = 1000000;    // 1,000,000   1백만 
int b = 2000000;    // 2,000,000   2백만 

long c = a * b;     // a * b = 2,000,000,000,000 ?

System.out.println(c);

식 a * b의 결과 값을 담는 변수 2의 자료형이 long 타입(8 byte)이기 때문에 2 X 10$^{12}$을 저장하기에 충분하므로 ‘2000000000000’이 출력될 것 같지만, 결과는 전혀 다른 값이 출력된다.
그 이유는 int타입과 int타입의 연산결과는 int타입이기 때문이다. 'a * b의 결과가 이미 int타입의 값(- 1454759936)이므로 long형으로 자동 형변환되어도 값은 변하지 않는다.

   long c = a * b;
-> long c = 1000000 * 2000000;
-> long c = -1454759936;

올바른 결과를 얻으려면 아래와 같이 변수 a 또는 b의 타입을 ‘long’으로 변환해야 한다.

   long c = (long)a * b;
-> long c = (long)1000000 * 2000000;
-> long c = 1000000L * 2000000;
-> long c = 1000000L * 2000000L;
-> long c = 1000000000000L;

문자형 - char

char a = 'a';
char d = 'd';
char zero = '0';
char two = '2';

System.out.printf("'%c' - '%c' = %d%n", d, a, d - a); // 'd' - 'a' = 3
System.out.printf("'%c' - '%c' = %d%n", two, zero, two - zero);
System.out.printf("'%c'=%d%n", a, (int)a);
System.out.printf("'%c'=%d%n", d, (int)d);
System.out.printf("'%c'=%d%n", zero, (int)zero);
System.out.printf("'%c'=%d%n", two,  (int)two);

사칙연산의 피연산자로 숫자뿐만 아니라 문자도 가능하다. 문자는 실제로 해당 문자의 유니코드(부호없는 정수)로 바뀌어 저장되므로 문자간의 사칙연산은 정수간의 연산과 동일하다. 주로 문자간의 뺄셈을 하는 경우가 대부분이며, 문자 ‘2’를 숫자로 변환하려면 다음과 같이 문자 '0을 빼주면 된다.

'2' - '0' -> 50 - 48 -> 2

문자 2의 유니코드는 50이고, 문자 '0’은 48이므로, 두 문자간의 뺄셈은 2를 결과로 얻는다. 아래의 표는 유니코드의 일부인데, '0'~’9’까지의 문자가 연속적으로 배치되어 있는 것을 알 수 있다. 그렇기 때문에 해당 문자에서 ‘0'을 빼주면 숫자로 변환되는 것이다.

<숫자와 영문자의 유니코드>

문자	코드
0	48
1	49
2	50
3	51
4	52
5	53
6	54
7	55
8	56
9	57

문자	코드
A	65
B	66
C	67
D	68
E	69
…	…
W	87
X	88
Y	89
Z	90

문자	코드
a	97
b	98
c	99
d	100
e	101
…	…
w	119
x	120
y	121
z	122

• Operator12.java

  char c1 = 'a';        // c1에는 문자 'a'의 코드값인 97이 저장된다. 
  char c2 = c1;         // c1에 저장되어 있는 값이 c2에 저장된다. 
  char c3 =' ';         // c3를 공백으로 초기화 한다. 
  
  int i = c1 + 1;       // 'a'+1 → 97+1 → 98
  
  c3 = (char)(c1 + 1); 
  c2++; 
  c2++; 
  
  System.out.println("i=" + i); 
  System.out.println("c2=" + c2); 
  System.out.println("c3=" + c3);

char c1 = 'a';

// char c2 = c1 + 1; // 라인 5 : 컴파일 에러 발생
char c2 = 'a' + 1;   // 라인 6 : 컴파일 에러 없음
System.out.println(c2);

이 예제를 컴파일하면 오류가 발생하지 않고 실행도 올바른 결과를 얻는다. 덧셈 연산자와 같은 이항 연산자는 int보다 작은 타입의 피연산자를 int로 자동 형변환한다고 배웠는데 어째서 라인 6의 코드는 형변환을 해주지 않고도 문제가 없는 것일까?

그것은 바로 ‘a’+1이 리터럴 간의 연산이기 때문이다. 상수 또는 리터럴 간의 연산은 실행 과정동안 변하는 값이 아니기 때문에, 컴파일 시에 컴파일러가 계산해서 그 결과로 대체함으로써 코드를 보다 효율적으로 만든다.

<컴파일러에 의해서 최적화된 코드의 비교>

컴파일 전의 코드	컴파일 후의 코드
char c2 = ‘a’ + 1; int sec = 60 * 60 * 24;	char c2 = ‘b’; int sec = 86400;

위에서 알 수 있듯이 컴파일러가 미리 덧셈연산을 수행하기 때문에 실행 시에는 덧셈 연산이 수행되지 않는다. 그저 덧셈연산결과인 문자 ‘b’를 변수 c2에 저장할 뿐이다.

그러나 라인 5와 같이 수식에 변수가 들어가 있는 경우에는 컴파일러가 미리 계산을 할 수 없기 때문에 아래의 오른쪽 코드와 같이 형변환을 해주어야 한다. 그렇지 않으면 컴파일 에러가 발생한다.

char c2 = c1 + 1;

→

char c2 = (char) (c1+1);

일부러 뻔한 리터럴 연산을 풀어쓸 필요는 없지만, 코드의 가독성과 유지보수를 위해서 그렇게 하는 경우가 있다. 표3-9에서 int타입의 변수 sec에 하루를 초단위로 변환한 값을 저장하는 코드를 보면, ‘86400’이라는 값보다는 '60*60*24’와 같이 적어주는 것이 이해하기도 쉽고 오류가 발생할 여지가 적다. 나중에 반나절(12시간)로 값을 변경해야한다면 계산할 필요없이 '60*60*12'로 변경하면 되기 때문이다. 이렇게 풀어써도 결국 컴파일러에 의해서 미리 계산되기 때문에 실행 시의 성능차이는 없다.

• 예제 3-14 OperatorEx14

  class OperatorEx14 { 
        public static void main(String[] args) { 
              char c = 'a'; 
              for(int i=0; i<26; i++) {          // 블럭{} 안의 문장을 26번을 반복한다. 
                          System.out.print(c++); //'a'부터 26개의 문자를 출력한다. 
              } 
              
              System.out.println(); // 줄바꿈을 한다.
  
              c = 'A'; 
              for(int i=0; i<26; i++) {          // 블럭{} 안의 문장을 26번을 반복한다. 
                          System.out.print(c++); //'A'부터 26개의 문자를 출력한다. 
              } 
  
              System.out.println(); 
  
              c='0'; 
              for(int i=0; i<10; i++) {          // 블럭{} 안의 문장을 10번을 반복한다. 
                          System.out.print(c++); //'0'부터 10개의 문자를 출력한다. 
              } 
              System.out.println(); 
        } 
  }

char lowerCase = 'a';
char upperCase = (char) (lowerCase - 32);
System.out.println(upperCase);

💡 대문자와 소문자 간의 코드값 차이는 10진수로 32이다.

실수형

float pi = 3.141592f;
float shortPi = (int)(pi * 1000) / 1000f;
System.out.println(shortPi); // 3.141

(int) (pi * 1000) / 1000f; // 위의 수식에서 제일 먼저 수행되는 것은 괄호 안의 'pi * 1000'이다.
(int) (3141.592f) / 1000f; // 단항연산자인 형변환 연산자의 형변환이 수행된다. 3141.592f를 int로 변환하면 3141을 얻는다. 소수점 이하는 반올림 없이 버려진다.
3141 / 1000f; // int와 float의 연산이므로 int가 float로 변환된 다음, float와 float의 연산이 수행된다.
3141.0f / 1000f -> 3.141f;

• 예제 3-17 Operator17.java - 반올림되도록하는 예제

  class OperatorEx17 {
  	public static void main(String args[]) { 
  		double pi = 3.141592; 
  		double shortPi = (int)(pi * 1000 + 0.5) / 1000.0;
  
  		System.out.println(shortPi);
  	}
  }

• 예제 3-18 Operator18.java - 반올림되도록하는 예제2

  class OperatorEx18 {
  	public static void main(String args[]) { 
  		double pi = 3.141592; 
  		double shortPi = Math.round(pi * 1000) / 1000.0;
  
  		System.out.println(shortPi);
  	}
  }

3.2 나머지 연산자 %

책 108p.

4. 비교 연산자(p.109)

4.1 대소비교 연산자 < > <= >=

4.2 등가비교 연산자 == !=

5. 논리 연산자

5.1 논리 연산자 - &&, ||, !

|| (OR결합) 피연산자 중 어느 한 쪽만 true이면 true를 결과로 얻는다.

&& (AND결합) 피연산자 양쪽 모두 true이어야 true를 결과로 얻는다.

효율적인 연산(short circuit evaluation)

논리 연산자의 또 다른 특징은 효율적인 연산을 한다는 것이다. OR연산 ‘||’의 경우 두 피연산자 중 어느 한 쪽만 ‘참’이어도 전체 연산결과가 ‘참’이므로 좌측 피연산자가 ‘ture(참)’이면, 우측 피연산자의 값은 평가하지 않는다.

‘x가 true이면, x || y는 항상 true이다.’

AND연산 ‘&&’의 경우도 마찬가지로어느 한쪽만 ‘거짓(false)’이어도 전체 연산결과가 ‘거짓(false)’이므로 좌측 피연산자가 ‘거짓(false)’이면 우측 피연산자는 평가하지 않는다.

‘x가 false이면, x && y는 항상 false이다.’

그래서 같은 조건식이라도 피연산자의 위치에 따라서 연산속도가 달라질 수 있는 것이다. OR연산 ‘||’의 경우에는 ‘참’일 확률이 높은 피연산자를 연산자의 왼쪽에 놓아야 더 빠른 연산결과를 얻을 수 있다.

('a' <= ch && ch <= 'z' || ('A' <= ch && ch <= 'Z'))

위의 식은 문자 ch가 소문자 또는 대문자인지 확인하는 것인데, 이 식에서 문자 ch가 소문자인 조건을 대문자인 조건보다 왼쪽에 놓았다. 그 이유는 사용자로부터 문자 ch를 입력받을 때, 사용자가 대문자보다 소문자를 입력할 확률이 높다고 판단했기 때문이다. 실제로 사용자가 소문자를 더 자주 입력한다면, 이 식은 더 효율적으로 처리될 것이다.

---

class OperatorEx26 {
	public static void main(String[] args) { 
		int a = 5;
		int b = 0;

		System.out.printf("a=%d, b=%d%n", a, b);
		System.out.printf("a!=0 || ++b!=0 = %b%n", a!=0 || ++b!=0);
		System.out.printf("a=%d, b=%d\n", a, b);
		System.out.printf("a==0 && ++b!=0 = %b%n", a==0 && ++b!=0);
		System.out.printf("a=%d, b=%d%n", a, b);
	} // main의 끝
}

논리 연산자가 효율적인 연산을 하는지 확인하는 예제이다. 변수 b에 증감 연산자 ‘++’을 사용해서 우측 피연산자가 처리되면, b의 값이 증가하도록 했다.

그러나 실행결과에서 알 수 있듯이, 두 번의 논리연산 후에도 b의 값은 여전히 0인 채로 남아있다. ‘||(OR)’의 경우는 좌측 피연산자(a!=0)가 참이라서, 그리고 ‘&&(AND)’의 경우는 좌측 피연산자(a==0)가 거짓이라서 우측 피연산자를 평가하지 않았기 때문이다.

논리 부정 연산자 !

이 연산자는 피연산자가 true이면 false를, false면 true를 결과로 반환한다.

x	!x
true	false
false	true

논리 부정 연산자‘!’가 주로 사용되는 곳은 조건문과 반복문의 조건식이며, 이 연산자를 잘 사용하면 조건식이 보다 이해하기 쉬워진다. 예를 들어 ‘문자 ch는 소문자가 아니다’라는 조건을 아래의 왼쪽과 같이 쓰기보다 오른쪽과 같이 논리부정연산자’!’를 사용하는 쪽이 알기 쉽다.

ch < 'a' || ch > 'z'

↔

!('a' <= ch || ch <= 'z')

위와 같이 논리부정연산자’!’를 적절히 사용해서 보다 이해하기 쉬운 식이 되도록 노력하자.

---

식 ‘!!b’가 평가되는 과정

단항연산자는 결합방향이 오른쪽에서 왼쪽이므로 피연산자와 가까운 것부터 연산된다.

   !!b
-> !!true // 가까운 연산자가 먼저 연산된다.
-> !false // !true의 결과는 false이다.
-> true   // !false의 결과는 true이다.

5.2 비트 연산자 & | ^ ~ << >>

비트 연산자는 피연산자를 비트단위로 논리 연산한다. 피연산자를 이진수로 표현했을 때의 각 자리를 아래의 규칙에 따라 표3-14와 같이 연산을 수행하며, 피연산자로는 실수는 허용하지 않는다. 정수(문자 포함)만 허용된다.

| (OR연산자) 피연산자 중 한 쪽의 값이 1이면, 1을 결과로 얻는다. 그 외에는 0을 얻는다.

& (AND연산자) 피연산자 양 쪽이 모두 1이어야만 1을 결과로 얻는다. 그 외에는 0을 얻는다.

^ (XOR연산자) 피연산자의 값이 서로 다를 때만 1을 결과로 얻는다. 같을 때는 0을 얻는다.

<표 3-14 비트 연산자의 연산결과>

x	y	x | y	x & y	x ^ y
1	1	1	1	0
1	0	1	0	1
0	1	1	0	1
0	0	0	0	0

💡 연산자 ‘^’는 배타적 XOR(eXclusive OR)라고 하며, 피연산자의 값이 서로 다른 경우, 즉 배타적인 경우에만 참(1)을 결과로 얻는다.

비트OR연산자’|’는 주로 특정 비트의 값을 변경할 때 사용한다. 아래의 식은 피연산자 0xAB의 마지막 4 bit를 ‘F’로 변경하는 방법을 보여준다.

식	2진수	16진수
0xAB | 0xF = 0xAF	10101011 00001111 | ) —————— 10101111	0xAB 0x F —— 0xA F

비트AND연산자’&’는 주로 특정 비트의 값을 뽑아낼 때 사용한다. 아래의 식에서는 피연산자의 마지막 4bit가 어떤 값인지 알아내는데 사용되었다.

식	2진수	16진수
0xAB & 0xF = 0xB	10101011 00001111 & ) —————— 00001011	0xAB 0x F —— 0x B

비트XOR연산자’^’는 두 피연산자의 비트가 다를 때만 1이 된다. 그리고 같은 값으로 두고 XOR연산을 수행하면 원래의 값으로 돌아오는 특징이 있어서 간단한 암호화에 사용된다.

식	2진수	16진수
0xAB ^ 0xF = 0xA4 0xA4 ^ 0xF = 0xAB	10101011 00001111 ^ ) —————— 10100100 00001111 ^ ) —————— 10101011	0xAB 0xF —— 0xA4 0xF —— 0xAB

이해를 돕기 위해 2진수를 8자리로 표현한 것이고, 사실은 int타입(4 byte)간의 연산이라 32자리로 표현하는 것이 맞다. 그리고 비트연산에서도 피연산자의 타입을 일치시키는 ‘산술 변환’이 일어날 수 있다.

• 예제 3-28 OperatorEx28.java

  class OperatorEx28 {
  	public static void main(String[] args) { 
  		int x = 0xAB;
  		int y = 0xF;
  
  		System.out.printf("x = %#X \t\t%s%n", x, toBinaryString(x));
  		System.out.printf("y = %#X \t\t%s%n", x, toBinaryString(y));
  		System.out.printf("%#X | %#X = %#X \t%s%n", x, y, x | y, toBinaryString(x | y));
  		System.out.printf("%#X & %#X = %#X \t%s%n", x, y, x & y, toBinaryString(x & y));
  		System.out.printf("%#X ^ %#X = %#X \t%s%n", x, y, x ^ y, toBinaryString(x ^ y));
  		System.out.printf("%#X ^ %#X ^ %#X = %#X %s%n", x, y, y, x ^ y ^ y, toBinaryString(x ^ y ^ y));
  	} // main의 끝
  
  	// 10진 정수를 2진수로 변환하는 메서드
  	static String toBinaryString(int x) {
  		String zero = "00000000000000000000000000000000";
  		String tmp = zero + Integer.toBinaryString(x);
  
  		return tmp.substring(tmp.length()-32);
  	}
  }

비트 전환 연산자 ~

이 연산자는 피연산자를 2진수로 표현했을 때, 0은 1로, 1은 0으로 바꾼다. 논리부정 연산자 ‘!’와 유사하다.

<비트전환 연산자의 2진 연산결과>

x	~x
1	0
0	1

비트 전환 연산자 ‘~'에 의해 '비트 전환 되고 나면, 부호있는 타입의 피연산자는 부호가 반대로 변경된다. 즉, 피연산자의 1의 보수를 얻을 수 있는 것이다. 그래서 비트전환연산자 를 ‘1의 보수' 연산자라고도 한다.

예를 들어 10진수 10을 비트전환 연산한 결과는 -11이고, 이 값은 10의 ‘1의 보수'이다. 이미 배운 것과 같이 1의 보수에 1을 더하면 음수가 되므로 -11에 1을 더하면 -10이 되고 -11은 10의 1의 보수가 맞다는 것을 확인할 수 있다.

• 예제 3-29 OperatorEx29.java

  class OperatorEx29 {
  	public static void main(String[] args) {
  		byte p =  10;
  		byte n = -10;
  
  		System.out.printf(" p  =%d \t%s%n",  p,   toBinaryString(p));
  		System.out.printf("~p  =%d \t%s%n", ~p,   toBinaryString(~p));
  		System.out.printf("~p+1=%d \t%s%n", ~p+1, toBinaryString(~p+1));
  		System.out.printf("~~p =%d \t%s%n", ~~p,  toBinaryString(~~p));
  		System.out.println();
  		System.out.printf(" n  =%d%n",  n);	
  		System.out.printf("~(n-1)=%d%n", ~(n-1));
  	} // main의 끝
  
  	// 10진 정수를 2진수로 변환하는 메서드
  	static String toBinaryString(int x) {
  		String zero = "00000000000000000000000000000000";
  		String tmp = zero + Integer.toBinaryString(x);
  
  		return tmp.substring(tmp.length()-32);
  	}
  }

  양의 정수 p가 있을 때, p에 대한 음의 정수를 얻으려면 ‘~p+1’을 계산하면 된다.

  ‘~~p’는 변수 p에 비트 전환 연산을 두 번 적용한 것인데, 1을 0으로 바꿨다가 다시 0을 1로 바꾸므로 원래의 값이 된다. 그러나 연산결과의 타입이 byte가 아니라 int라는 것에 주의하자.

쉬프트 연산자 << >>

이 연산자는 피연산자의 각 자리(2진수로 표현했을 때)를 ‘오른쪽(>>)’ 또는 ‘왼쪽(<<)’으로 이동(shift)한다고 해서 ‘쉬프트 연산자(shift operator)’라고 이름 붙여졌다.

예를 들어 ‘8 << 2’는 왼쪽 피연산자인 10진수 8의 진수를 왼쪽으로 2자리 이동한다.

이때, 자리이동으로 저장범위를 벗어난 값들은 버려지고 빈자리는 0으로 채워진다.

‘<<’ 연산자의 경우, 피연산자의 부호에 상관없이 각 자리를 왼쪽으로 이동시키며 빈칸을 0으로만 채우면 되지만, ‘>>' 연산자는 오른쪽으로 이동시키기 때문에 부호있는 정수는 부호를 유지하기 위해 왼쪽 피연산자가 음수인 경우 빈자리를 1로 채운다. 물론 양수일 때는 0으로 채운다.

❕

x << n은 x * 2$^n$의 결과와 같다.
x >> n은 x / 2
$^n$의 결과와 같다.

그리고, 'x << n’ 또는 'x >> n’에서, n의 값이 자료형의 bit수 보다 크면, 자료형의 bit수로 나눈 나머지만큼만 이동한다. 예를 들어 int타입이 4 byte(=32 bit)인 경우, 자리수를 32번 바꾸면 결국 제자리로 돌아오기 때문에. 8 >ß> 32'는 아무 일도 하지 않는다. ‘8>>34'는 34를 32로 나눈 나머지인 2만큼만 이동하는 '3>>2’를 수행한다. 당연히 n은 정수 만 가능하며 음수인 경우, 부호없는 정수로 자동 변환된다.

곱셈이나 나눗셈 연산자를 사용하면 같은 결과를 얻을 수 있는데, 굳이 쉬프트 연산자를 제공하는 이유는 속도 때문이다.

8>>2이 8/4보다 속도가 더 빠름

그러나 프로그램의 실행속도도중요하지만 프로그램을 개발할 때 코드의 가독성 (readability)도 중요하다. 쉬프트 연산자가 속도가 빠르긴 해도 곱셈이나 나눗셈 연산자 보다는 가독성이 떨어질 것이다. 쉬프트 연산자보다 곱셈 또는 나눗셈 연산자를 주로 사용하고, 보다 빠른 실행속도가 요구되어지는 곳만 쉬프트 연산자를 사용하는 것이 좋다.

• 예제 3-30 OperatorEx30.java 표 3-18의 내용을 직접 확인할 수 있는 예제

  class OperatorEx30 {
  	public static void main(String[] args) {
  		int dec = 8;
  
  		System.out.printf("%d >> %d = %4d \t%s%n", dec, 0, dec >> 0, toBinaryString(dec >> 0));
  		System.out.printf("%d >> %d = %4d \t%s%n", dec, 1, dec >> 1, toBinaryString(dec >> 1));
  		System.out.printf("%d >> %d = %4d \t%s%n", dec, 2, dec >> 2, toBinaryString(dec >> 2));
  
  		System.out.printf("%d << %d = %4d \t%s%n", dec, 0, dec << 0, toBinaryString(dec << 0));
  		System.out.printf("%d << %d = %4d \t%s%n", dec, 1, dec << 1, toBinaryString(dec << 1));
  		System.out.printf("%d << %d = %4d \t%s%n", dec, 2, dec << 2, toBinaryString(dec << 2));
  		System.out.println();
  
  		dec = -8;
  		System.out.printf("%d >> %d = %4d \t%s%n", dec, 0, dec >> 0, toBinaryString(dec >> 0));
  		System.out.printf("%d >> %d = %4d \t%s%n", dec, 1, dec >> 1, toBinaryString(dec >> 1));
  		System.out.printf("%d >> %d = %4d \t%s%n", dec, 2, dec >> 2, toBinaryString(dec >> 2));
  
  		System.out.printf("%d << %d = %4d \t%s%n", dec, 0, dec << 0, toBinaryString(dec << 0));
  		System.out.printf("%d << %d = %4d \t%s%n", dec, 1, dec << 1, toBinaryString(dec << 1));
  		System.out.printf("%d << %d = %4d \t%s%n", dec, 2, dec << 2, toBinaryString(dec << 2));
  		System.out.println();
  
  		dec = 8;
  		System.out.printf("%d >> %2d = %4d \t%s%n", dec, 0,  dec >> 0,  toBinaryString(dec << 2));
  		System.out.printf("%d >> %2d = %4d \t%s%n", dec, 32, dec >> 32, toBinaryString(dec << 2));
  	} // main의 끝
  
  	// 10진 정수를 2진수로 변환하는 메서드
  	static String toBinaryString(int x) {
  		String zero = "00000000000000000000000000000000";
  		String tmp = zero + Integer.toBinaryString(x);
  
  		return tmp.substring(tmp.length()-32);
  	}
  }

• 예제 3-31 OperatorEx31.java 쉬프트, 비트AND 연산자를 이용해서 16진수를 끝에서부터 한자리씩 뽑아내는 예제
  비트AND연산자는 두 bit가 모두 1일 때만 1이 되므로 0xABCD와 0x000F를 비트AND연산하면 마지막 자리만 남고 나머지자리는 모두 0이된다.
  

  class OperatorEx31 {
  	public static void main(String[] args) {
  		int dec  = 1234; 
  		int hex  = 0xABCD;
  		int mask = 0xF;
  
  		System.out.printf("hex=%X%n", hex);
  		System.out.printf("%X%n", hex & mask);
  		
  		hex = hex >> 4;
  		System.out.printf("%X%n", hex & mask);
  
  		hex = hex >> 4;
  		System.out.printf("%X%n", hex & mask);
  
  		hex = hex >> 4;
  		System.out.printf("%X%n", hex & mask);
  	} // main의 끝
  }

6. 그 외의 연산자

6.1 조건 연산자 ? :

6.2 대입 연산자 = op=

lvalue와 rvalue

대입 연산자의 왼쪽 피연산자를 ‘lvalue(left value)’이라 하고, 오른쪽 피연산자를 ‘rvalue(right value)’라고 한다.

연

6번

float celcius = (float) ((int) (5/9.0f * (fahrenheit - 32) * 1000 + 0.5) * 0.001);

Uploaded by N2T