ν‹°μŠ€ν† λ¦¬ λ·°

(ꡬ)Java

03 Java μ—°μ‚°μž(Operator)

yeahajeong 2019. 4. 29. 14:41
λ°˜μ‘ν˜•

μ—°μ‚°μž (Operator)


- μ—°μ‚°μžλŠ” λ³€μˆ˜μ˜ κ°’을 λ³€κ²½ν•˜κ±°λ‚˜ λŒ€μž…ν•˜λŠ”λ° μ‚¬μš©λœλ‹€.

- μžλ°”μ—μ„œλŠ” μ—°μ‚°μžμ— λ”°λΌ μ—°μ‚° λŒ€μƒμ΄ λ  μˆ˜ μžˆλŠ” λ°μ΄ν„° νƒ€μž…이 μ •ν•΄μ Έ μžˆλ‹€.

- μ˜€λ²„ν”Œλ‘œ(overflow) λ˜λŠ” μ–Έλ”ν”Œλ‘œ(underflow) λ“± λ²”μœ„λ₯Ό λ²—μ–΄λ‚˜λŠ” μ—°μ‚°λ“€μ— λŒ€ν•΄μ„œλŠ” μ—°μ‚° κ²°κ³Όμ— λΆˆν•„μš”ν•œ κ°’이 μ €μž₯λœλ‹€.

- 0으둜 λ‚˜λˆŒ κ²½μš°λŠ” μ˜€λ₯˜κ°€ λ°œμƒν•©λ‹ˆλ‹€.

 


* λ‹¨ν•­ μ—°μ‚°μž(Unary Operator) 

- λ‹¨ν•­ μ—°μ‚°μžλŠ” ν”Ό μ—°μ‚°μžκ°€ ν•˜λ‚˜μΈ μ—°μ‚°μžλ₯Ό λ§ν•œλ‹€.

- 단항 μ—°μ‚°μžμ˜ μ’…λ₯˜
1. λ³€μˆ˜μ˜ μ•žμ΄λ‚˜ λ’€μ— λΆ™μ–΄μ„œ λ³€μˆ˜ κ°’을 ν•˜λ‚˜ μ¦κ°€μ‹œν‚€κ±°λ‚˜, κ°μ†Œμ‹œν‚€λŠ” μ¦/감 μ—°μ‚°μž(++, --)
2. μ–‘μˆ˜μ™€ μŒμˆ˜λ₯Ό λ‚˜νƒ€λ‚΄λŠ” λΆ€ν˜Έ μ—°μ‚°μž(+, -)
3. λΉ„νŠΈμ˜ κ°’을 λ°”κΏ”μ£ΌλŠ” λΉ„νŠΈ λ°˜μ „ μ—°μ‚°μž(~)
4. λ…Όλ¦¬λŒ€μˆ˜μ˜ κ°’을 λ°˜μ „μ‹œμΌœμ£ΌλŠ” λ…Όλ¦¬ λ°˜μ „ μ—°μ‚°μž(!)
5. λ°μ΄ν„° νƒ€μž…을 λ°”κΏ”μ£ΌλŠ” μΊμŠ€νŠΈμ—°μ‚°μž ( (type) )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class UnaryEx {
 
    public static void main(String[] args) {
        
        //λΆ€ν˜Έμ—°μ‚°μž
        int num1 = -5;
        int result = -num1;
        System.out.println(result);
        System.out.println("-----------------");
        
        
        //μ¦κ°μ—°μ‚°μž ++, --
        int i = 1;
        int j = i++//ν›„μœ„ μ—°μ‚°
        System.out.println("i의 κ°’은 : " + i);
        System.out.println("j의 κ°’은 : " + j);
        System.out.println("-----------------");
        
        int x = 1;
        int y = ++x; //μ „μœ„ μ—°μ‚°
        System.out.println("x의 κ°’은 : " + x);
        System.out.println("y의 κ°’은 : " + y);
        System.out.println("-----------------");
        
        
        //λΉ„νŠΈ λ°˜μ „ μ—°μ‚°μž ~
        //μ •μˆ˜μ˜ κ°’을 2μ§„μˆ˜λ‘œ ν‘œν˜„ν•˜μ—¬ κ° μžλ¦¬μˆ˜λ₯Ό λ°˜μ „
        byte b = 8//8 -> 0000 1000
        System.out.println(~b); //-9 -> 1111 0111
        
        
        //논리 λ°˜μ „ μ—°μ‚°μž !
        boolean bool = true;
        System.out.println(!bool);
    }
}
 
 

 


