Java Language
리터럴

소개

16 진수, 8 진수 및 2 진수

hexadecimal 는 hexadecimal 의 값입니다. 16 자릿수, 0-9 및 AF (대소 문자는 중요하지 않음)가 있습니다. AF 는 10-16 나타냅니다.

octal 는 octal 의 값이며 숫자 0-7 사용합니다.

binary 는 binary 의 값이며 숫자 0 과 1 됩니다.

이 숫자들은 모두 같은 값을 갖습니다. 110 :

int dec = 110;            // no prefix   --> decimal literal
int bin = 0b1101110;      // '0b' prefix --> binary literal
int oct = 0156;           // '0' prefix  --> octal literal
int hex = 0x6E;           // '0x' prefix --> hexadecimal literal

바이너리 리터럴 구문은 Java 7에서 소개되었습니다.

8 진 리터럴은 쉽게 의미 론적 오류에 대한 함정이 될 수 있습니다. 소수점 리터럴에 선행 '0' 을 정의하면 잘못된 값을 얻게됩니다.

int a = 0100;        // Instead of 100, a == 64

가독성을 높이기 위해 밑줄 사용

Java 7부터 원시 숫자 리터럴의 숫자 그룹을 분리하기 위해 하나 이상의 밑줄 (_)을 사용하여 가독성을 향상시킬 수있었습니다.

예를 들어, 다음 두 선언은 동일합니다.

int i1 = 123456;
int i2 = 123_456;
System.out.println(i1 == i2); // true

이것은 아래와 같이 모든 원시적 인 숫자 리터럴에 적용될 수 있습니다 :

byte color = 1_2_3;
short yearsAnnoDomini= 2_016;
int socialSecurtyNumber = 999_99_9999;
long creditCardNumber = 1234_5678_9012_3456L;
float piFourDecimals =  3.14_15F;
double piTenDecimals =  3.14_15_92_65_35;

이것은 또한 2 진수, 8 진수 및 16 진수로 접두사를 사용하여 작동합니다.

short binary= 0b0_1_0_1;
int octal = 07_7_7_7_7_7_7_7_0;
long hexBytes = 0xFF_EC_DE_5E;

다음 위치에서 배치를 금지 하는 밑줄에 대한 몇 가지 규칙이 있습니다.

• 숫자의 시작 또는 끝 부분 (예 : _123 또는 123_ 이 유효 하지 않음)
• 부동 소수점 리터럴의 소수점에 인접 (예 : 1._23 또는 1_.23 이 유효 하지 않음)
• 접미사 1.23_F F 또는 L이 있어야합니다 (예 : 1.23_F 또는 9999999_L 은 유효 하지 않음).
• 자리수가 예상되는 위치 (예 : 0_xFFFF 가 유효 하지 않은 경우)

리터럴의 이스케이프 시퀀스

문자열 및 문자 리터럴은 달리 리터럴에서 허용되지 않는 표현식 문자 코드를 허용하는 이스케이프 메커니즘을 제공합니다. 이스케이프 시퀀스는 백 슬래시 문자 ( \ ) 다음에 하나 이상의 다른 문자로 구성됩니다. 같은 순서가 두 문자 모두에서 문자열 리터럴에 유효합니다.

이스케이프 시퀀스의 전체 세트는 다음과 같습니다.

위의 <octal> 는 0에서 255 (10 진수) 사이의 숫자를 나타내는 1, 2 또는 3 개의 8 진수 ( '0'에서 '7')로 구성됩니다.

백 슬래시 다음에 다른 문자가 오는 것은 유효하지 않은 이스케이프 시퀀스입니다. 유효하지 않은 이스케이프 시퀀스는 JLS에서 컴파일 오류로 처리됩니다.

참고:

• JLS 3.10.6. 문자 및 문자열 리터럴 이스케이프 시퀀스

유니 코드 이스케이프

위에서 설명한 문자열 및 문자 이스케이프 시퀀스 외에도 Java에는 JLS 3.3에 정의 된보다 일반적인 유니 코드 이스케이프 메커니즘이 있습니다. 유니 코드 이스케이프 . 유니 코드 이스케이프의 구문은 다음과 같습니다.

'\' 'u' <hex-digit> <hex-digit> <hex-digit> <hex-digit> 

