Java practice_231228

진수(Radix)

• 서로 다른 모양(2진수, 8진수 등)의 숫자 몇 개를 가지고 모든 수를 표현

코딩에서 진수 사용법

• 10진수(Decimal) : 숫자 //0123456789/10 11 12 13....
• 8진수(Octal) : 0숫자 //01234567/10 11 12 13 14 15 16 17/20 21....
• 16진수(Hex) : 0x숫자 //0123456789a(10)b(11)c(12)d(13)e(14)f(15)/10 11 12...1a 1b....
• 2진수(Binary) //01

package day1228;
class Radix {
	
	public static void main(String[] args) {
		/*
		..배씩 늘어남..256 / 128 / 64 / 32 / 16 / 8 / 4 / 2 / 1
		OOOO OOOO

		10진수를 2진수로 바꾸기 //2의 배수를 합해서 값만들기(각 자리x)
		25 = 11001
		89 = 1011001
		300 = 100101100
		*/

		int i = 10;//10진수 -> 2진수로 저장
		int j = 012;//8진수 -> 2진수로 저장
		int k = 0xa;//16진수 -> 2진수로 저장 //ex)10진수 1190 = 16진수 4a6 = java 0x4a6

		System.out.println(i+j+k); //2진수를 연산하여 10진수로 보여줌

		System.out.println(Integer.toBinaryString(300));//10진수를 2진수로 바꾸기
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
		/*
		8진수를 2진수로 바꾸기
		025
		4/2/1
		5 -> 101(4+1)
		2 -> 010(2)
		0001 0101 (16+4+1=21(10진수로 21))

		030 = 11000 //숫자 맞춰 넣고 3자리중 나머지에 0 넣기
		0201 = 1000 0001
		0300 = 1100 0000
		*/

		System.out.println(Integer.toBinaryString(030));//8진수를 2진수로 바꾸기
		System.out.println(Integer.toBinaryString(0201));//8진수를 2진수로 바꾸기
		System.out.println(Integer.toBinaryString(0300));//8진수를 2진수로 바꾸기
		
		//10진수를 8진수로 바꾸기
		System.out.println(Integer.toOctalString(300));
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
		/*
		16진수를 2진수로 바꾸기
		숫자 하나당 8/4/2/1
		0x2b
		0010 1011
		0x5c
		0101 1100

		0x25
		0010 0101
		0x1d 13
		0001 1101
		0xff 15
		1111 1111
		*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////	

		//10진수를 16진수로 바꾸기
		System.out.println(Integer.toHexString(37));

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
		//16진수를 2진수로 바꾸기
		System.out.println("0x25를 2진수로 : " + 
				Integer.toBinaryString(0x25));//16진수를 2진수로 바꾸기
		System.out.println("0x1d를 2진수로 : " +
				Integer.toBinaryString(0x1d));//16진수를 2진수로 바꾸기
		System.out.println("0xff를 2진수로 : " +
				Integer.toBinaryString(0xff));//16진수를 2진수로 바꾸기

		/*
		2진수 음수 표현 - 보수법(맨 앞 1) 사용. 전체 1에 빠지는 곳에 0
		맨 앞 : 0 양수 / 1 음수
		0 : 0000 0000 -1 : 1111 1111
		1 : 0000 0001 -2 : 1111 1110
		2 : 0000 0010 -3 : 1111 1101
		...
		0000 1100 : 12 / 1111 0011 : -13(-(12+1))
		*/

		
	}//main
}//class

최(우선) 단(항)산(술)쉬(프트) 관(계)(논)리 삼(항)대(입) 콤마(지막)

연산자(Operator)

1. 단항

연산에 필요한 항이 하나인 연산자

• ~, !, +, -, ++, --

package day1228;