* 2ν•­ μ—°μ‚°μž(Binary Operator)
- 2ν•­ μ—°μ‚°μžλŠ” ν”Ό μ—°μ‚°μž(Operand)κ°€ λ‘ κ°œμΈ μ—°μ‚°μžλ₯Ό μ˜λ―Έν•©λ‹ˆλ‹€.
- μ—°μ‚°μžκ°€ intν˜•(4byte)보닀 μž‘은 ν¬κΈ°μ˜ λ°μ΄ν„° νƒ€μž…인 κ²½μš°μ— booleanν˜•μ„ μ œμ™Έν•˜κ³  λͺ¨λ‘ intν˜•μœΌλ‘œ μžλ™ ν˜• λ³€ν™˜λ˜μ–΄ μ—°μ‚°μ„ μˆ˜ν–‰ν•©λ‹ˆλ‹€.

- 2ν•­ μ—°μ‚°μžμ˜ μ’…λ₯˜
1. μ‚°μˆ  μ—°μ‚°μž ( +, -, *, /, % )
- λ‚˜λ¨Έμ§€ μ—°μ‚°μ€ κ²°κ³Όκ°€ ν•­μƒ μ •μˆ˜

2. λΉ„ꡐ μ—°μ‚°μž ( <, <=, >, >=, ==, != )
- λΉ„ꡐ μ—°μ‚°μžμ˜ κ²°κ³Ό κ°’은 ν¬κΈ° κ°’을 λΉ„κ΅ν•˜μ—¬ μ‘°κ±΄μ„ λ§Œμ‘±ν•˜λ©΄ true κ·Έλ ‡μ§€ μ•ŠμœΌλ©΄ falseλ₯Ό λ°˜ν™˜
- λ§Œμ•½ λΉ„κ΅λ˜λŠ” μˆ«μžμ˜ λ°μ΄ν„° νƒ€μž…이 λ‹€λ₯Ό κ²½μš° κΈ°λ³Έμ μœΌλ‘œ ν¬κΈ°κ°€ ν° λ°μ΄ν„° νƒ€μž…에 λ§žμΆ”μ–΄ λΉ„ꡐ μ—°μ‚°μ„ μ‹€ν–‰

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class BinaryEx {
 
    public static void main(String[] args) {
        
        //μˆ˜μΉ˜μ—°μ‚°
        int i = 7/3//2
        int j = 7%3//1
 
        //비ꡐ연산
        System.out.println(i == j);
        System.out.println(20 >= 20);
        System.out.println(130 < 50);
    }
}
 
 

3. λΉ„νŠΈ μ—°μ‚°μž ( &, |, ^ )
- λΉ„νŠΈ μ—°μ‚°μžλŠ” λ‘ μˆ˜λ₯Ό κ°κ° 2μ§„μˆ˜λ‘œ λ³€ν™˜ν•˜μ—¬ λ‘ μˆ˜μ˜ κ° λΉ„νŠΈ μ—°μ‚°μ„ μˆ˜ν–‰ν•©λ‹ˆλ‹€.
a. & (λΉ„νŠΈκ³±): λ‘ λΉ„νŠΈκ°€ 1일 λ•Œ 1, λ‚˜λ¨Έμ§€λŠ” 0.
b. | (λΉ„νŠΈν•©): λ‘ λΉ„νŠΈ μ€‘ ν•˜λ‚˜ μ΄μƒμ΄ 1이면 1, λ‘ λΉ„νŠΈ λͺ¨λ‘ 0이면 0.
c. ^ (xor λ°°νƒ€μ  λ…Όλ¦¬ν•©): λ‘ λΉ„νŠΈκ°€ λ‹€λ₯΄λ©΄ 1, κ°™μœΌλ©΄ 0.

4. λΉ„νŠΈ μ΄λ™ μ—°μ‚°μž ( <<, >> )
- μ™Όμͺ½ ν•­μ˜ κ°’을 2μ§„μˆ˜λ‘œ λ³€ν™˜ν•˜μ—¬ μ˜€λ₯Έμͺ½ ν•­μ˜ κ°’λ§ŒνΌ λΉ„νŠΈλ₯Ό μ™Όμͺ½(<<), μ˜€λ₯Έμͺ½(>>)으둜 μ΄λ™μ‹œν‚€λŠ” μ—°μ‚°μ„ μˆ˜ν–‰ν•œλ‹€.
ex) 

