[Java] 3일차 : 관계 연산자, 동등 연산자, 논리 연산자, 비트 연산자, 대입 연산자, 배정 연산자

 

 

▶ 증감연산자 ( ++, -- 는 형변환이 일어나지 않음)

package ch03.unit01;

public class Ex10 {

	public static void main(String[] args) {
		char c;
		
		c = 'A';
		// c = c + 1; // 컴파일오류
		// c = (char)(c + 1);
		c++; // ++, -- 는 형변환이 일어나지 않는다.
		
		System.out.println(c); // B
		
		c = 'A';
		System.out.println((c++) + ", " + (++c)); // A, C

	}

}

 

결과

 

 

 

관계 연산자
오퍼랜드가 두 개인 이항 연산자로 수식을 오퍼랜드로 취하여 결과 값이 참인 경우 true,
거짓인 경우 false을 반환한다.

연산자	의미	ex
<	~보다 적다	a가 b보다 적으면 true, 그렇지 않으면 false
<=	~보다 적거나 같다	a가 b보다 적거나 같으면 true, 그렇지 않으면 false
>	~보다 크다	a가 b보다 크면 true, 그렇지 않으면 false
>=	~보다 크거나 같다	a가 b보다 크거나 같으면 true, 그렇지 않으면 false

동등 연산자
오퍼랜드가 두 개인 이항 연산자, 수식을 오퍼랜드로 취하여 결과 값이 참인 경우 true, 거짓인 경우
false을 반환한다. 

 

연산자	의미	ex
==	~와 같다	a == b / a와 b가 같으면 true, 그렇지 않으면 false
!=	~와 같지 않다	a != b / a와 b가 같지 않으면 true, 그렇지 않으면 false

 

 

 

 

package ch03.unit02;

public class Ex01 {

	public static void main(String[] args) {
		// 관계 연산자 : 연산 결과는 true 또는 false
		int a = 10, b = 5;
		boolean c;
		
		System.out.println(a + ", " + b);
		
		c = a > b;
		System.out.println("a > b : " + c);
		System.out.println("a >= b : " + (a >= b));
		System.out.println("a < b : " + (a < b));
		System.out.println("a <= b : " + (a <= b));
		System.out.println("a == b : " + (a == b));
		System.out.println("a != b : " + (a != b));

	}

}

 

결과

 

 

 

 

논리 연산자
이항연산자로 논리합(||), 논리곱(&&) 연산자가 있다.

연산자	의미	ex
&&	논리곱(AND)	a와 b가 참이면 true, 그렇지 않으면 false
||	논리합(OR)	a 또는 b가 참이면 true, 그렇지 않으면 fasle
!	논리 부정(NOT)	a가 거짓이면 true, 참이면 fasle

 

package ch03.unit02;

public class Ex02 {

	public static void main(String[] args) {
		boolean a = true, b = false;
		
		System.out.println("a:"+a+", b:"+b);
		System.out.println("a&&b : " + (a&&b));
		System.out.println("a||b : " + (a||b));
		System.out.println("!a : " + (!a));
	}

}

 

 

결과

 

▶단축연산 

• && : 앞이 거짓이면 뒤는 연산하지 않음
• || : 앞이 참이면 뒤는 연산하지 않음 

package ch03.unit02;

public class Ex03 {

	public static void main(String[] args) {
		int a;
		boolean b1, b2;
		
		a = 10;
		b1 = false;
		b2 = a > 20 && (b1 = true); // 단축연산. &&:앞이 거짓이면 뒤는 연산하지 않음 
		System.out.println(b1 + ", " + b2); // false, false
		
		a = 10;
		b1 = false;
		b2 = a < 20 && (b1 = true); 
		System.out.println(b1 + ", " + b2); // true, true
		
		a = 10;
		b1 = false;
		b2 = a > 20 || (b1 = true); 
		System.out.println(b1 + ", " + b2); // true, true

		a = 10;
		b1 = false;
		b2 = a < 20 || (b1 = true); // 단축연산. ||는 앞이 참이면 뒤연산을 하지 않음
		System.out.println(b1 + ", " + b2); // false, true
		
	}

}

 

결과

 

 

package ch03.unit02;

public class Ex04 {

