네이버 클라우드 캠프 23일차 230525

#1 교육정리

1) gitignore 설정하기

2) 리터럴 데이터 표기

3) 정수 리터럴

4) 정수 리터럴과 부동소수점 리터럴

5) 문자 리터럴

6) 데이터 전기 신호 : 정수 & 부동소수점

#2 Gitignore 설정하기

VSstudio에서 코딩 작업을 하다가 git으로 push를 하게 되면 compile 된 파일까지 모두 push가 되어 공유가 됩니다.

이렇게 되면 각 사용자마다의 컴파일 방식이 다른데 제가 적용한 컴파일파일로 인해 데이터를 쓰지 못하게 되어 무용지물이 됩니다. 그래서 무수히 많은 파일을 매번 push 할 때마다 하나씩 push 할 수 없기에 이를 방기하기 위해 gitignore를 하여 소스원본파일만 push되도록 설정해보겠습니다.

1. 먼저 저는 bitcamp-study라는 폴더에서 주로 교육을 받기 때문에 그 폴더 아래에 모든 파일에 설정하기 위해 .gitignore파일을 bitcamp-study 아래에 생성해줍니다.

2. 그리고 나서 gitignore.io 를 들어가줍니다.( 주소 : https://www.toptal.com/developers/gitignore )

3. 여기서 ignore할 운영체제, 개발환경, 프로그래밍 언어 등을 생성 해줍니다.

저는 아래와 같이 이정도로 설정해서 생성해보겠습니다.

추가로 생성하셔서 생성하셔도 됩니다.

4. 그러면 아래와 같이 소스 코드가 나옵니다. ctrl + a 로 전체선택을 하고 ctrl + c 로 복사해서 .gitignore 에 붙여주고 저장합니다.

5. 이렇게 해주시면 아래와 같이 class 파일과 gradle 파일 등이 어두운 회색으로 변한것을 확인 할 수 있습니다.

#3 리터럴 데이터 표기

변수의 초기값은 코드에서 직접 입력하는 경우가 많은데, 소스 코드 내에서 직접 입력된 값을 리터럴(Literal)이라고 부릅니다.

Java의 기본 타입은 정수, 실수, 문자, 논리 리터럴을 직접 저장하는 타입을 말합니다.
메모리에 0과 1을 저장하는 최소 기억 단위인 비트(Bit)가 있으며, 8개의 비트는 바이트(btye)를 의미합니다.

기본 타입 (Primitive type)
- 정수
  - byte (1 byte)
  - char (2 byte)
  - short (2 byte)
  - int (4 byte)
  - long (8 byte)
- 실수
  - float (4 byte)
  - double (8 byte)
- 논리
  - boolean (1 byte)
참조 타입 (Reference type)
- 배열 타입
- 열거 타입
- 클래스
- 인터페이스

참조 : https://www.theserverside.com/tutorial/Why-the-8-Java-primitive-data-types-are-not-objects

#4 정수 리터럴과 부동소수점 리터럴

정수리터럴)

소수점이 없는 정수 리터럴은 10진수로 간주한다.

-> 코드에서 일반적으로 정수 값을 표현할 때 사용한다.

0으로 시작되는 리터럴은 8진수로 간주한다.

-> 코드를 작성할 때 잘 사용하지 않는다.

0b 또는 0B로 시작하는 정수 리터럴은 2진수로 간주한다.

-> 메모리의 상태를 직설적으로 보여주고 싶을 때 사용한다.

-> 숫자 앞에 0이 있어도 된다.

0x(0X)로 시작하고 A,B,C,D,E,F로 구성된 리터럴은 16진수로 간주한다.

-> 2진수를 간결하게 표현하기 위해 사용한다.

-> 숫자 앞에 0이 있어도 된다.

정수리터럴 자릿수 표기)

정수를 읽기 쉽도록 밑줄(underscore; _)를 숫자 사이에 삽입할 수 있습니다.

