[Java] 자료형과 연산자

1. Data Type

 

• 기본형(Primitive type)
  : 미리 정해진 크기의 데이터 표현
  : 변수 자체에 값 저장
  : 8개
• 참조형(reference type)
  : 크기가 미리 정해질 수 없는 데이터의 표현
  : 변수에는 실제 값을 참조할 수 있는 주소만 저장
  (실제 메모리 주소X, Java 내부에서 사용하는 주소값)

 

• Primitive Type
  • Boolean Type (boolean)
  • Charactor Type(char)
  • Numeric Type
    • Integer Type (byte, short, int, long)
    • Floating Point Type (float, double)
• Reference Type
  • Class Type
  • Interface Type
  • Array Type
  • Enum Type
  • etc

 

---

가. boolean

semi boolean 미지원

boolean flag = 1; //오류

 

---

나. char

• 아래 아스키코드 값은 암기하도록 하자.
  • 숫자 0 = 48
  • 소문자 a = 65
  • 대문자 A = 97

 

---

다. byte

 

2의 보수 설명할 수 있어야 함. (1byte가 -128 ~ 127인 이유)

byte bb1 = 10;
byte bb2 = 20;
byte bb3 = b1 - b2; // 컴파일 오류

java의 연산의 최소 단위는 기본 int다.

 

그래서 short, byte는 계산이 안된다.

 

byte bb3 = (byte)(bb1 - bb2); // 컴파일 성공

 

---

라. int

int num;
num = 100; // 10진수
num = 0x100; // 16진수
num = 010; // 8진수
num = 0b100; // 이진수

 

---

마. 오버플로우

package public class Lang_01 {
    public static void main(String[] args) {
        int i1 = Integer.MAX_VALUE;
        int i2 = i1 + 1;
        System.out.println(i2);

        long l1 = i1 + 1;
        System.out.println(l1);

        long l2 = (long) (i1 + 1);
        System.out.println(l2);

        long l3 = (long) i1 + 1;
        System.out.println(l3);

        int i3 = 1000000 * 1000000 / 100000;
        int i4 = 1000000 / 100000 * 100000;
        System.out.println(i3 + " : " + i4);
    }
}
/*
-2147483648
-2147483648
-2147483648
2147483648
-7273 : 1000000
*/

• i2 : 오류는 발생하지 않지만 오버플로우가 발생한다.
• 01111111 11111111 11111111 11111111 → 10000000 00000000 00000000 00000000
• l1는 i1 + 1에서 int의 오버플로우 발생
• l2는 (i1 + 1)에서 오버플로우 발생.
• i3는 1000000 * 1000000에서 int의 오버플러우 발생
• Integer : int의 wrapper class

 

---

바. 실수 계산

import java.math.BigDecimal;

public class Lang_02 {
    public static void main(String[] args) {
        float f1 = 2.0f;
        float f2 = 1.1f;
        float f3 = f1 - f2;
        System.out.println(f3);

        double d1 = 2.0;
        double d2 = 1.1;
        double d3 = d1 - d2;
        System.out.println(d3);

        System.out.println(((int) (d1 * 100) - (int) (d2 * 100)) / 100.0);

        BigDecimal b1 = new BigDecimal("2.0");
        BigDecimal b2 = new BigDecimal("1.1");
        System.out.println("BigDecimal을 이용한 빼기 : " + b1.subtract(b2));
    }
}
/*
0.9
0.8999999999999999
0.9
BigDecimal을 이용한 빼기 : 0.9
*/

실수의 연산은 정확하지 않다. (유효 자릿수를 이용한 반올림 처리)

 

실수에서 정확한 연산을 하기 위해서는 ((int) (d1 * 100) - (int) (d2 * 100)) / 100.0 처럼 계산하거나 Bigdecimal로 계산해야한다.

 

---

사. 형변환

 

primitive는 primitive끼리, reference는 reference끼리 형 변환 가능.

(boolean은 다른 기본 형과 호환되지 않음.)

 

기본형과 참조형의 형 변환을 위해서 Wrapper 클래스 사용.

 

1) 명시적 형변환

int i = 300;
byte b = (byte)i;

 

2) 묵시적 형변환

byte b = 10;
int i = b;

일부 묵시적인 형변환은 값 손실이 발생하지 않음.

 

3) 형변환 주의점

double d = 100.5;
int result = (int)d;
//d = 100.5
// result = 100

byte → short → int → long → float → double

char → int → long → float → double

 

값 손실이 발생하는 경우 명시적인 형변환이 필요하다.

 