	public static void main(String[] args) {
		int a, b;
		boolean c;
		
		System.out.println("a:20, b:20");
		
		a = 20; b = 20;
		c = ++a > 20 && ++b > 20;
		System.out.println(a + ", " + b + ", " + c); // 21,21,true
	
		a = 20; b = 20;
		c = a++ > 20 && ++b > 20;
		System.out.println(a + ", " + b + ", " + c); // 21,20,false
		
		a = 20; b = 20;
		c = ++a > 20 && b++ > 20;
		System.out.println(a + ", " + b + ", " + c); // 21,21,false

		a = 20; b = 20;
		c = ++a > 20 || ++b > 20;
		System.out.println(a + ", " + b + ", " + c); // 21,20,true
		
		a = 20; b = 20;
		c = a++ > 20 || ++b > 20;
		System.out.println(a + ", " + b + ", " + c); // 21,21,true 

		a = 20; b = 20;
		c = ++a > 20 || b++ > 20;
		System.out.println(a + ", " + b + ", " + c); // 21,20,true
	}

}

 

결과

 

 

 

비트 연산자
피 연산자로 byte, short, char, int, long 타입만 가능하며,
double, float형은 사용할 수 없다.
boolean형은 비트 단위 shift 연산을 제회한 나머지 비트 단위 연산은 가능하고 결과는 boolean 형이다.
byte, short, char 타입의 경우 피 연산자를 int로 자동 변환하여 연산 하므로, 결과의 자료형은 int 형이다.


비트 단위 부정 연산자 
컴퓨터 내부 2진수 값을 1의 보수(반전)된 값을 구하는 단항 연산자 

연산자	의미		ex
~	해당 비트를 반전 (0→1,1→0)	b = ~a;	a값을 비트 단위로 반전시켜 b에 대입

비트 단위 논리 연산자
정수형 자료의 내부 2진수 값을 대상으로 논리 연산을 수행하는 이항 연산자

연산자	의미		ex
&	비트 단위 AND	c = a & b;	a와 b를 비트단위 AND 연산 후 c에 대입
|	비트 단위 OR	c = a | b;	a와 b를 비트단위 OR에 연산 후 c에 대입
^	비트 단위 Exclusive OR	c = a ^ b;	a와 b를 비트단위 XOR 연산 후 c에 대입  서로 다를때 1값을 갖고, 같을때는 0값을 갖는다.

 

 

package ch03.unit03;

public class Ex01 {

	public static void main(String[] args) {
		int a, b;
		
		a = 10; // 0000 1010
		b = ~a; // 1111 0101
		System.out.println(a + ", " + b); // 10, -11

		a = -10; // 1111 0110
		b = ~a; // 0000 1001
		System.out.println(a + ", " + b); // -10, 9
		
		a = 13; // 0000 1101
		b = 7;  // 0000 0111
		System.out.println("a&b:" + (a&b)); // 5:0101
		System.out.println("a|b:" + (a|b)); // 15:1111
		System.out.println("a^b:" + (a^b)); // 10:1010
	}

}

 

결과

 

 

 

비트 단위 이동(shift) 연산자
정수형 자료의 내부 비트를 좌측 또는 우측으로 이동(shift)시키는 이항 연산자

연산자	의미		ex
>>	산술적 우측 Shift 연산자	c = a >> b;	a를 2진수로 변환 후 b 비트만큼 우측으로 이동  (이동으로 생긴 왼쪽 자리는 MSB(부호)로 채움)
<<	산술적 좌측 Shift 연산자	c = a << b;	a를 2진수로 변환 후 b 비트만큼 좌측으로 이동 (이동으로 생긴 우측 자리는 0으로 채움)
>>>	논리적 우측 Shift 연산자	c = a >>> b;	a를 2진수로 변환 후 b 비트만큼 우측으로 이동 (이동으로 생긴 왼쪽 자리는 0으로 채움)

package ch03.unit03;

public class Ex02 {

	public static void main(String[] args) {
		// bit 단위 shift 연산자
		
		int a, b;
		
		a = 128;
		System.out.println("a:" + a);
		
		b = a << 3; // 좌측으로 3비트 이동. a * (2의3승)과 동일
		System.out.println("a<<3 : " + b); // 1024
		
		b = a >> 3; // 우측으로 3비트 이동. a / (2의3승)과 동일
		System.out.println("a>>3 : " + b); // 16
		
		a = -128;
		System.out.println("\na:" + a);
		
		b = a << 3;
		System.out.println("a<<3 : " + b); // -1024
		
		b = a >> 3; // 우측으로 이동하고 빈자리는 부호로 채움
		System.out.println("a>>3 : " + b); // -16
		
		b = a >>> 3; // 논리적 우측 shift
		// 우측으로 이동하고 빈자리는 0으로 채움
		System.out.println("a>>>3 : " + b);
	}

}

 

결과

 

package ch03.unit03;

public class Ex03 {