public class Exam0220 {
  public static void main(String[] args) {
    
    //## 10진수에 _ 문자를 삽입하기
    System.out.println(12783406);
    System.out.println(1278_3406);
    System.out.println(12_783_406);

    //숫자 맨 앞 또는 맨 뒤에 삽입할 수 없다.
    //System.out.println(_12783406); 
    //System.out.println(12783406_);
    
    //## 8진수에 _ 문자를 삽입하기
    System.out.println(077);
    System.out.println(0_77);
    System.out.println(07_7);

    //숫자 맨 앞 또는 맨 뒤에 삽입할 수 없다.
    //System.out.println(_077);
    //System.out.println(077_);

    //## 2진수에 _ 문자를 삽입하기
    System.out.println(0b1100100);
    System.out.println(0b110_0100);
    System.out.println(0b1_1_0_0_1_0_0);

    //숫자 맨 앞 또는 맨 뒤에 삽입할 수 없다.
    //System.out.println(0b_1100100);
    //System.out.println(0b1100100_);

    //## 16진수에 _ 문자를 삽입하기
    System.out.println(0xffaa);
    System.out.println(0xff_aa);

    //숫자 맨 앞 또는 맨 뒤에 삽입할 수 없다.
    //System.out.println(0x_ffaa);
    //System.out.println(0xffaa_);
  }
}

12783406
12783406
12783406
63
63
63
100
100
100
65450
65450

메모리의 크기에 따른 정수형 크기)

정수를 저장할 메모리의 크기를 지정할 수 있습니다.

S : 부호 비트(양수는 0, 음수는 1)

n : 타입의 크기(단위 : bit)

모든 정수는 부호가 있으므로 왼쪽의 첫 번째 비트를 부호 비트로 사용하며 나머지는 값을 표현하는데 사용한다. 정수형은 총 2n개가 표현가능하며, 부호 비트가 '0'으로 된 숫자 0을 포함한 2n-1개까지의 값이 양수의 표현이 가능하고, 나머지인 부호 비트가 '1'로 된 2n-1개의 값은 음수로 표현이 가능하다. 곧 값의 개수가 각각 2n-1개로 곱하기 2를 하면 2n개가 된다.

public class Exam0230 {
  public static void main(String[] args) {
    //## 4바이트 정수
    //접미사를 붙이지 않고 그냥 숫자를 표현하면 4바이트 크기의 메모리에 저장되는 정수를 표현한다.
    System.out.println(2147483647); // 4바이트 양의 정수 최대값
    System.out.println(-2147483648); // 4바이트 음의 정수 최소값

    //4바이트 메모리 크기를 초과하면 컴파일 오류가 발생한다.
    //System.out.println(2147483648);
    //System.out.println(-2147483649);

    //## 8바이트 정수
    //4바이트 메모리를 벗어나는 정수 값을 표현할 때 사용한다.
    //숫자 뒤에 L 또는 l을 붙인다.
    //보통 대문자를 붙인다. 왜? 소문자 l은 숫자 1과 헷갈리기 때문이다.
    System.out.println(2147483648L);
    System.out.println(-2147483649L);

    //## 4바이트 또는 8바이트 정수의 최대값과 최소값
    //자바에서는 각 데이터 유형에 따라 최대/최소 값을 알아볼 수 있도록 특별한 명령을 제공한다.
    System.out.println(Integer.MAX_VALUE); // 4바이트로 표현할 수 있는 정수 최대값
    System.out.println(Integer.MIN_VALUE); // 4바이트로 표현할 수 있는 정수 최소값
    System.out.println(Long.MAX_VALUE); // 8바이트로 표현할 수 있는 정수 최대값
    System.out.println(Long.MIN_VALUE); // 8바이트로 표현할 수 있는 정수 최소값

    //## 주의!
    //- 다음은 크기가 다른 정수이다.
    System.out.println(100); // 4바이트 크기의 정수 값
    System.out.println(100L); // 8바이트 크기의 정수 값
  }
}

2147483647
-2147483648
2147483648
-2147483649
2147483647
-2147483648
9223372036854775807
-9223372036854775808
100
100

부동소수점 리터럴)

부동 소수점 리터럴(소수, 숫자 또는 분수 리터럴)은 소수점과 옵션으로 지수 표시(e)까지 포함할 수 있는 연속된 숫자입니다. 컴퓨터는 1과 0으로 데이터를 저장하기에 실수 값을 부동소수점 방식으로 저장하려면 1과 0으로 변환해야 합니다.

자바는 부동소수점을 저장할 때 전기전자기술자협회(IEEE)에서 개발한 IEEE 754 명세에 따라 2진수로 변환합니다.

