λ³Έλ¬Έ λ°”λ‘œκ°€κΈ°
JAVA/기본 이둠

5. μ—°μ‚°μž(Operator)와 μ—°μ‚° μˆœμœ„

by 🐳 Laboon 2024. 2. 10.
μ—°μ‚°μžλž€ ?

 

μš°λ¦¬λŠ” μ—°μ‚°μžμ— λŒ€ν•΄ 이미 μ•Œκ³  μžˆμŠ΅λ‹ˆλ‹€. +, -, *, / 와 같은 μ—°μ‚° 기호λ₯Ό μ˜λ―Έν•˜λŠ”λ°μš”.

ν”„λ‘œκ·Έλž˜λ° μ–Έμ–΄μ—μ„œλŠ” 사칙 μ—°μ‚° 외에도 λ‹€μ–‘ν•œ μ—°μ‚°μžκ°€ μžˆμŠ΅λ‹ˆλ‹€.

 

사칙연산 + λ‚˜λ¨Έμ§€ μ—°μ‚°
public class Main
{
	public static void main(String[] args) {
	    int a = 18, b = 4;
	    System.out.printf("a + b = %d\n", a + b);
	    System.out.printf("a - b = %d\n", a - b);
	    System.out.printf("a * b = %d\n", a * b);
	    System.out.printf("a / b = %d\n", a / b);
	    System.out.printf("a %% b = %d\n", a % b);
	}
}

μ»΄ν“¨ν„°μ—μ„œλŠ” 사칙연산은 μš°λ¦¬κ°€ μ‚¬μš©ν•˜λŠ” μ—°μ‚°μžμ™€ λ™μΌν•΄μ„œ μ‰½μŠ΅λ‹ˆλ‹€.

μΆ”κ°€λ‘œ modulo 연산은 % 기호λ₯Ό μ΄μš©ν•΄μ„œ μ‚¬μš©ν•˜λŠ”λ°μš”.

μžλ°”μ—μ„œ printf와 같은 좜λ ₯ν•¨μˆ˜λŠ” %d, %f 와 같이 좜λ ₯ν˜•μ‹ μ§€μ •μžμΈ %λ₯Ό μ΄μš©ν•©λ‹ˆλ‹€.

%λ₯Ό ν‘œν˜„ν•˜κΈ° μœ„ν•΄μ„œλŠ” λ‘λ²ˆ μž‘μ„±ν•˜μ—¬ escapeλ₯Ό ν•΄μ£Όμ–΄μ•Ό ν•˜λŠ”λ° μžμ„Έν•œ λ‚΄μš©μ€ μž…μΆœλ ₯μ—μ„œ 닀루도둝 ν•˜κ² μŠ΅λ‹ˆλ‹€.

μ˜ˆμƒ κ²°κ³ΌλŠ” 22, 14, 72, 4, 2 μž…λ‹ˆλ‹€.

μ‹œν”„νŠΈ μ—°μ‚°μž
public class Main
{
	public static void main(String[] args) {
	    // 1010
	    int a = 10;
	    
	    // left shift, 10100 
	    a = a << 1;
	    System.out.printf("a = %d\n", a);
	    
	    // right shift, 1010
	    a = a >> 1;
	    System.out.printf("a = %d\n", a);
	    
	    // left shift twice, 101000
	    a = a << 2;
	    System.out.printf("a = %d\n", a);
	}
}

μ»΄ν“¨ν„°μ—μ„œ 숫자λ₯Ό ν‘œν˜„ν•˜κΈ° μœ„ν•΄μ„œλŠ” 2μ§„λ²•μœΌλ‘œ ν‘œν˜„ν•˜κ²Œ λ©λ‹ˆλ‹€.

10의 κ²½μš°λŠ” 1010이 되죠.

shift 연산을 ν•˜κ²Œλ˜λ©΄ bitλ₯Ό μ™Όμͺ½ λ˜λŠ” 였λ₯Έμͺ½μœΌλ‘œ μΌμ •μˆ˜λ§ŒνΌ λ°€μ–΄λ²„λ¦¬κ² λ‹€λŠ” μ˜λ―Έκ°€ λ©λ‹ˆλ‹€.

 

10μ§„μˆ˜λ‘œ 예λ₯Ό λ“€μ–΄ λ³΄κ² μŠ΅λ‹ˆλ‹€.

10을 100으둜 ν‘œν˜„ν•˜λ €λ©΄ μ–΄λ–»κ²Œ ν•˜λ‚˜μš”? 10을 κ³±ν•΄μ£Όλ©΄ λ©λ‹ˆλ‹€.