	public static void main(String[] args) {
		int a = 13, b = 10;
		
		System.out.println(a + " : " +  (a%2==0) ); // false
		System.out.println(b + " : " +  (b%2==0) ); // true

		// & 이 == 보다 연산 순위가 느림
		System.out.println(a + " : " +  ((a&1)==0) ); // false
		System.out.println(b + " : " +  ((b&1)==0) ); // true
		
		// a:13=>1101      b:10=>1010
		//   &   0001        &   0001
		// =>    0001        =>  0000
	}

}

 

 

결과

 

 

package ch03.unit03;

import java.util.Scanner;

public class Ex04 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a, b;
		
		System.out.print("두수 ? ");
		a = sc.nextInt();
		b = sc.nextInt();
		
		System.out.println("a:" + a + ", b:" + b);
		
		/*
		// 두 변수값 바꾸는 방법 1
		int c;
		c = a; a = b; b = c;
		*/
		
		// 두 변수값 바꾸는 방법 2
		a = a ^ b; 
		b = b ^ a; 
		a = a ^ b; 
		
		System.out.println("a:" + a + ", b:" + b);
		
		sc.close();
	}

}

 

결과

 

 

package ch03.unit03;

public class Ex05 {

	public static void main(String[] args) {
		int a = 123;
		int key = 7788;
		
		System.out.println("a:" + a);
		
		a = a ^ key; // 암호화의 기본 연산에 사용
		System.out.println("암호화 : " + a);
		
		a = a ^ key;
		System.out.println("복호화 : " + a);
	}
}

 

결과

 

---

 

 

대입연산자
우측의 값을 좌측에 대입

연산자	의미		ex
=	우변의 값을 좌변에 대입	a = b;	b의 값을 a변수에 대입

배정연산자
먼저 배정되어 있는 연산을 한 후에 결과에 대한 대입 연산이 일어남
자료형을 유지시키면서 연산을 수행하므로 속도가 빠르다
byte,char,short형에 대한 연산에서 int형으로 형 변환이 일어나지 않고 자료 형이 유지된다.

연산자	의미		ex
+=	좌변과 우변의 값을 더해서 좌변에 대입	a += b;	a = a + b;
-=	좌변에서 우변의 값을 뺀 후 좌변에 대입	a -= b;	a = a - b;
*=	좌변과 우변의 값을 곱해서 좌변에 대입	a *= b;	a = a * b;
/=	좌변에서 우변의 값을 나눈 후 좌변에 대입	a /= b;	a = a / b;
%=	자변에서 우변의 값을 나눈 나머지를 좌변에 대입	a %= b;	a = a % b;
<<=	좌변 값을 우변 수만큼 비트단위로 좌측 이동한 값을 좌변에 대입	a <<= b;	a = a << b;
>>=	좌변 값을 우변 수만큼 비트단위로 우측 이동한 값을 좌변에 대입	a >>= b;	a = a >> b;
>>>=	좌변 값을 우변 수만큼 비트단위로 우측 이동한 값을 좌변에 대입 (빈 공간은 0으로 채움)	a >>>= b;	a = a >>> b'
&=	좌변과 우변의 값을 비트단위 AND 연산 후에 좌변에 대입	a &= b;	a = a & b;
^=	좌변과 우변의 값을 비트단위 베타적 OR 연산 후에 좌변에 대입	a ^= b;	a = a ^ b;
!=	좌변과 우변의 값을 비트단위 OR 연산 후에 좌변에 대입	a != b;	a = a | b;

 

 

 

package ch03.unit04;

public class Ex01 {

	public static void main(String[] args) {
		// 배정연산자
		short a, b;
		
		a = 10; b = 5;
		a = (short)(a + b); // 형변환 해야 함
		System.out.println(a);
		
		a = 10; b = 5;
		a += b; // 형변환이 일어나지 않으며 위보다 연산 속도 빠름
		System.out.println(a);
		
		char c = 'A';
		c += 10;
		System.out.println(c); // K
		
		float f = 3.5f;
		c = 'A';
		c += f;
		System.out.println(c); // D
		
		int n = 4;
		n *= 0.6;
		System.out.println(n); // 2
	}

}

 

 

결과

 

 

package ch03.unit04;

public class Ex02 {

	public static void main(String[] args) {
		int a;
		a = (+-+-+-((5%3)*(4/2)));
		System.out.println(a); // -4
		
		int x = 2, y = 5, z = 0;
		x += 3 + 2;
		System.out.println(x); // 7
		
		x += y -= z = 4; // 8 1 4
		System.out.println(x + "," + y + "," + z);

	}

}

 

결과