public class Exam0310 {
  public static void main(String[] args) {
    
    //## 10진수 표기법
    System.out.println(3.14);
    
    //## Exponential 기호 사용하기
    //- e 기호를 사용하면 소수점의 위치를 조정할 수 있다.
    //- 소수점의 위치를 움직인다고 해서 "부동소수점(floating point)"이라 부른다. 
    //- 표기법
    //    숫자e지수 또는 숫자E지수 
    System.out.println(0.0314e2); // 0.0314 * 10의2승 = 3.14
    System.out.println(0.314e1); // 0.314 * 10의1승 = 3.14
    System.out.println(31.4e-1); // 31.4 * 10의-1승 = 3.14
    System.out.println(314e-2); // 314 * 10의-2승 = 3.14
    
    //## 8바이트 크기의 부동소수점
    //- 숫자 맨 뒤에 d 또는 D를 붙인다.
    //- 생략해도 된다.
    System.out.println(3.14); // = 3.14
    System.out.println(3.14d); // = 3.14
    System.out.println(3.14D); // = 3.14

    //## 4바이트 크기의 부동소수점
    //- 숫자 맨 뒤에 f 또는 F를 붙인다.
    System.out.println(3.14f); // = 3.14 주로 소문자 f를 많이 붙인다.
    System.out.println(3.14F); // = 3.14
    
    //## 4바이트 부동소수점의 최대값과 최소값
    System.out.println(Float.MAX_VALUE); // = 3.4028235E38
    System.out.println(Float.MIN_VALUE); // = 1.4E-45
    
    //## 8바이트 부동소수점의 최대값과 최소값
    System.out.println(Double.MAX_VALUE); // = 1.7976931348623157E308
    System.out.println(Double.MIN_VALUE); // = 4.9E-324
    
  }
}

부동소수점 리터럴 - 유효자릿수)

정수처럼 메모리 크기(4바이트 또는 8바이트)에 따라 표현할 수 있는 부동소수점의 범위가 다릅니다.

단, IEEE 753 명세에 따라 2진수로 변환되기 때문에 정확하게 '소수점 이상 얼마까지 소수점 이하 얼마까지' 식으로 정의할 수가 없습니다. 대신에 '유효자릿수'라는 방식으로 대략적으로 값의 범위를 표현합니다.

public class Exam0340 {

  public static void main(String[] args) {

    //## 4byte(float) 부동소수점의 유효자릿수
    //소수점을 뺀 후 7자리 숫자까지는 거의 정상적으로 저장된다.
    System.out.println(999.9999f);
    System.out.println(999999.9f);
    System.out.println(9.999999f);
    System.out.println("----------------------------");

    //유효자릿수가 7자리를 넘어가는 경우 값이 잘려서 저장될 수 있다.
    System.out.println(987654321.1234567f);
    System.out.println(9.876543211234567f);
    System.out.println(987654321123456.7f);
    System.out.println("----------------------------");

    //## 8byte(double) 부동소수점의 유효자릿수
    //소수점을 뺀 후 16자리 숫자까지는 거의 정상적으로 저장된다.
    System.out.println(987654321.1234567);
    System.out.println(9.876543211234567);
    System.out.println(987654321123456.7);
    System.out.println("----------------------------");

    //유효자릿수가 16자리를 넘어가는 경우 값이 잘려서 저장될 수 있다.
    System.out.println(987654321.12345678);
    System.out.println(9.8765432112345678);
    System.out.println(987654321123456.78);
    System.out.println("----------------------------");

    //## 부동소수점을 저장할 때 정확하게 저장되지 않는 예
    System.out.println(7 * 0.1); //결과: 0.7000000000000001
    //- 이유
    //  - IEEE-754 규격에 따라 부동소수점을 2진수로 바꾸다보면
    //    정확하게 2진수로 딱 떨어지지 않는 경우가 있다.
    //    CPU, OS, 컴파일러, JVM의 문제가 아니다.
    //  - IEEE-754의 방법에 내재되어 있는 문제다.
    //- 해결책
    //  - 시스템에서 필요한 만큼 소수점 이하 자리수를 적절히 짤라 사용하라!
  }
}