int a = 192;
00000000 00000000 00000000 11000000
    a << 3
00000000 00000000 00000110 00000000 //1536

 

5. λ…Όλ¦¬ μ—°μ‚°μž ( &, |, &&, || )
a. & : μ—°μ‚°μ„ μˆ˜ν–‰ν•˜μ—¬ μ–‘μͺ½ ν•­μ΄ λͺ¨λ‘ true일 λ•Œλ§Œ trueλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
b. | : μ—°μ‚°μ„ μˆ˜ν–‰ν•˜μ—¬ μ–‘μͺ½ ν•­ μ€‘ ν•œμͺ½λ§Œ trueλ₯Ό λ§Œμ‘±ν•΄λ„ trueλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
c. && : λ§ŒμΌ μ™Όμͺ½ ν•­μ΄ false일 κ²½μš°μ—λŠ” μ˜€λ₯Έμͺ½ ν•­μ„ μˆ˜ν–‰ν•˜μ§€ μ•Šκ³  λ¬΄μ‘°κ±΄ falseλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
d. || : λ§ŒμΌ μ™Όμͺ½ ν•­μ΄ true일 κ²½μš°μ—λŠ” μ˜€λ₯Έμͺ½ ν•­μ„ μˆ˜ν–‰ν•˜μ§€ μ•Šκ³  λ¬΄μ‘°κ±΄ trueλ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.
- &&, ||을 short circuit operator라고 λΆ€λ¦…λ‹ˆλ‹€.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
public class LogicOper {
    