class Operator1{
	public static void main(String[] args){
		/*
		~:tilde -1의 보수 연산
		<~양수 : 부호변경 1증가, ~음수 : 부호변경 1감소>
		~12 => -13
		~-13 => 12
		*/

		int i=10, j=-10;
		System.out.println("~" + i + "=" + ~i);//-11
		System.out.println("~" + j + "=" + ~j);//9

		//~를 사용하여 부호만 변경하고 싶다. -10만들기
		System.out.println("-10 만들기 : " + (~i+1));
        
///////////////////////////////////////////////////////////////////////////////////////////////////////////
		/*
		! : not - true => false / false => true 변경
		true나 false 앞에만 사용가능
		!(3>4) : true
		*/

		i = 12;
		j = 28;
		System.out.println(!(i < j));//!은 true, false 앞에서만 정의가능
		System.out.println(i + "<" + j + "=" + (!(i < j)));

		boolean flag1=true, flag2=false;
		System.out.println("!" + flag1 + "=" + !flag2);
        
//////////////////////////////////////////////////////////////////////////////////////////////////////////
		/*
		+ : 형식적인 제공
		+9 = 9
		+-9 = -9

		- : 값은 그대로, 부호만 바꿈
		*/

		i = 12;
		j = -12;
		System.out.println("-" + i + "=" + -i);
		System.out.println("-" + j + "=" + -j);
        
//////////////////////////////////////////////////////////////////////////////////////////////////////////
		/*
		++ : 증가연산
		-- : 감소연산

		변수에만 사용가능.
		단독으로 사용되면, 대상체의 값을 1씩 증가 또는 1씩 감소시킴

		전위연산 : 연산자&대상체
				연산자&대상체 : 후위연산
		
		int i = 100;
		++i//101
		i++//102
		*/

		i = 5;
		j = 10;
		System.out.println("설정된 값: " + i + ", " + j);

		++i;//전위연산 5->6
		--j;//전위연산 10->9
		++i;//전위연산 6->7
		--j;//전위연산 9->8
		System.out.println("전위연산 후: " + i + ", " + j);

		i++;//후위연산 7->8
		j--;//후위연산 8->7
		System.out.println("후위연산 후: " + i + ", " + j);
        
/////////////////////////////////////////////////////////////////////////////////////////////////////
		/*
		대입연산자와 함께 사용되면 전위와 후위는 다른 값을 대입해준다.
		전위 : 단항 먼저(증가, 감소 연산 후 대입)
		후위 : 대입 먼저(대입 후 증가, 감소 연산)

		int i = 12;
		int result = 0;

		result = ++i
		*/

		//전위와 후위는 대입연산과 함께 사용되며 각자 다른 값을 대입한다.
		i = 10;
		int result = 0;
		//전위 연산 : 단항을 수행 후 대입 수행
		result = ++i;
		System.out.println("전위 후 : result : " + result + ", i : " + i);

		i = 10;
		//후위연산 : 남의 것 먼저(대입 후 단항에 수행)
		result = i++;
		System.out.println("후위 후 : result : " + result + ", i : " + i);

		i=10;
		j=10;
		System.out.println("전위 : " + ++i + " 후위 : " + j++);
		System.out.println("method 호출 후 i : " + i + " , j : " + j);//할당 후

	}//main
}//class

---

2. 산술연산자

• +, -, *, /, %(나머지)

package day1228;
class Operator2 {
	public static void main(String[] args) {
		int i = 10;
		System.out.println(i + "를 2로 나눈 나머지 : " + (i % 2)); //0 또는 1
		i = 116849;
		System.out.println(i + "를 2로 나눈 나머지 : " + (i % 2));//0 또는 1

		int birth = 2024;
		System.out.println(birth + "를 2로 나눈 나머지 : " + (birth % 12));
		//0-원숭이, 1-닭, 2-개, 3-돼지, 4-쥐, 5-소, 6-호랑이, 7-토끼, 8-용, 9-뱀, 10-말, 11-양

		//정수 / 정수 = 정수
		int num = 10;
		int num2 = 3;
		System.out.println(num + "/" + num2 + "=" + (num / num2));

		//정수/실수=실수 : 연산 결과를 실수로 얻으려면 나누는 수 중 하나는 실수여야한다.
		System.out.println(num + "/" + num2 + "=" + (num / (double)num2));

		//쉬프트 대입
		i <<= 4; //i = i << 4; //0000 0010 << 4 = 0010 0000
		i >>= 1; //i = i >> 1; //0010 0000 >> 1 = 0001 0000
		i >>>= 2; //i = i >>> 2; //0001 0000 >>> 2 = 0000 0100

		//비트논리 대입
		i &= 20; //i = i&20; //0000 0100 & 0001 0100 = 0000 0100 (4)

		System.out.println(i);

	}//main
}//class

---

3. 쉬프트 연산자

• << : left shift 비트를 왼쪽으로 밀고, 밀어서 빈칸을 항상 0으로 채움
• >> : right shift 비트를 오른쪽으로 밀고, 밀어서 빈칸을 최상위 부호비트에 따라 양수면 0을 음수면 1을 채움
• >>> : unsigned right shift 비트를 오른쪽으로 밀고, 밀어서 빈칸을 항상 0으로 채움