999.9999
999999.9
9.999999
----------------------------
9.8765434E8
9.876543
9.876543E14
----------------------------
9.876543211234567E8
9.876543211234567
9.876543211234568E14
----------------------------
9.876543211234568E8
9.876543211234567
9.876543211234568E14
----------------------------
0.7000000000000001

실수 값을 정규화하는 방법)

- 예: 12.375(10진수)

1) 소수점 앞의 정수 값을 2진수로 변환한다.
12(10진수)
= 1100(2진수)

2) 소수점 뒤의 값을 2진수로 변환한다.
- 변환 규칙
- 소수점을 2로 곱하여 나온 결과에서 정수 부분만을 차례대로 표기한다.
- 소수 부분이 0이거나 반복되면 계산을 멈춘다.
- 예: 0.375(10진수)
0.375 * 2 = 0.75  --> 0
0.75 * 2  = 1.5   --> 1
0.5 * 2   = 1.0   --> 1
=> 0.011(2진수)

3) 2진수 바꾼 최종 결과
12.375(10진수)
= 12(10진수) + 0.375(10진수)
= 1100(2진수) + 0.011(2진수)
= 1100.011(2진수)
= 1*2^3 + 1*2^2 + 0*2^1 + 0*2^0 + 0*2^-1 + 1*2^-2 + 1*2^-3
= 1*8 + 1*4 + 0*2 + 0*1 + 0*0.5 + 1*0.25 + 1*0.125

4) 정규화
- 소수점의 위치를 조정하여 가수부와 지수부를 분리한다.
- IEEE 754 명세는 다음과 같은 형식으로 가수부와 지수부를 나눈다.
1.x1x2x3x4...x23(2진수) * 2^e
=> 소수점 왼쪽에 1만 남도록 소수점을 이동한다.
=> 소수점 왼쪽은 무조건 1이기 때문에 저장하지 않고 버린다.
=> 따라서 소수점 오른쪽 수만 가수부에 놓는다.
즉 x1, x2 등은 가수부 1번 비트부터 23번 비트까지를 의미한다.
=> 23번 비트까지 채우지 못하면 나머지 비트는 0으로 채운다.
- 예)
1100.011(2진수)
= 1.100011(2진수) * 2^3
가수부 => 100011(2진수)
지수부 => 3 + 127(bias) = 130(10진수) = 10000010(2진수)

5) 32비트로 표현하기
[0][10000010][10001100000000000000000]
=> 0100_0001_0100_0110_0000_0000_0000_0000
=> 0x41460000

클래스파일의 Hex Editor를 이용하여 부동소수점 찾기)

1) 컴파일하기
- $ javac -d bin/main -encoding UTF-8 src/main/java/com/eomcs/lang/ex03/Exam0350.java(본인의 컴파일 할 경로를 확인해서 컴파일 진행해주세요)

2) 클래스 파일로 부동소수점 값 확인하기
- Exam0350.class 파일을 hex Editor 플러그인으로 출력한다.
- 12.375의 2진수 값인 0100_0001_0100_0110_0000_0000_0000_0000을 찾아본다.
보통 에디터에서는 2진수를 16진수로 바꿔 보여주기 때문에 16진수 값 0x41460000을 찾아보기!

정수를 2진수로 표현하는 방법)

1) 부호-크기/절대값(Sign-Magnitude)
- 부동 소수점에서 가수부(significand or mantissa)를 저장할 때 사용한다.
- 맨 왼쪽 1비트를 부호 비트로 사용한다. 양수는 0, 음수는 1 이다.
- 나머지 비트는 절대값(magnitude)으로 저장한다.
8비트 = 1비트(부호) + 7비트(절대값)
예) +24 => |+24| = 24 ---> 0001 1000
예) -24 => |-24| = 24 ---> 1001 1000
- 수의 범위(8비트 기준): -127 ~ + 127
0111 1111 (127)
0111 1110 (126)
0111 1101 (125)
...
0000 0001 (1)
0000 0000 (+0)
1000 0000 (-0)
1000 0001 (-1)
...
1111 1101 (-125)
1111 1110 (-126)
1111 1111 (-127)
- 단점
- 두 개의 0(+0, -0)이 존재한다.
- 양수와 음수를 더했을 때 옳지 않은 값이 나온다.
예) 4비트일 경우, 1 + -1 = ?
0001(+1) + 1001(-1) = 1010 (-2) <-- 계산 결과가 옳지 않다.
- 빼기를 처리하는 컴퓨팅 회로를 별도로 설계해야 하므로 하드웨어가 복잡해진다.
- 장점
- 이해하기 쉽다!

