๐ ๋ฌธ์์ด String
๐ฏ String์ด๋?
String์ ๋ฌธ์์ ์งํฉ์ ํํํ๋ ์ฐธ์กฐํ(๊ฐ์ฒดํ) ๋ฐ์ดํฐ ํ์ ์ ๋๋ค.
โ ๏ธ ์ฃผ์: ๋ฌธ์ ํ๋(char)์ ๋ฌธ์์ด(String)์ ๋ค๋ฆ ๋๋ค!
char letter = 'A'; // ๋ฌธ์ ํ๋
String word = "Apple"; // ๋ฌธ์์ด (๊ฐ์ฒด)
๐ฎ String ๊ฐ์ฒด์ ํน์ง
๊ตฌ๋ถ | ์ค๋ช |
---|---|
๋ถ๋ณ์ฑ(Immutable) | ํ ๋ฒ ๋ง๋ค์ด์ง ๋ฌธ์์ด์ ์์ ํ ์ ์๋ค. |
๋ฉ๋ชจ๋ฆฌ ์ต์ ํ | ๋์ผํ ๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ณต์ ํ๋ค. |
์ฐธ์กฐํ ๋ฐ์ดํฐ | ๊ธฐ๋ณธํ์ด ์๋๋ผ ๊ฐ์ฒด ๋ก ๊ด๋ฆฌ๋๋ค. |
โ๏ธ String ํด๋์ค์ ๊ตฌ์กฐ
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
private final char[] value; // (Java 8 ์ดํ)
// Java 9 ์ด์์ byte[] value๋ฅผ ์ฌ์ฉ (๋ฉ๋ชจ๋ฆฌ ์ต์ ํ)
}
final
: ์์ ๋ถ๊ฐ!private final value
: ๋ฌธ์์ด ๋ด์ฉ์ ์ง์ ์์ ํ ์ ์์.
๐ผ ๋ฌธ์์ด ์์ฑ ๋ฐฉ๋ฒ ์ด์ ๋ฆฌ
// ๋ฆฌํฐ๋ด
String book = "Java";
// new ํค์๋
String subject = new String("OOP");
// ๋ฌธ์ ๋ฐฐ์ด๋ก ์์ฑ
char[] letters = { 'C', 'o', 'd', 'e' };
String code = new String(letters);
๐ ์ String์ '๋ถ๋ณ(Immutable)'ํ๊ฒ ์ค๊ณํ์๊น?
1. ๋ณด์(Security)
โถ๏ธ ๋คํธ์ํฌ ์ฐ๊ฒฐ ์ฃผ์(URL), ํ์ผ ๊ฒฝ๋ก(Path) ๊ฐ์ ๋ฏผ๊ฐํ ๋ฌธ์์ด์ด ๋ณ์กฐ๋๋ฉด ์ํํ๋๊น!
2. ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ ์์ ์ฑ(Thread Safety)
โถ๏ธ ๋ถ๋ณ ๊ฐ์ฒด๋ ์ฌ๋ฌ ์ค๋ ๋์์ ๋์์ ์ ๊ทผํด๋ ์์ ํฉ๋๋ค.
3. ์บ์ฑ ๋ฐ ์ต์ ํ ๊ฐ๋ฅ์ฑ
โถ๏ธ ๊ฐ์ ๋ฌธ์์ด์ ๋ฉ๋ชจ๋ฆฌ์์ ์ฌ์ฌ์ฉํ ์ ์์ด ์ฑ๋ฅ์ด ์ฌ๋ผ๊ฐ๋๋ค.
4. Hash ๊ธฐ๋ฐ ์๋ฃ๊ตฌ์กฐ์์์ ์ ๋ขฐ์ฑ
โถ๏ธHashMap
, HashSet
๊ฐ์ ๊ณณ์์ String์ ํค(key)๋ก ์ฌ์ฉํ ๋,
๊ฐ์ด ๋ณํ๋ฉด ํด์์ฝ๋๋ ๋ณํด๋ฒ๋ฆฌ๊ธฐ ๋๋ฌธ์ ๋ณ๊ฒฝ ๋ถ๊ฐํด์ผ ์ ๋ขฐํ ์ ์์ต๋๋ค.
๐ก ๋ฌธ์์ด ํ (String Constant Pool)์ด๋?
๋ฌธ์์ด ๋ฆฌํฐ๋ด์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๊ธฐ ์ํ ๊ณต์ฉ ์ ์ฅ์์ ๋๋ค.
"Hello"
๊ฐ์ ๋ฆฌํฐ๋ด์ ๋ง๋ค๋ฉด, ๋ฌธ์์ด ํ์ ์ ์ฅ๋ฉ๋๋ค.- ๊ฐ์ ๋ด์ฉ์ด ์์ผ๋ฉด ์๋ก ๋ง๋ค์ง ์๊ณ ๊ธฐ์กด ๊ฐ์ฒด ์ฐธ์กฐ๋ง ํฉ๋๋ค.
String cat1 = "meow";
String cat2 = "meow";
System.out.println(cat1 == cat2); // true (๊ฐ์ ๊ฐ์ฒด ์ฐธ์กฐ)
โ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น ๋ฐฉ์ง!
โ ์๋ ์ต์ ํ!
๐ก new String() vs ๋ฆฌํฐ๋ด ์์ฑ ์ฐจ์ด
๋ฐฉ์ | ํน์ง |
---|---|
"Hello" | ๋ฌธ์์ด ํ์ ์ ์ฅ. ๊ธฐ์กด์ ์์ผ๋ฉด ์ฌ์ฌ์ฉ. |
new String("Hello") | Heap ๋ฉ๋ชจ๋ฆฌ์ ์๋ก์ด ์ธ์คํด์ค ์์ฑ. ํ์ ์ ์ฅ ์ ํจ. |
String a = "hi";
String b = new String("hi");
System.out.println(a == b); // false (๋ค๋ฅธ ๊ฐ์ฒด)
๐ง intern() ๋ฉ์๋๋?
ํ(Heap)์ ์๋ String์ ๋ฌธ์์ด ํ(String Constant Pool)๋ก ์ด๋์ํค๋ ๋ฉ์๋.
String heapStr = new String("welcome");
String pooledStr = heapStr.intern();
System.out.println(pooledStr == "welcome"); // true
- ์ด๋ฏธ ํ์ ์์ผ๋ฉด ๊ทธ ์ฐธ์กฐ ๋ฐํ
- ์์ผ๋ฉด ํ์ ์๋ก ์ ์ฅ
๐ ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ + == ๋น๊ต ๊ฐ๋ฅ์ฑ ์ฆ๊ฐ
๐งฉ String ์ฃผ์ ๋ฉ์๋ ์์ฝ
๋ฉ์๋ | ์ค๋ช |
---|---|
length() | ๋ฌธ์์ด ๊ธธ์ด ๋ฐํ |
charAt(int index) | ํน์ ์์น ๋ฌธ์ ๋ฐํ |
substring(start, end) | ๋ถ๋ถ ๋ฌธ์์ด ์ถ์ถ |
equals(Object obj) | ๋ฌธ์์ด ๋ด์ฉ ๋น๊ต |
equalsIgnoreCase(String other) | ๋์๋ฌธ์ ๋ฌด์ํ๊ณ ๋น๊ต |
indexOf(String s) | ํน์ ๋ฌธ์์ด ์์น ์ฐพ๊ธฐ |
toUpperCase() / toLowerCase() | ๋์๋ฌธ์ ๋ณํ |
trim() | ์๋ค ๊ณต๋ฐฑ ์ ๊ฑฐ |
replace(old, new) | ๋ฌธ์์ด ์นํ |
โ ๏ธ String์ ์ฌ์ฉํ ๋ ์ฃผ์ํ ์
๋น๊ตํ ๋๋ ==(์ฐธ์กฐ) ๋ง๊ณ equals() ์ฌ์ฉ!
String a = "apple";
String b = new String("apple");
System.out.println(a == b); // false (์ฐธ์กฐ ์ฃผ์ ๋น๊ต)
System.out.println(a.equals(b)); // true (๊ฐ ๋น๊ต)
์์ฃผ ๋ณ๊ฒฝ๋๋ ๋ฌธ์์ด์ด๋ผ๋ฉด String ๋์ StringBuilder
๋ฅผ ๊ณ ๋ คํ์ธ์.
๐ ์์ฝ
String์ ์์ ํ๊ณ ํธ๋ฆฌํ์ง๋ง, ๋ฌด์กฐ๊ฑด ์ ๊ฐ์ฒด๋ฅผ ๋ง๋๋ ๊ฑด ์๋๋ค!
ํจ์จ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ์์ ์ฑ ๋๋ถ์ ์๋ฐ ํ๋ก๊ทธ๋จ ๊ณณ๊ณณ์ ์ฌ์ฉ๋๋ค.
๐ ์ถ๊ฐ๋ก ๊ณต๋ถํ๋ฉด ์ข์ ์ฃผ์
- String + StringBuilder ๋น๊ต
- String์ ํด์์ฝ๋(HashCode)์ equals()์ ๊ด๊ณ
- ๋ฌธ์์ด ํฌ๋งทํ (String.format())
'Programming languages > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋คํ์ฑ(Polymorphism)์ด ๋ญ๊ฐ์? (0) | 2025.04.30 |
---|---|
StringBuilder Vs StringBuffer (0) | 2025.04.29 |
Java์ ๋ฐ๋ณต๋ฌธ๊ณผ ํ๋ฆ ์ ์ด ํค์๋! (0) | 2025.04.23 |
์๋ฐ์ ๋ฐฐ์ด(Array) (0) | 2025.04.22 |
์ ๊ทผ ์ ์ด์ (0) | 2025.04.17 |