표현방식의 차이 때문에 long(64bit) → float(32bit) 가능하다.

 

부동소수점 - 위키백과, 우리 모두의 백과사전

 

---

아. 연산과 형 변환

public class Lang_04 {

    public static void main(String[] args) {
        byte b1 = 10;
        byte b2 = 20;
        byte b3 = b1 + b2;

        int i1 = 10;
        long l1 = 20;
        int i2 = i1 + l1;

        float f1 = 10.0;
        float f2 = f1 + 20.0;
    }
}

• byte b3 = b1 + b2; : java의 최소 연산단위는 int다.
• int i2 = i1 + l1; : i1+l1는 long이라서 int인 i2로 명시적 형변환이 필요한다..
• float f2 = f1 + 20.0; : 20.0는 double이다. (20.0f이 float이다.)

 

자바는 두 개의 피연산자 중 큰 타입으로 형 변환 후 연산 진행.

 

피연산자의 크기가 4byte 미만이면 int로 변경한 후 연산을 진행한다.

 

int보다 작은 타입으로 표현할 수 있는 값이라도 연산을 하려면 int로 선언하자.

 

---

2. 연산자

 

가. 연산자 우선순위

public class Lang_03 {
    public static void main(String[] args) {
        int x = 8 >> 9 % 2 / 3 * 2 == 2 ? 0 : 1;
                System.out.println("x = " + x);
                System.out.println(8 >> 1 / 6);
    }
}
/*
x = 8
8
*/

• int y = 8 >> 9 % 2 / 3 * 2 == 2 ? 0 : 1;
  : % → / → * → >> → == → 삼항연산자
  : 9 % 2는 1, 1 / 3은 0이다.
  : 0 * 2는 0이 되고, 8 >> 0은 8을 반환.
• System.out.println(8 >> 1 / 6);
  : 1 / 6이 먼저 계산된다.
  : 8 >> 0은 8이다.

 

1. 괄호 ( )
2. 단항 연산자 (++, --, +, -, !)
3. 산술 연산자 (*, /, %)
4. 산술 연산자 (+, -)
5. 시프트 연산자 (<<, >>, >>>)
6. 관계 연산자 (<, >, <=, >=, instanceof)
7. 등호 연산자 (==, !=)
8. 비트 AND 연산자 (&)
9. 비트 XOR 연산자 (^)
10. 비트 OR 연산자 (|)
11. 논리 AND 연산자 (&&)
12. 논리 OR 연산자 (||)
13. 삼항 연산자 (?:)
14. 대입 연산자 (=, +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, ^=, |=)

 

---

나. short circuit

public class Lang_05 {
    public static void main(String[] args) {

        int a = 10;
        int b = 20;
        System.out.println((a > b) & (b > 0));

        System.out.println((a += 10) > 15 | (b -= 10) > 15);
        System.out.println("a = " + a + ", b = " + b);

        a = 10;
        b = 20;
        System.out.println((a += 10) > 15 || (b -= 10) > 15);
        System.out.println("a = " + a + ", b = " + b);
    }
}
/*
false
true
a = 20, b = 10
true
a = 20, b = 20
*/

• & : 비트연산자. short circuit 미지원.
• && : 논리연산자. short circuit 지원.
• | : 논리연산자. 비트연산자. short circuit 미지원.
• || : short circuit 지원.

 

별일 없으면 &&, ||를 사용하자. 단, short circuit에 주의할 것.

 

---

다. 비트연산자

1) ~ 연산자

int num2 = 10; // 00001010
num2 = ~num2; // 11110101 -> -11

System.out.println(num2);

 

---

2) << 연산자

int aa = 5; // 00000000 00000101
int ab = aa << 2; // 00000000 00010100
System.out.println(ab + " , " + aa); // 20 , 5

왼쪽 한번 이동할 때마다 2를 곱하는 것과 같다.

 

---

3) >>과 >>> 차이

 

오른쪽에 비어진 비트에 …

• 기존의 부호를 지킨다 → >>
• 무시하고 무조건 0이다. → >>>

 

>> 산술 시프트, >>> 논리 시프트.

 

---

4) 같은 표현 다른 연산 속도

ab = aa << 10; // 컴퓨터는 비트를 10번 산술 시프트한다.
ab = aa * 1024; // 컴퓨터는 aa를 1024번 더한다.
ab = 1024 * aa; // 컴퓨터는 1024를 aa번 더한다.

 

---

라. 삼항 연산자

(condition) ? (true) : (false)

연산자이기 때문에 실제 조건문보다 더 빠르게 동작한다.

 

---