2) 1의 보수(Ones' Complement)
- 모든 비트를 반대 값으로 바꾼다.
예) +24 => 0001 1000
예) -24 => 1110 0111
- 수의 범위(8비트 기준): -127 ~ +127
0111 1111 (127)
0111 1110 (126)
0111 1101 (125)
...
0000 0001 (1)
0000 0000 (+0)
1111 1111 (-0)
1111 1110 (-1)
...
1000 0010 (-125)
1000 0001 (-126)
1000 0000 (-127)
- 단점
- 두 개의 0(+0, -0)이 존재한다.
- 두 수를 더한 후 비트 크기를 초과한 1 값을 다시 맨 뒤에 더해야만 옳은 값이 된다.
예) 4비트일 경우,
0001(+1)
1110(-1)
--------
1111(-0) <--- 음수 0과 양수 0을 다뤄야 하는 것이 번거롭다.

0101(+5)
1100(-3)
--------
1 0001(1) <--- 옳지 않은 값.
+ 1 <--- 4비트를 초과하는 값을 다시 맨 뒤에 더함.
---------
0010(2) <--- 옳은 값!

3) 2의 보수(Two's complement)
- 자바에서 음수를 저장하는 방법이다.
- 1의 보수의 문제점을 해결하기 위해 등장한 방법.
- 음수 0을 없앰으로써 -128까지 표현할 수 있음.
- 2의 보수를 만드는 방법 1:
- 모든 비트를 반대 값으로 만든 다음 1을 더한다.
예) 0010 1001(+41)
1101 0110(1의 보수)
1
--------------
1101 0111(-41)
- 2의 보수를 만드는 방법 2:
- 오른쪽에서부터 1을 찾는다.
- 찾은 1의 왼쪽편에 있는 모든 비트를 반대 값으로 바꾼다.
예) 0010 1001(41) => 1101 0111(-41)
^ ^
예) 0010 1100(44) => 1101 0100(-44)
^ ^
- 2의 보수를 만드는 방법 3:
- 2^n(8비트일 경우 2^8 = 256)에서 음수 값 만큼 뺀다.
예) -41 => 256 - 41 = 215 = 1101 0111
예) -44 => 256 - 44 = 212 = 1101 0100
- 수의 범위(8비트 기준): -128 ~ +127
0111 1111 (127)
0111 1110 (126)
0111 1101 (125)
...
0000 0010 (2)
0000 0001 (1)
0000 0000 (+0)
1111 1111 (-1)
1111 1110 (-2)
...
1000 0011 (-125)
1000 0010 (-126)
1000 0001 (-127)
1000 0000 (-128)
- 장점
- 양수와 음수의 덧셈이 가능하다.
- 음수 0이 없다. 0에 대한 표현이 한 가지이다.

4) K-초과(Excess-K)
- 부동 소수점의 지수부(exponent)를 저장할 때 사용한다.
- 오프셋 바이너리(offset binary) 또는 바이어스된 표기법(biased representation) 이라고도 한다.
- K를 바이어스 값이라 부르며, 표현하려는 값에 더할 때 사용한다.
표현하려는 값 + 초과 값(K) = 결과
- 바이어스 값(K)을 구하는 공식:
K = 2^(비트수 - 1)
예) 8비트일 경우 ---> K = 2^(8 - 1) = 2^7 = 128, 결과 = 128 + 값
1111 1111 = 128 + 127
1111 1110 = 128 + 126
1111 1101 = 128 + 125
...
1000 0001 = 128 + 1
1000 0000 = 128 + 0
0111 1111 = 128 + (-1)
...
0000 0010 = 128 + (-126)
0000 0001 = 128 + (-127)
0000 0000 = 128 + (-128)

- IEEE 부동소수점 표준에서는 다음의 공식을 사용한다.
K = 2^(비트수 - 1) - 1
예) 8비트일 경우 ---> K = 2^7 - 1 = 127, 결과 = 127 + 값
1111 1111 = 127 + 128
1111 1110 = 127 + 127
1111 1101 = 127 + 126
1111 1100 = 127 + 125
...
1000 0000 = 127 + 1
0111 1111 = 127 + 0
0111 1110 = 127 + (-1)
...
0000 0010 = 127 + (-125)
0000 0001 = 127 + (-126)
0000 0000 = 127 + (-127)