package day1228;
class Operator3{
	public static void main(String[] args){
		int i = 5;
		System.out.println(i + "<< 3 =" + (i<<3));//5<<3 = 40 0000 0101 << 0010 1000 40

		i = 60;
		System.out.println(i + ">> 4 =" + (i>>4));//0011 1100 -> 0000 0011 = 3

		i = 75;
		System.out.println(i + ">> 2 =" + (i>>2));//0100 1011 -> 0001 0010 18

		i = 29;										//128 / 64 / 32 / 16 / 8 / 4 / 2 / 1
		System.out.println(i + ">>> 1 =" + (i>>>1));//0001 1101 -> 0000 1110 14

		i = 1;										
		System.out.println(i + "<< 31 =" + (i<<31));//int가 가질 수 있는 최소값 -2147483648
		i = 1;										
		System.out.println(i + "<< 32 =" + (i<<32));//되돌아와서 1
		i = 6;										
		System.out.println(i + "<< 31 =" + (i<<31));//0

		i = -1;										
		System.out.println(i + ">> 5 =" + (i>>5));//-1은 몇칸을 밀어도 -1
		i = -1;										
		System.out.println(i + ">>> 1 =" + (i>>>1));//양수의 최고값 2147483647
	}//main
}//class

---

4. 관계연산자

대소비교

• 결과를 bollean으로 나온다.
• >, <, >=, <=, ==(같다), !=(다름)

package day1228;
class Operator4{
	public static void main(String[] args){
		int num=10, num2=20, num3=10; 
		System.out.println(num + "==" + num3 + "=" + (num==num3));//true
		System.out.println(num + "==" + num2 + "=" + (num==num2));//false

		System.out.println(num + "!=" + num3 + "=" + (num!=num3));//false
		System.out.println(num + "!=" + num2 + "=" + (num!=num2));//true
	}//main
}//class

---

5. 논리연산자

일반논리

• 여러 개의 관계연산자를 붙여서 연산해야 할 때

&&(and) : 전항과 후항이 모두 true일때만 true반환. 하나라도 false면 false
||(or) : 전항과 후항이 모두 false일때만 false반환. 하나라도 true면 true

비트논리

• 비트를 연산

&(and) : 상위비트와 하위 비트가 모두 1일때만 1내림 0있으면 0내림
|(or) : 상위비트와 하위 비트가 모두 0일때만 0내림 1있으면 1내림
^(xor) : 상위비트와 하위 비트가 둘 중 하나만 1일때 1내림, 1이 두개면 0내림

package day1228;
class Operator5{
	public static void main(String[] args) {
		boolean flag=true, flag2=false, flag3=true, flag4=false;
		System.out.println("--------------AND--------------");
		System.out.println(flag + " && " + flag3 + " = " + (flag&&flag3));//true
		System.out.println(flag + " && " + flag2 + " = " + (flag&&flag2));//false
		System.out.println(flag2 + " && " + flag3 + " = " + (flag2&&flag3));//false
		System.out.println(flag2 + " && " + flag4 + " = " + (flag&&flag4));//false

		System.out.println("--------------OR--------------");
		System.out.println(flag + " || " + flag3 + " = " + (flag||flag3));//true
		System.out.println(flag + " || " + flag2 + " = " + (flag||flag2));//true
		System.out.println(flag2 + " || " + flag3 + " = " + (flag2||flag3));//true
		System.out.println(flag2 + " || " + flag4 + " = " + (flag2||flag4));//false

		//&& : 전항이 false라면 후항을 연산하지 않는다.
		//|| : 전항이 true라면 후항을 연산하지 않는다.

		flag=false;
		flag2=false;
		flag3=false;

		flag3 = (flag = 3<2) && (flag2 = 5<6);
		System.out.println(flag + " && " + flag2 + " = " + flag3);

		int octalNum=0;//임의의 한자리의 양의수;//0~9
		//octalNumd이 8진수의 범위라면 true를 그렇지 않다면 false를 출력.
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=1;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=2;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=3;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=4;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=5;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=6;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=7;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=8;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		octalNum=9;
		System.out.print(octalNum + " 은(는) ");
		System.out.println((octalNum > -1) && (octalNum < 8));

		int tel=01012341234;//0으로 시작하는 수는 8진수
		System.out.println(tel);
		//8진수를 출력하면 10진수로 나온다. => 문자열로 해결
		
		
		////////////////////////////////////////////////////////////////////
		//비트논리

		//20 & 15 = 4
		//0001 0100
		//0000 1111
		//0000 0100 4

		//128 64 32 16 8 4 2 1
		//0010 0101 & 0000 1110 = 0000 0100 (4)
		//0010 0101 | 0000 1110 = 0010 1111 (47)
		//0010 0101 ^ 0000 1110 = 0010 1011 (43)

		int i =37, j = 14;
		System.out.println(i + "&" + j + "=" + (i&j));
		System.out.println(i + "|" + j + "=" + (i|j));
		System.out.println(i + "^" + j + "=" + (i^j));


	}//main
}//class