    public static void main(String[] args) {
        
        int x = 10, y = 20;
        
        if( (x != 10& (++== 21) ) {
            System.out.println("κ²°κ³Όκ°€ μ°Έ");
        } else {
            System.out.println("κ²°κ³Όκ°€ κ±°μ§“");
        }
        System.out.println("x : " + x + ", y : " + y);
        
        if( (x == 10| (++== 21) ) {
            System.out.println("κ²°κ³Όκ°€ μ°Έ");
        } else {
            System.out.println("κ²°κ³Όκ°€ κ±°μ§“");
        }
        System.out.println("x : " + x + ", y : " + y);
        
        
        System.out.println("----------------");
        
        int a = 10;
        int b = 20;
        
        if(a!=10 && ++b==21) { //μ•žμ—κ°€ falseλΌμ„œ λ¬΄μ‘°κ±΄ κ±°μ§“ κ·Έλž˜μ„œ λ’€μ— μ—°μ‚°μ΄ μ‹€ν–‰λ˜μ§€μ•Šμ•˜κΈ° λ•Œλ¬Έμ— b의 κ°’이 20
            System.out.println("κ²°κ³Όκ°€ μ°Έ");
        } else {
            System.out.println("κ²°κ³Όκ°€ κ±°μ§“");
        }
        System.out.println("a : " + a + ", b : " + b);
        
        
        if(a==10 || ++b==21) { //μ•žμ—κ°€ trueλΌμ„œ λ¬΄μ‘°κ±΄ μ°Έ κ·Έλž˜μ„œ λ’€μ— μ—°μ‚°μ΄ μ‹€ν–‰λ˜μ§€ μ•Šμ•˜κΈ° λ•Œλ¬Έμ— b의 κ°’ 20
            System.out.println("κ²°κ³Όκ°€ μ°Έ");
        } else {
            System.out.println("κ²°κ³Όκ°€ κ±°μ§“");
        }
        System.out.println("a : " + a + ", b : " + b);
    
    }
}
 
 
 

* λŒ€μž… μ—°μ‚°μž(Assignment Operator)
- λŒ€μž… μ—°μ‚°μžμ˜ κΈ°λ³Έν˜•μ€ '=' μ΄κ³ , μΆ”κ°€λ‘œ λ°œμ „λœ ν˜•νƒœμ˜ λŒ€μž… μ—°μ‚°μžλ“€μ΄ μžˆλ‹€.
- +=, -=, *=, /=, %=  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public class AssignmentEx {
 
    public static void main(String[] args) {
        
        int a = 5, b = 5;
        a += 3//a = a + 3
        b =+ 3//b = +3
        System.out.println(a);
        System.out.println(b);
 
        a -= 4;
        a *= 6
        a /= 5
        a %= 3
        System.out.println(a);
 
    }
}
 
 

 


* 3ν•­ μ—°μ‚°μž 

- ν”Ό μ—°μ‚°μž 3개인 μ—°μ‚°μžλ₯Ό λ§ν•©λ‹ˆλ‹€. 

- ( μ‘°κ±΄μ‹ ? μ—°μ‚°μ‹1 : μ—°μ‚°μ‹2 ) 

: μ‘°κ±΄μ‹μ˜ κ²°κ³Όκ°’이 μ°Έμ΄λ©΄ μ—°μ‚°μ‹1, κ±°μ§“이면 μ—°μ‚°μ‹2λ₯Ό μ‹€ν–‰ν•˜λΌ. 

- μ‘°κ±΄μ‹μ—λŠ” booleanν˜• μ‘°κ±΄μ‹μ΄ λ“€μ–΄κ°‘λ‹ˆλ‹€. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
public class ConditionalEx {
    
    public static void main(String[] args) {
        
        /*
         * λ‚œμˆ˜(λžœλ€κ°’)을 λ°œμƒμ‹œν‚€λŠ” λ©”μ„œλ“œ random()
         * 0.0 μ΄μƒ 1.0미만의 λžœλ€ μ‹€μˆ˜κ°’을 κ°€μ Έμ˜΄
         */
        System.out.printlnMath.random() );
        
        
        
        double ran = Math.random() * 10;
        int r = (int)ran; //r의 λ²”μœ„ : 0이상 10미만
        
        System.out.println(ran);
        System.out.println(r);
        System.out.println("--------------");
        
        int result = (int)(Math.random() * 10+ 1;
        System.out.println(result);
        
        
        //μ‚Όν•­ μ—°μ‚°μž
        //쑰건식과 λ°˜ν™˜κ°’μ˜ ν˜•νƒœκ°€ κ°™μ•„μ•Όν•œλ‹€
        String str1 = result % 2 == 0 ? "μ°Έ" : "거짓";
        System.out.println(str1);
        
        //-4~5κΉŒμ§€ λžœλ€κ°’
        int i = 5 - (int)(Math.random() * 10);
        System.out.println(i);
        
        
        
        
        //3ν•­ μ—°μ‚°μ‹μ„ μ΄μš©ν•΄μ„œ i의 μ ˆλŒ€κ°’을 κ΅¬ν•΄ μΆœλ ₯
        int o = i>0 ? i : -i;
        System.out.println(i + "의 μ ˆλŒ€κ°’은 " + o + "μž…λ‹ˆλ‹€.");
        
        //3ν•­ μ—°μ‚°μ‹μ„ μ΄μš©ν•΄μ„œ 3의 λ°°μˆ˜λΌλ©΄ 3의 λ°°μˆ˜μž…λ‹ˆλ‹€. μΆœλ ₯
        int t = (int)(Math.random() * 101);
        String str2 = t%3 == 0 ? "3의 λ°°μˆ˜μž…λ‹ˆλ‹€." : "3의 λ°°μˆ˜κ°€ μ•„λ‹™λ‹ˆλ‹€.";
        System.out.println(t + "λŠ” " + str2);
    }
}
 
 

β˜…β˜…β˜…β˜…β˜…β˜…β˜…β˜…κ³„μ‚°μˆœμ„œβ˜…β˜…β˜…β˜…β˜…β˜…β˜…β˜…
- μ†Œκ΄„ν˜Έ > λ‹¨ν•­ > μ΄ν•­ > μ‚Όν•­ >λŒ€μž…

λ°˜μ‘ν˜•

'(ꡬ)Java' μΉ΄ν…Œκ³ λ¦¬μ˜ λ‹€λ₯Έ κΈ€

04 Java ν‘œμ€€ μž…μΆœλ ₯(IO : Input/Output)  (0) 2019.04.29
04 Java λ°°μ—΄  (0) 2019.04.29
03 Java ν˜• λ³€ν™˜( type casting)  (1) 2019.04.29
02 Java 데이터 νƒ€μž…  (0) 2019.04.29
02 Java λ³€μˆ˜  (0) 2019.04.29
λŒ“κΈ€