여기서 <hex-digit> 중 하나 인 '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'A' , 'B' , 'C' , 'D' , 'E' , 'F' .

유니 코드 이스케이프는 Java 컴파일러에서 문자 (정확히 16 비트 유니 코드 코드 단위 )로 매핑되며 매핑 된 문자가 유효한 소스 코드의 모든 위치에서 사용할 수 있습니다. 이것은 리터럴에서 비 ASCII 문자를 나타낼 필요가있을 때 문자 및 문자열 리터럴에서 일반적으로 사용됩니다.

정규 표현식에서 이스케이프 처리하기

미정

십진수 정수 리터럴

정수 리터럴은 byte , short , int , long 또는 char 인스턴스가 필요한 곳에서 사용할 수있는 값을 제공합니다. (이 예제는 간단한 십진수 양식에 중점을 둡니다. 다른 예제에서는 8 진수, 16 진수 및 2 진수로 리터럴을 사용하는 방법과 가독성을 높이기 위해 밑줄을 사용하는 방법을 설명합니다.)

일반 정수 리터럴

정수 리터럴의 가장 단순하고 가장 일반적인 형태는 십진 정수 리터럴입니다. 예 :

 0       // The decimal number zero       (type 'int')
 1       // The decimal number one        (type 'int')
 42      // The decimal number forty two  (type 'int')

선행 0에주의해야합니다. 선행 0은 정수 리터럴이 십진수가 아닌 8 진수 로 해석되도록합니다.

 077    // This literal actually means 7 x 8 + 7 ... or 63 decimal!

정수 리터럴은 서명되지 않습니다. 당신이 좋아하는 것을 볼 경우 -10 또는 +10 , 이들은 단항 사용하여 표현 실제로 - 및 단항 + 연산자.

이 형식의 정수 리터럴 범위는 int 의 intrinsic 유형을 가지며 0에서 2 ³¹ 또는 2,147,483,648 범위에 있어야합니다.

2 ³¹ 은 Integer.MAX_VALUE 보다 1 크다. 에 이르기까지 0에서 리터럴 2147483647 어디서나 사용할 수 있지만 사용하는 컴파일 오류가 2147483648 선행하는 단항없이 - 연산자. (즉, Integer.MIN_VALUE 의 값을 나타 내기 위해 예약되어 있습니다.)

 int max = 2147483647;     // OK
 int min = -2147483648;    // OK
 int tooBig = 2147483648;  // ERROR

긴 정수 리터럴

long 타입의 리터럴은 L 접미사를 추가하여 표현됩니다. 예 :

 0L          // The decimal number zero       (type 'long')
 1L          // The decimal number one        (type 'long')
 2147483648L // The value of Integer.MAX_VALUE + 1

 long big = 2147483648;    // ERROR
 long big2 = 2147483648L;  // OK

int 와 long 리터럴의 구별은 다른 곳에서는 중요합니다. 예를 들어

 int i = 2147483647;
 long l = i + 1;           // Produces a negative value because the operation is
                           // performed using 32 bit arithmetic, and the 
                           // addition overflows
 long l2 = i + 1L;         // Produces the (intuitively) correct value.

참조 : JLS 3.10.1 - 정수 리터럴

부울 리터럴

Boolean 리터럴은 Java 프로그래밍 언어에서 가장 단순한 리터럴입니다. 가능한 두 가지 boolean 값은 true 및 false 리터럴로 나타냅니다. 대 / 소문자를 구분합니다. 예 :

boolean flag = true;    // using the 'true' literal
flag = false;           // using the 'false' literal

문자열 리터럴

문자열 리터럴은 Java 소스 코드에서 문자열 값을 표현하는 가장 편리한 방법을 제공합니다. 문자열 리터럴은 다음과 같이 구성됩니다.