10을 1000으둜 ν‘œν˜„ν•˜λ €λ©΄ ? 10을 2번 κ³±ν•΄μ£Όλ©΄ λ©λ‹ˆλ‹€.

νŠΉμ§•μ€ 0이 μ±„μ›Œμ§„λ§ŒνΌ 10을 κ³±ν–ˆλ‹€λŠ” 것이죠. (10μ§„μˆ˜ μ΄λ―€λ‘œ)

 

2μ§„μˆ˜μ—μ„œλ„ λ§ˆμ°¬κ°€μ§€μž…λ‹ˆλ‹€.

10을 20으둜 ν‘œν˜„ν•˜λ €λ©΄ 2λ₯Ό κ³±ν•˜λ©΄ λ©λ‹ˆλ‹€.

이 λ•Œ, 2μ§„μˆ˜λŠ” 2κΉŒμ§€ λ‚˜νƒ€λ‚΄λ―€λ‘œ 2μ§„μˆ˜ μƒμ—μ„œλŠ” 뒀에 0이 μ±„μ›Œμ§€κ²Œ λ©λ‹ˆλ‹€.

1010μ—μ„œ 10100이 λ˜λŠ” 것이죠.

 

이런 μˆ˜ν•™μ  νŠΉμ„±μ„ μ΄μš©ν•œ 것이 shift μ—°μ‚°μž…λ‹ˆλ‹€.

κ³±ν•˜κΈ° 연산보닀 λΉ λ¦…λ‹ˆλ‹€.

 

λΉ„νŠΈ μ—°μ‚°μž
public class Main
{
	public static void main(String[] args) {
	    // 1010
	    int a = 10;
	    // 1111
	    int b = 15;
	    System.out.printf("a and b μ—°μ‚° %d\n", a & b);          
	    System.out.printf("a or b μ—°μ‚° %d\n", a | b);           
	    System.out.printf("a xor b μ—°μ‚° %d\n", a ^ b);          
	    System.out.printf("not a μ—°μ‚° %d\n", ~a);            
	    System.out.printf("not b μ—°μ‚° %d\n", ~b);              
	    System.out.printf("notAnd(nand) μ—°μ‚° %d\n", ~(a & b));
	    System.out.printf("notOr(nor) μ—°μ‚° %d\n", ~(a | b));
	    System.out.printf("notXor μ—°μ‚° %d\n", ~(a ^ b));
	}
}

코딩을 ν•˜λ‹€λ³΄λ©΄ μ†λ„μ˜ 문제둜 2μ§„μˆ˜ 간에 λΉ„νŠΈμ—°μ‚°μ„ ν•˜κ²Œ λ˜λŠ” κ²½μš°κ°€ λ°œμƒν•©λ‹ˆλ‹€.

μ΄μœ λŠ” 일반적인 사칙연산보닀 λΉ λ₯Έ μ†λ„μ˜ μž₯점이 있기 λ•Œλ¬Έμž…λ‹ˆλ‹€.

aλŠ” 10(10) → 1010(2), bλŠ” 15(10) → 1111(2) 둜 λ³€ν™˜ ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

1010κ³Ό 1111의 and, or, xor 연산은 각 각 1010, 1111, 0101둜 10, 15, 5의 값을 κ°€μ§‘λ‹ˆλ‹€.

λ‹€λ§Œ μžλ°”μ—μ„œ not (~) 연산은 2의 보수 방법을 μ‚¬μš©ν•˜λŠ”λ°μš”.

 

32λΉ„νŠΈ ν™˜κ²½ μžλ°”μ—μ„œ 1010(2)인 경우 00000000 00000000 00000000 00001010으둜 ν‘œν˜„ν•©λ‹ˆλ‹€.

이에 not 연산을 μ μš©ν•˜λ©΄ 11111111 11111111 11111111 11110101 이 되고 맨 μƒμœ„ bit인 MSBκ°€ 1인 것을 ν™•μΈν•©λ‹ˆλ‹€.

μžλ°”λŠ” ν•΄λ‹Ή μˆ«μžκ°€ 음수라고 μΈμ‹ν•˜κ³  2의 보수λ₯Ό μ·¨ν•˜κ²Œ λ©λ‹ˆλ‹€.

11111111 11111111 11111111 11110101 μ—μ„œ λΆ€ν˜Έκ°€ minus라고 인식 ν›„ 1의 보수,

00000000 00000000 00000000 00001010 μ—μ„œ 2의 보수,