- 바이어스 방식으로 데이터를 저장할 때의 이점?
- 모든 비트가 0일 때 최소 값을 가지고, 모든 비트가 1일 때 최대 값을 갖는다.
- 이런 이유로 작은 값에서 큰 값으로 정렬되는 결과를 낳는다.
- 모든 비트가 정렬된 상태이기 때문에 부동소수점이든 정수이든 상관없이 값을 비교할 때 속도가 빠르다.
- '부호-크기', '1의 보수', '2의 보수'와 같은 방법으로 값을 표현할 경우, 비트들이 순차적으로 정렬되지 않는다.

#5 문자 리터럴

- 작은 따옴표 ' ' 를 사용하여 문자를 표현합니다.

- 자바는 문자를 다룰 때 2바이트 값으로 다룹니다.
- 즉 각각의 문자는 규칙에 따라 0 ~ 65535(2의16승)까지의 값으로 메모리에 저장됩니다.
- 각 문자를 표현하기 위해 정의된 값을 '문자 코드(character code)'라고 부릅니다.
- 각 문자에 부여된 문자 코드의 집합을 '문자 집합(chararacter set)'이라 부릅니다.
- 자바가 사용하는 문자 집합은 '유니코드(Unicode)'입니다.

## 유니코드
- 전 세계의 모든 문자를 컴퓨터에서 일관되게 처리할 목적으로 정의된 산업 표준 규칙이다.
- 유니코드는 '문자를 2진수로 표현(인코딩; encoding)'할 때, 두 가지 방식(UTF와 UCS)을 사용한다.
- 자바는 메모리에 문자를 저장할 때는 'UCS(국제 문제 집합)'를 사용하고, 외부로 입출력 할 때는 'UTF'를 사용한다.

## UCS(Universal Coded Character Set; 국제 문자 집합)
- 'ISO 10646' 표준을 가리키는 이름이다.
- UCS는 110만개 이상의 문자에 대해 코드 값을 정의하고 있다.
- 그 중에서 첫 65536개(0 ~ 65535 까지의 코드)의 문자 코드가 주로 사용된다.
- 이 범위의 유니코드를 'BMP(Basic Multilingual Plane; 기본 다국어 평면)'라 하며 보통 'UCS-2'라 부른다.
즉 2바이트 범위에서 정의한 유니코드라는 의미다.
- 자바가 사용하는 유니코드는 바로 이 'UCS-2'라 불리는 범위의 유니코드이다.

## UTF(UCS Transformation Format)
- 문자를 1바이트 코드 값으로 저장하는 기존 시스템에서 UCS를 사용하기 위해 만든 문자 인코딩 방식이다.
- UTF-8, UTF-16, UTF-32가 있으며 주로 UTF-8이 사용된다.

## UTF-8
- UCS의 코드 값 중에서 00 ~ 7F(127개)까지 ASCII에 해당하는 UCS 코드는 그대로 1바이트로 표현한다.
따라서 ASCII를 기본으로 사용하는 시스템의 경우 UTF-8로 인코딩 된 데이터를 특별한 처리없이 그대로 읽고 쓸 수 있다.
- 그 외의 문자 코드는 규칙에 따라 2바이트 ~ 4바이트까지 변환하여 표현한다.
- UCS의 UTF-8 변환 규칙
000000 ~ 00007F: 0xxxxxxx
000080 ~ 0007FF: 110yyyxx 10xxxxxx
000800 ~ 00FFFF: 1110yyyy 10yyyyxx 10xxxxxx
100000 ~ 10FFFF: 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
- 대부분의 시스템에서 데이터 입출력 할 때 UTF-8을 사용한다.
- 자바에서도 데이터 입출력할 때 주로 UTF-8을 사용하고 있다.

