์ถ์ฒ
ChatGPT
๋ค์ด๋ฒ์ฌ์
Literal์ ์์ด ์๋ฏธ
Literal์ '์์' ์ ๋๋ก ์๊ฐํ๋ฉด ๋ ๋ฏํ๋ค.
๋ฌธ์์ด ๋ฆฌํฐ๋ด String Literal
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์ฝ๋ ๋ด์ ์ง์ ์์ฑ๋ ๋ฌธ์์ด ๊ฐ์ ๋งํ๋ค. ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ฝ๋์์ ๊ณ ์ ๋ ๊ฐ์ผ๋ก ์ทจ๊ธ๋๋ฉฐ, ์ฃผ๋ก ํฐ๋ฐ์ดํ("")๋ก ๋๋ฌ์ธ์ฌ ์๋ค. ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ํ๋ก๊ทธ๋จ ์คํ ์ค ๋ณํ์ง ์๋ ์์ ๊ฐ์ผ๋ก ์ทจ๊ธ๋๋ค.
ํน์ง
๋ถ๋ณ์ฑ
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์ผ๋ฐ์ ์ผ๋ก ๋ถํธ(immutable)์ด๋ค. ์ฆ, ํ ๋ฒ ์์ฑ๋๋ฉด ๋ณ๊ฒฝํ ์ ์๋ค. ๋ง์ฝ ๋ฌธ์์ด์ ์์ ํ๊ณ ์ถ๋ค๋ฉด, ์๋ก์ด ๋ฌธ์์ด์ ์์ฑํด์ผ ํ๋ค.
๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ
์๋ฐ์์๋ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์คํธ๋ง ํ(String Pool)์ด๋ผ๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ์ฅํ๋ค. ๋์ผํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ด ์ฌ๋ฌ ๋ฒ ์ฌ์ฉ๋๋ฉด, ์๋ฐ๋ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ์ ์ํด ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์ฌ์ฌ์ฉํ๋ค.
๊ณ ์ ๋ ๊ฐ
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ํ๋ก๊ทธ๋จ ์ฝ๋์ ๋ช ์์ ์ผ๋ก ์์ฑ๋์ด ์๋ ๊ฐ์ผ๋ก, ์คํ ์์ ์ ๋ณ๊ฒฝํ ์ ์๋ค.
์์
public class StringLiteralExample {
public static void main(String[] args) {
// ๊ฐ๋จํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด
String hello = "Hello, World!";
// ์ ๋์ฝ๋ ์ด์ค์ผ์ดํ๋ฅผ ํฌํจํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด
String unicodeString = "This is a unicode snowman: \u2603";
// ์ฌ๋ฌ ์ค ๋ฌธ์์ด ๋ฆฌํฐ๋ด (Java 13+)
String multiLine = """
This is a multi-line
string literal
in Java.
""";
// ํน์ ๋ฌธ์๋ฅผ ํฌํจํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด
String specialChars = "This string contains a tab\tand a newline\n";
// ์ถ๋ ฅ
System.out.println(hello);
System.out.println(unicodeString);
System.out.println(multiLine);
System.out.println(specialChars);
}
}
์ถ๋ ฅ
Hello, World!
This is a unicode snowman: โ
This is a multi-line
string literal
in Java.
This string contains a tab and a newline
๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ : ์คํธ๋ง ํ (String Pool)
์๋ฐ์์ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์คํธ๋ง ํ(String Pool)์ด๋ผ ๋ถ๋ฆฌ๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ์ฅ๋๋ค. ์ด ์์ญ์ JVM์ ์ํด ๊ด๋ฆฌ๋๋ฉฐ, ๋์ผํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ด ์ฌ๋ฌ ๋ฒ ์์ฑ๋๋๋ผ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ฝํ๊ธฐ ์ํด ๋์ผํ ๊ฐ์ฒด๋ฅผ ์ฌ์ฌ์ฉํ๋ค.
์๋ฅผ ๋ค์ด, ๋ ๊ฐ์ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ด ๋์ผ ๋ด์ฉ์ ๊ฐ์ง๊ณ ์๋ค๋ฉด, ์๋ฐ๋ ํ๋์ ๊ฐ์ฒด๋ง ์์ฑํ๊ณ ์ด๋ฅผ ์ฌ์ฌ์ฉํ๋ค. ์ด๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ์ต์ ํํ๊ณ ํ๋ก๊ทธ๋จ์ ์ฑ๋ฅ์ ํฅ์์ํจ๋ค.
public class StringPoolExample {
public static void main(String[] args) {
// ๋ ๋ฌธ์์ด ๋ฆฌํฐ๋ด ์ ์ธ
String str1 = "Hello";
String str2 = "Hello";
// ์ฐธ์กฐ ๋น๊ต
if (str1 == str2) {
System.out.println("str1 and str2 refer to the same object in the string pool.");
} else {
System.out.println("str1 and str2 refer to different objects.");
}
}
}
์ถ๋ ฅ
str1 and str2 refer to the same object in the string pool.
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ๋ถ๋ณ์ฑ
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ๋ถ๋ณ์ด๋ค. ์ฆ, ํ ๋ฒ ์์ฑ๋๋ฉด ๋ณ๊ฒฝํ ์ ์๋ค. ๋ฌธ์์ด์ ์์ ํ๋ ์์ ์ ์๋ก์ด ๋ฌธ์์ด์ ์์ฑํ๋ ๊ฒ์ผ๋ก ์ฒ๋ฆฌ๋๋ค. ์ด๋ ๋ถ๋ณ ๊ฐ์ฒด์ ํน์ฑ์ผ๋ก ์ธํด ์ค๋ ๋ ์์ ์ฑ์ ์ ๊ณตํ๊ณ , ํด์ ์ฝ๋ ์บ์ฑ ๋ฐ ๊ธฐํ ์ต์ ํ๋ฅผ ๊ฐ๋ฅํ๊ฒ ํ๋ค.
public class StringImmutabilityExample {
public static void main(String[] args) {
String original = "Java";
String modified = original.concat(" Programming");
// ์ถ๋ ฅ
System.out.println("Original: " + original);
System.out.println("Modified: " + modified);
}
}
์ถ๋ ฅ
Original: Java
Modified: Java Programming
์ ์ฝ๋์์ 'original' ๋ฌธ์์ด์ ๋ณ๊ฒฝ๋์ง ์๊ณ , 'modified' ๋ผ๋ ์๋ก์ด ๋ฌธ์์ด์ด ์์ฑ๋๋ค.
ํน์ ๋ฌธ์๋ฅผ ํฌํจํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด
๋ฌธ์์ด ๋ฆฌํฐ๋ด์๋ ์ด์ค์ผ์ดํ ์ํ์ค๋ฅผ ์ฌ์ฉํด ํน์ ๋ฌธ์๋ฅผ ํฌํจํ ์ ์๋ค.
- \n : ์ ์ค(new line)
- \t : ํญ(tab)
- \\ : ๋ฐฑ์ฌ๋์(backslash)
- \" : ํฐ๋ฐ์ดํ(double quote)
- \' : ์์๋ฐ์ดํ(single quote)
์์ ์ฝ๋
public class SpecialCharExample {
public static void main(String[] args) {
String text = "First line\nSecond line\tIndented";
System.out.println(text);
}
}
์ถ๋ ฅ
First line
Second line Indented
๊ฒฐ๋ก
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ์๋ฐ ๋ฐ ๋ค๋ฅธ ๋ง์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๊ณ ์ ๋ ๋ฌธ์์ด ๊ฐ์ ํํํ๋ ์ค์ํ ๋ฐฉ์์ด๋ค. ์ด๋ฌํ ๋ฆฌํฐ๋ด์ ๋ถ๋ณ์ฑ์ ๊ฐ์ง๋ฉฐ, ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ์ ๋์ด๊ธฐ ์ํด ์คํธ๋ง ํ์ ํตํด ๊ด๋ฆฌ๋๋ค. ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ํ์ฉํ๋ฉด ํ๋ก๊ทธ๋จ ์ฝ๋ ๋ด์์ ์ง์ ์ ์ผ๋ก ๋ฌธ์์ด ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ณ , ๋ค์ํ ํ์์ ํ ์คํธ๋ฅผ ํํํ ์ ์๋ค.
'๋น ๊ตฌ๋ฉ ์ฑ์ฐ๊ธฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ๋ฌธ์๋ฅผ ์ ์ํ์ผ๋ก ํํํ ๋, '\u' ๋ค์ 16์ง์๊ฐ ๋์์ผ ํ๋ ์ด์ (0) | 2024.08.06 |
---|---|
[์ฉ์ด] ๊ตญ์ ํ(i18n)๋ฐ ์ง์ญํ(l19n) (0) | 2024.08.06 |
[Java] float ์ double ๋ฐ์ดํฐ ํ์ ์ด ์ ํ์ฑ์ ๋ณด์ฅํ ์ ์๋ ์ด์ (0) | 2024.08.05 |
[์ฉ์ด] ์ค๋ฒํ๋ก์ฐ(Overflow), ์ธ๋ํ๋ก์ฐ(Underflow) (0) | 2024.08.02 |
[์ฉ์ด] CPU ์ํคํ ์ฒ (2) | 2024.08.02 |