00000000 00000000 00000000 00001011 μ΄λΌλŠ” κ²°κ³Ό 생성

ν•΄λ‹Ή 값은 11μ΄λΌλŠ” 값을 κ°€μ§€κ³  λΆ€ν˜ΈλŠ” minusμ΄λ―€λ‘œ -11(2)λΌλŠ” κ²°κ³Όλ₯Ό λ„μΆœν•˜κ²Œ λ©λ‹ˆλ‹€.

 

κ·Έ μ™Έ λ‹€λ₯Έ 값듀도 ν•œ 번 직접 μ—°μ‚°ν•΄λ³΄μ‹œλŠ” 것을 μΆ”μ²œν•©λ‹ˆλ‹€.

 

λŒ€μž… μ—°μ‚°μž
public class Main
{
	public static void main(String[] args) {
	    int a = 10;
	    a <<= 1;        // a = a << 1
	    System.out.printf("shift λŒ€μž… μ—°μ‚° : %d\n", a);
	    a *= 2;         // a = a * 2
	    System.out.printf("사칙 λŒ€μž… μ—°μ‚° : %d\n", a);
	    a &= 10;        // a = a & 10
	    System.out.printf("λΉ„νŠΈ λŒ€μž… μ—°μ‚° : %d\n", a);
	}
}

λŒ€μž… μ—°μ‚°μ˜ 경우, μœ„μ—μ„œ 닀룬 사칙연산, shiftμ—°μ‚°, λΉ„νŠΈ μ—°μ‚°μ—λ§Œ 적용이 λ˜λŠ” μ—°μ‚°μž…λ‹ˆλ‹€.

λ³€μˆ˜ μž…μž₯μ—μ„œ 자기 μžμ‹ μ—κ²Œ νŠΉμ • 값을 μ—°μ‚°ν•œλ‹€λ©΄ λŒ€μž… μ—°μ‚°μžλ₯Ό μ‚¬μš©ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

μ£Όμ„μ—μ„œ 풀어놓은 λ¬Έμž₯κ³Ό 같은 의미λ₯Ό κ°€μ§‘λ‹ˆλ‹€.

 

증감 μ—°μ‚°μž
public class Main
{
	public static void main(String[] args) {
	    int a = 0;
	    System.out.printf("a = %d\n", a++);
	    System.out.printf("a = %d\n", a);
	    System.out.printf("a = %d\n", ++a);
	    System.out.printf("a = %d\n", a--);
	    System.out.printf("a = %d\n", a);
	    System.out.printf("a = %d\n", ++a);
	}
}

증감 연산은 값을 1을 μ¦κ°€ν•˜κ±°λ‚˜ 1을 κ°μ†Œν•˜λŠ” 연산을 μ˜λ―Έν•©λ‹ˆλ‹€.

증감 μ—°μ‚°μ—λŠ” μ „μΉ˜ μ—°μ‚°κ³Ό ν›„μΉ˜ 연산이 μžˆμŠ΅λ‹ˆλ‹€.

μ „μΉ˜ μ—°μ‚°μ΄λž€ λ³€μˆ˜μ˜ 데이터에 연산을 μˆ˜ν–‰ν•œ ν›„ 데이터λ₯Ό μ „λ‹¬ν•˜λŠ” κ²ƒμž…λ‹ˆλ‹€.

ν›„μΉ˜ μ—°μ‚°μ΄λž€ 데이터λ₯Ό μ „λ‹¬ν•˜κ³  데이터에 연산을 μˆ˜ν–‰ν•˜λŠ” κ²ƒμž…λ‹ˆλ‹€.

int a = 0;

// μ „μΉ˜ μ—°μ‚°
a = a + 1;
System.out.printf("a = %d\n", a);

// ν›„μΉ˜ μ—°μ‚°
System.out.printf("a = %d\n", a);
a = a + 1

 

비ꡐ(관계) μ—°μ‚°μž
public class Main
{
	public static void main(String[] args) {
	    System.out.printf("1 > 2 : %b\n", (1 > 2));
	    System.out.printf("1 >= 2 : %b\n", (1 >= 2));
	    System.out.printf("1 < 2 : %b\n", (1 < 2));
	    System.out.printf("1 <= 2 = %b\n", (1 <= 2));
	    System.out.printf("1 == 2 = %b\n", (1 == 2));
	    System.out.printf("2 >= 2 = %b\n", (2 >= 2));
	    System.out.printf("2 <= 2 = %b\n", (2 <= 2));
	    System.out.printf("2 == 2 = %b\n", (2 == 2));
	}
}