## UTF-16
- UCS-2의 코드 값은 그대로 2바이트로 표현한다.
- ASCII 코드도 UCS-2와 동일하게 2바이트로 표현한다.
- 따라서 UCS-2의 코드 값을 표현할 때는 UCS-2와 같다.
- UCS-2와 다른 점은 UCS-2의 범위를 벗어나는 문자 코드 값도 표현할 수 있으며,
UCS-2를 벗어나는 유니코드는 무조건 4바이트로 변환한다.
- UCS의 UTF-16 변환 규칙
000000 ~ 00007F: 00000000 0xxxxxxx
000080 ~ 0007FF: 00000yyy xxxxxxxx
000800 ~ 00FFFF: yyyyyyyy xxxxxxxx
100000 ~ 10FFFF: 110110zz zzyyyyyy 110111yy xxxxxxxx

## UTF-32
- UCS-4의 4바이트 코드 값을 그대로 표현한다.
- 즉 UTF-32는 UCS-4와 같다.
- 모든 문자를 4바이트 코드 값으로 표현하기 때문에 메모리 낭비가 심하다.

public class Exam0420 {
  public static void main(String[] args) {
    
    //## 문자 'A'의 문자 코드를 직접 사용하여 문자를 출력하기
    //유니코드 문자집합에서 문자 'A'의 문자 코드는 65 이다.
    
    //println()에 숫자를 그냥 전달하면 일반 숫자인줄 알고 그대로 출력한다.
    System.out.println(65);

    //println()에 전달하는 값이 일반적인 수가 아니라 문자 코드임을 지정해야 한다.
    //숫자 앞에 (char) 를 붙여 이 숫자가 평범한 숫자가 아니라 문자의 UCS-2 코드 값임을 알려줘라.
    //  (char)문자코드
    System.out.println((char)65);

    //보통 문자 코드를 표현할 때 16진수를 사용한다.
    System.out.println((char)0x41);

    //한글 '가'를 문자 코드를 이용하여 출력하기
    System.out.println((char)0xAC00);
    
    //'가' 다음 문자 출력하기
    System.out.println((char)(0xAC00 + 1));
    
    //영어 대문자 모두 출력하기
    //첫 번째 알파벳의 코드 값만 안다면 + 연산자를 이용하여 출력할 수 있다.
    for (int i = 0; i < 26; i++) {
      System.out.print((char)(i + 65) + ",");
    }
  }
}

65
A
A
가
각
A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,

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

    //유니코드를 직접 넘겨주기
    //단, 유니코드임을 알려주기 위해 (char)를 앞에 붙인다.
    System.out.println((char)65);

    //작은 따옴표를 사용하여 문자 코드를 넘겨주기
    //(char)붙일 필요가 없다.
    System.out.println('A');

    //작은 따옴표가 알려준 유니코드를 그대로 출력하기
    //정수를 의미하는 (int)를 앞에 붙인다.
    System.out.println((int)'A');

    // '각' ==> 0xac01(44033) 을 리턴한다.
    // 따라서 다음과 같이 다른 숫자와 연산을 수행할 수 있다.
    System.out.println('각' + 1);
    System.out.println('각' - 1);
    // 문자 코드에 정수 값을 연산하는 순간 
    // 그 결과는 더이상 문자 코드가 아니라 일반적인 정수가 된다.
    // 그래서 println()은 그 값에 대한 문자를 출력하는 것이 아니라
    // 그냥 정수를 출력하는 것이다.

    // 해당 계산 결과를 문자 코드로 바꾸고 싶다면,
    // 이전에 했던대로 (char) 명령을 붙여라
    System.out.println((char)('각' + 1));
    System.out.println((char)('각' - 1));
  }
}


A
A
65
44034
44032
갂
가

문자열 리터럴은 자바의 기본 타입이 아니라 객체입니다. 객체는 여러 데이터들의 덩어리로 비유 할 수 있습니다. 표기법은 아래와 같습니다.

큰 따옴표(double quote) 안에 문자들(문자열)을 작성한다.
예) "홍길동", "임꺽정", "hello"

public class Exam0610 {
  public static void main(String[] args) {
    // 문자열 리터럴 기본 예
    System.out.println("ABC가나다");

    // 문자열에 유니코드를 포함할 수 있다.
    System.out.println("\u0041BC\uac00나다");
  }
}


ABC가나다
ABC가나다

문자열 리터럴 + 연산자)

- 문자열 연결 연산자(concatenation): +
+ 를 이용하여 문자열과 문자열을 연결한다.
이때 두 개의 문자열이 연결된 새 문자열이 생성된다.
예) "홍길동" + "입니다." => "홍길동입니다."