• 여는 큰 따옴표 ( " ) 문자입니다.
• 큰 따옴표 나 줄 바꿈 문자가 아닌 0 개 이상의 다른 문자. 백 슬래시 ( \ ) 문자는 후속 문자의 의미를 변경하며 리터럴의 이스케이프 시퀀스를 참조하십시오.
• 닫는 큰 따옴표 문자.

예 :

"Hello world"   // A literal denoting an 11 character String
""              // A literal denoting an empty (zero length) String
"\""            // A literal denoting a String consisting of one 
                //     double quote character
"1\t2\t3\n"     // Another literal with escape sequences

단일 문자열 리터럴은 여러 소스 코드 줄에 걸쳐 있지 않을 수도 있습니다. 리터럴의 닫는 큰 따옴표 앞에 줄 바꿈 (또는 소스 파일의 끝)이 발생하는 것은 컴파일 오류입니다. 예 :

"Jello world    // Compilation error (at the end of the line!)

긴 문자열

한 줄에 들어갈 수없는 문자열이 필요하다면, 표현하는 전통적인 방식은이를 여러 개의 리터럴로 나누고 연결 연산자 ( + )를 사용하여 조각을 결합하는 것입니다. 예를 들어

String typingPractice = "The quick brown fox " +
                        "jumped over " +
                        "the lazy dog"

문자열 리터럴과 + 로 구성된 위와 같은 표현식은 상수 표현식을 위한 요구 사항을 만족시킵니다. 이는 표현식이 컴파일러에 의해 평가되고 런타임에 단일 String 객체로 표현됨을 의미합니다.

문자열 리터럴의 내부 처리

문자열 리터럴을 포함하는 클래스 파일이 JVM에 의해로드 된 경우, 해당 String 객체는 런타임 시스템에 의해 구금되어있다. 즉, 여러 클래스에 사용 된 문자열 리터럴은 한 클래스에서 사용 된 것보다 더 많은 공간을 차지하지 않습니다.

인턴 및 문자열 풀에 대한 자세한 내용은 문자열 항목의 문자열 풀 및 힙 저장소 예제를 참조하십시오.

Null 리터럴

Null 문자 ( null 작성)는 null ( null ) 유형의 유일한 값을 나타냅니다. 여기 예시들이 있습니다

    MyClass object = null;
    MyClass[] objects = new MyClass[]{new MyClass(), null, new MyClass()};

    myMethod(null);

    if (objects != null) {
         // Do something
    }

null 형은 다소 드물다. 이름이 없으므로 Java 소스 코드로 표현할 수 없습니다. (그리고 런타임 표현도 없습니다.)

널 유형의 유일한 목적은 유형이 될 것입니다 null . 모든 참조 유형과 지정이 호환되며 모든 참조 유형으로 유형을 변환 할 수 있습니다. 후자의 경우 캐스트는 런타임 유형 검사를 수반하지 않습니다.

마지막으로 null 은 null instanceof <SomeReferenceType> 이 유형과 상관없이 false 평가된다는 속성을 갖습니다.

부동 소수점 리터럴

부동 소수점 리터럴은 float 또는 double 인스턴스가 필요한 곳에서 사용할 수있는 값을 제공합니다. 부동 소수점 리터럴에는 세 가지 종류가 있습니다.

• 간단한 십진 형식
• 스케일 된 소수 양식
• 16 진수 형식

JLS 구문 규칙은 두 개의 10 진수 형식을 하나의 형식으로 결합합니다. 설명의 편의를 위해 별도로 취급합니다.

접미사를 사용하여 표현 된 float 및 double 리터럴에 대한 고유 한 리터럴 유형이 있습니다. 다양한 형태는 편지를 사용하여 다양한 것을 표현합니다. 이 문자는 대소 문자를 구분하지 않습니다.

간단한 십진 형식

부동 소수점 리터럴의 가장 간단한 형식은 하나 이상의 십진수와 소수점 ( . ) 및 선택적 접미사 ( f , F , d 또는 D )로 구성됩니다. 선택적 접미어를 사용하면 리터럴이 float ( f 또는 F ) 또는 double ( d 또는 D ) 값임을 지정할 수 있습니다. 디폴트 (접미사가 지정되지 않은 경우)는 double 입니다.

예를 들어

 0.0     // this denotes zero
 .0      // this also denotes zero
 0.      // this also denotes zero
 3.14159 // this denotes Pi, accurate to (approximately!) 5 decimal places.
 1.0F    // a `float` literal
 1.0D    // a `double` literal.  (`double` is the default if no suffix is given)

실제로 접미사가 오는 십진수는 부동 소수점 리터럴입니다.

 1F      // means the same thing as 1.0F

소수점 리터럴의 의미는 10 진수 부동 소수점 형식으로 표시된 무한 정밀도 수학 실수에 가장 근접한 IEEE 부동 소수점 수입니다. 이 개념 값은 가장 가까운 수로 반올림 하여 IEEE 이진 부동 소수점 표현으로 변환됩니다. 10 진수 변환의 정확한 의미는 Double.valueOf(String) 및 Float.valueOf(String) 의 javadocs에 지정되며 숫자 구문에 차이점이 있음을 유의하십시오.

스케일 된 소수 양식

스케일 된 십진수 형식은 지수 부분이 E 또는 e 로 시작되고 부호가 매겨진 정수가 오는 단순 십진수로 구성됩니다. 지수 부분은 아래의 예와 같이 십진법에 10의 거듭 제곱을 곱하는 짧은 손입니다. float 과 double 리터럴을 구분할 수있는 선택적 접미사도 있습니다. 여기 예시들이 있습니다 :

 1.0E1    // this means 1.0 x 10^1 ... or 10.0 (double)
 1E-1D    // this means 1.0 x 10^(-1) ... or 0.1 (double)
 1.0e10f  // this means 1.0 x 10^(10) ... or 10000000000.0 (float)

리터럴의 크기는 표현 ( float 또는 double )에 의해 제한됩니다. 배율 인수가 너무 크거나 작 으면 컴파일 오류입니다.

16 진수 형식

Java 6부터는 부동 소수점 리터럴을 16 진수로 표현할 수 있습니다. 16 진수 형식은 다음과 같은 차이점이있는 단순한 소수 자릿수와 소수 자릿수와 유사한 구문을가집니다.

1. 모든 16 진수 부동 소수점 리터럴은 영 ( 0 )으로 시작하고 x 또는 X 합니다.
2. 숫자의 자릿수 (지수 부분이 아님 !)에는 a 부터 f 까지의 16 진수와 해당 대문자도 포함됩니다.
3. 지수는 필수적 이며 e 또는 E 대신 문자 p (또는 P )로 도입됩니다. 지수는 10의 거듭 제곱 대신 2의 거듭 제곱 인 배율 인수를 나타냅니다.

여기 예시들이 있습니다 :

0x0.0p0f    // this is zero expressed in hexadecimal form (`float`)
0xff.0p19   // this is 255.0 x 2^19 (`double`)

조언 : 16 진수 부동 소수점 형식은 대부분의 Java 프로그래머에게는 익숙하지 않으므로 사용하지 않는 것이 좋습니다.

밑줄

Java 7부터는 부동 소수점 리터럴의 세 가지 형식 모두에서 숫자 문자열 내에 밑줄이 허용됩니다. 이것은 "지수"파트에도 적용됩니다. 가독성을 높이려면 밑줄 사용을 참조하십시오.

특수한 상황들

부동 소수점 리터럴이 선택된 표현에서 표현하기에는 너무 크거나 작은 숫자를 나타내는 경우 컴파일 오류입니다. 즉, 숫자가 + INF 또는 -INF로 오버플로되거나 언더 플로우가 0.0으로 설정됩니다. 그러나 리터럴이 0이 아닌 비정규 화 된 숫자를 나타내는 것은 합법적입니다.

부동 소수점 리터럴 구문은 INF 및 NaN 값과 같은 IEEE 754 특수 값에 대한 리터럴 표현을 제공하지 않습니다. 그것들을 소스 코드로 표현할 필요가 있다면, java.lang.Float 와 java.lang.Double 정의 된 상수를 사용하는 것이 좋습니다. 예를 들어 Float.NaN , Float.NEGATIVE_INFINITY 및 Float.POSITIVE_INFINITY

문자 리터럴

문자 리터럴은 Java 소스 코드에서 char 값을 표현하는 가장 편리한 방법을 제공합니다. 문자 리터럴은 다음으로 구성됩니다.

• 여는 작은 따옴표 ( ' ).
• 문자 표현. 이 표현은 작은 따옴표 또는 줄 바꿈 문자가 될 수 없지만 백 슬래시 ( \ ) 문자에 의해 도입 된 이스케이프 시퀀스 일 수 있습니다. 리터럴의 이스케이프 시퀀스를 참조하십시오.
• 닫는 작은 따옴표 ( ' ).

예 :

char a = 'a';
char doubleQuote = '"';
char singleQuote = '\'';

문자 리터럴의 줄 바꿈은 컴파일 오류입니다.

char newline = '
// Compilation error in previous line
char newLine = '\n';  // Correct