이것 λ˜ν•œ μš°λ¦¬κ°€ μ•Œκ³  μžˆλŠ” κ·ΈλŒ€λ‘œ μž…λ‹ˆλ‹€.

λŒ€μ‹  비ꡐ μ—°μ‚°μžκ°€ λ‚˜νƒ€λ‚΄λŠ” 값은 true or false둜, 1 λ˜λŠ” 0만 ν‘œν˜„ν•©λ‹ˆλ‹€.

 

논리 μ—°μ‚°
public class Main
{
	public static void main(String[] args) {
	    System.out.printf("false and false : %b\n", false && false);
	    System.out.printf("false or false : %b\n", false || false);
	    System.out.printf("true and false : %b\n", true && false);
	    System.out.printf("true or false : %b\n", true || false);
	    System.out.printf("false and true : %b\n", false && true);
	    System.out.printf("false or true : %b\n", false || true);
	    System.out.printf("true and true : %b\n", true && true);
	    System.out.printf("true or true : %b\n", true || true);
	    System.out.printf("not true : %b\n", !true);
	    System.out.printf("not false : %b\n", !false);
	}
}

 

기호 λ•Œλ¬Έμ— λΉ„νŠΈ μ—°μ‚°μžμ™€ ν—·κ°ˆλ¦¬λŠ” μ‚¬λžŒμ΄ λ‹€μˆ˜ μžˆλŠ” λ¬Έμ œμž…λ‹ˆλ‹€.

λΉ„νŠΈ μ—°μ‚°μžλŠ” 10μ§„μˆ˜λ₯Ό 2μ§„μˆ˜ 연산을 ν•˜κΈ° λ•Œλ¬Έμ— 숫자둜 연산이 κ°€λŠ₯ν•©λ‹ˆλ‹€.

ν•˜μ§€λ§Œ μžλ°”μ—μ„œ 논리 연산은 boolean(true λ˜λŠ” false)으둜만 연산을 ν•  수 μžˆμŠ΅λ‹ˆλ‹€.

주둜 쑰건이 λ§Œμ‘±ν•˜λŠ” μ§€ ν™•μΈν•˜κΈ° μœ„ν•΄μ„œ μ‚¬μš©ν•©λ‹ˆλ‹€.

 

μ‚Όν•­ μ—°μ‚°μž
public class Main
{
	public static void main(String[] args) {
	    int a = 10, b = 20;
	    System.out.printf("bigger : %d\n", a > b ? a : b);
	    System.out.printf("%s\n", 10 < 2 ? "Yes" : "No");
	}
}

μ΅œλŒ€ 값을 찾을 λ•Œ μ‚¬μš©ν•˜κ±°λ‚˜ μ½”λ“œλ₯Ό κ°„κ²°ν•˜κ²Œ ν•˜κ³  싢을 λ•Œ, μ‚¬μš©ν•˜λŠ” μ—°μ‚°μžμž…λ‹ˆλ‹€.

ν•˜μ§€λ§Œ, μ‹€λ¬΄μ—μ„œλŠ” 잘 μ‚¬μš©λ˜μ§€ μ•ŠλŠ” κ²ƒμœΌλ‘œ μ•Œκ³  μžˆμŠ΅λ‹ˆλ‹€.

μš°μ•„ν•œ ν˜•μ œλ“€ μžλ°” μ»¨λ²€μ…˜μ—λ„ λΉ„μΆ”ν•˜κ³  μžˆμŠ΅λ‹ˆλ‹€.

 

μˆ˜ν–‰κ³Όμ •μ€ μ•„λž˜μ™€ κ°™μŠ΅λ‹ˆλ‹€.

1. '?' λ₯Ό κΈ°μ€€μœΌλ‘œ μ™Όμͺ½μ˜ 연산을 λ¨Όμ € μˆ˜ν–‰ν•©λ‹ˆλ‹€.

2. κ²°κ³Ό 값이 true라면 ' : ' 을 κΈ°μ€€μœΌλ‘œ μ™Όμͺ½ 값을 전달

3. κ²°κ³Ό 값이 false라면 ' : ' 을 κΈ°μ€€μœΌλ‘œ 였λ₯Έμͺ½ 값을 μ „λ‹¬ν•©λ‹ˆλ‹€.

μ‰½κ²Œ μƒκ°ν•˜λ©΄ 이 쑰건이 λ§žμ•„ ? 응 : μ•„λ‹ˆ 둜 μƒκ°ν•˜μ‹œλ©΄ λ©λ‹ˆλ‹€.

 