- 문자열과 다른 종류의 값을 연결하기
문자열과 다른 종류의 값을 연결할 수 있다.
연결되기 전에 다른 종류의 값이 먼저 문자열로 바뀐 다음에 연결된다.

public class Exam0620 {
  public static void main(String[] args) {
    // 두 문자열을 합쳐 새 문자열이 생성된다.
    // "Hello," + "world!" = "Hello,world!"
    System.out.println("Hello," + "world!");

    // 새 문자열을 만들어 숫자를 붙인다.
    // "나이:" + 20 = "나이:20"
    System.out.println("나이:" + 20);

    // 새 문자열을 만들어 논리 값을 붙인다.
    // false + "<== 재직자 여부" = "false<== 재직자 여부"
    System.out.println(false + "<== 재직자 여부");

    // 새 문자열을 만들어 문자를 붙인다.
    // "성별:" + '여' = "성별:여"
    System.out.println("성별:" + '여');

    // 새 문자열을 만들어 부동소수점을 붙인다.
    // "키:" + 170.5f = "키:170.5" <== 부동소수점 접미사 f 는 새로 만든 문자열에 붙지 않는다.
    System.out.println("키:" + 170.5f);
  }
}


Hello,world!
나이:20
false<== 재직자 여부
성별:여
키:170.5

이스케이프 문자 - escape charcter)

문자 제어 코드라고도 하며, 화면에 출력하는 문자가 아니라 문자 출력을 제어하는 문자입니다.

- 제어 문자
\n - Line Feed(LF), 0x0a
\r - Carrage Return(CR), 0x0d
\f - Form Feed, 0x0c
\t - Tab, 0x09
\b - Backspace, 0x08
\' - Single Quote, 0x27
\" - Double Quote, 0x22
\\ - Backslash, 0x5c

public class Exam0700 {
  public static void main(String[] args) {
    System.out.println("Hello,world!"); 
    System.out.println("Hello,\nworld!"); // 줄바꿈 문자
    System.out.println("Hello,\rabc"); // 커서(cursor)를 처음으로 돌리는 문자
    // 커서란? 문자를 출력할 위치를 가리키는 것.

    System.out.println("Hello,\b\b\bworld!"); // 커서를 뒤로 한 칸 이동시키는 문자
    System.out.println("Hello,\tworld!"); // 탭 공간을 추가시키는 문자
    System.out.println("Hello,\fworld!"); // 
    System.out.println("Hello,\"w\"orld!"); // " 문자를 출력시키는 문자
    System.out.println("Hello,'w'orld!"); //"" 안에서 ' 문자는 그냥 적는다.
    System.out.println('\''); // ' 문자를 출력시키는 문자
    System.out.println('"'); // '' 안에서 " 문자는 그냥 적는다.
    System.out.println("c:\\Users\\user\\git"); // \ 문자를 출력시키는 문자
  }
}


Hello,world!
Hello,
world!
abclo,
Helworld!
Hello,  world!
Hello,
world!
Hello,"w"orld!
Hello,'w'orld!
'
"

'[Naver Cloud Camp 7] 교육 정리' 카테고리의 다른 글

네이버 클라우드 캠프 25일차 230530 (0)	2023.05.30
네이버 클라우드 캠프 24일차 230526 (0)	2023.05.26
네이버 클라우드 캠프 22일차 230524 (4)	2023.05.24
네이버 클라우드 캠프 21일차 230523 (0)	2023.05.23
네이버 클라우드 캠프 20일차 230522 (2)	2023.05.22

[우기37] 코린이 집사의 개발일지

네이버 클라우드 캠프 23일차 230525

#1 교육정리

#2 Gitignore 설정하기

#3 리터럴 데이터 표기

#4 정수 리터럴과 부동소수점 리터럴

#5 문자 리터럴

'[Naver Cloud Camp 7] 교육 정리' 카테고리의 다른 글

티스토리툴바

네이버 클라우드 캠프 23일차 230525

#1 교육정리

#2 Gitignore 설정하기

#3 리터럴 데이터 표기

#4 정수 리터럴과 부동소수점 리터럴

#5 문자 리터럴

'[Naver Cloud Camp 7] 교육 정리' 카테고리의 다른 글

관련글

티스토리툴바