μ‚¬μš©μ„ ν•œλ‹€λ©΄ 쑰건뢀인 ' ? ' μ™Όμͺ½μ€ κ΄„ν˜Έλ‘œ λ¬Άμ–΄ μ£Όμ‹œλŠ”κ²Œ μ’‹μŠ΅λ‹ˆλ‹€.

( a > b ) ? a : b


μ—°μ‚°μžμ˜ μš°μ„ μˆœμœ„??

 

μˆ˜ν•™μ—μ„œ 사칙 연산을 ν•  λ•Œ, κ³±ν•˜κΈ°μ™€ λ‚˜λˆ„κΈ°κ°€ λ§μ…ˆ λΊ„μ…ˆλ³΄λ‹€ λ¨Όμ € μ—°μ‚°ν•˜λ“―μ΄ μš°μ„ μˆœμœ„κ°€ μžˆλ‹€.

1. κ΄„ν˜Έ : ' () '

2. 단항 μ—°μ‚°μž : ' +, - , ++, --, !, ~'

- λ³€μˆ˜λ˜λŠ” μƒμˆ˜ μžμ²΄μ— λΆ™μ–΄μ„œ ν•˜λ‚˜μ˜ 숫자둜 ν‘œν˜„ν•˜λŠ” ν˜•νƒœμ΄λ‹€.

- (+1), (-1), (i++), (!true), ...

3. μ‚°μˆ  μ—°μ‚°μž : ' +, -, /, *, % '

- 기본적인 사칙연산과 mod연산을 ν¬ν•¨ν•œλ‹€.

4. μ‹œν”„νŠΈ μ—°μ‚°μž : ' <<, >> '

5. 비ꡐ μ—°μ‚°μž : ' <, >, <=, >= '

6. 비ꡐ(λ“±ν˜Έ, 동등) μ—°μ‚°μž : ' ==, != '

- a > b == b < a 인 경우, 문제 μ—†λ‹€.

- a == b > (a < b) 인 경우, λ¬Έμ œκ°€ λ°œμƒν•œλ‹€. ( a == b ) > ( a < b )둜 ν‘œν˜„ν•΄μ•Όν•œλ‹€.

7. λΉ„νŠΈ AND, XOR, OR μ—°μ‚°μž : ' &, ^, | '

- AND, XOR, OR μˆœμ„œλŒ€λ‘œ μ—°μ‚°μž μš°μ„ μˆœμœ„κ°€ μ‘΄μž¬ν•œλ‹€.

- κ·Έ μ΄μœ λŠ” λͺ…ν™•ν•˜μ§€ μ•Šλ‹€. μžλ°” μ„€κ³„μžλ“€μ΄ κ·Έλ ‡κ²Œ 섀계 ν–ˆλ‹€.

- μΆ”μΈ‘ν•˜λŠ” μ΄μœ λŠ” λͺ‡ κ°€μ§€ μžˆμœΌλ‚˜ λͺ¨λ₯΄κ³˜λ‹€.

8. 논리 AND, OR μ—°μ‚°μž : ' &&, || ' 

- 이 λ˜ν•œ μˆœμ„œλŒ€λ‘œ μš°μ„ μˆœμœ„κ°€ μžˆλ‹€.

9. μ‚Όν•­ μ—°μ‚°μž : ' (쑰건) ? (true) : (false) '

10. λŒ€μž… μ—°μ‚°μž : " =, +=, -= , ... '

- λͺ¨λ“  연산을 마친 후에 λŒ€μž…ν•˜κΈ° λ•Œλ¬Έμ— λ‹Ήμ—°ν•˜λ‹€.

 

되게 λ§Žμ€ μˆœμ„œκ°€ μžˆμ§€λ§Œ 생각보닀 μ™Έμš°κΈ° μ‹Άλ‹€.

κ°€μž₯ μ€‘μš”ν•œ 뢀뢄은 비ꡐ μ—°μ‚°κ³Ό 논리 μ—°μ‚°μ˜ μš°μ„ μˆœμœ„μ΄λ‹€.

직접 μ‹€ν–‰ν•˜λ©΄μ„œ ν…ŒμŠ€νŠΈ ν•΄λ³΄λŠ” 것을 μΆ”μ²œ

 

λ…Έμ…˜ 정리 URL

 

https://www.notion.so/24jihwan/b002389aea204cd2a1a15bd8ff2f358e

 

μ—°μ‚°μž | Notion

μ‚°μˆ , λŒ€μž…, μ—°μ‚°μž

24jihwan.notion.site