0. ํ์ต ๋ชฉ์
- String์ ๋ถ๋ณ ๊ฐ์ฒด์์ ์ดํดํ๋ค.
- ์ ์ฉํ String ํด๋์ค ํจ์๋ฅผ ์์๋ฌ์ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ ๋ ์ ์ฉํ๋ค.
1. String์ ํน์ง : ๋ถ๋ณ์ฑ
String ๊ฐ์ฒด์ ๊ฐ์ฅ ํฐ ํน์ง์ ๋ถ๋ณ์ฑ์ด ๋ณด์ฅ ๋๋ ๊ฐ์ฒด ๋ผ๋ ๊ฒ์ด๋ค.
(1) final ํด๋์ค๋ก ์ ์ธ๋จ
final ํด๋์ค๋ก ์ ์ธ๋์ด ์์ด์ ์์์ด ๋ถ๊ฐ๋ฅํ๋ค.
(2) ๊ฐ์ ๋ด๋ ๋ฉค๋ฒ ๋ณ์๋ private final ์
String ๋ฌธ์์ด์ ์ค์ง์ ๊ฐ์ ๋ด๋ byte ๋ฐฐ์ด๋ private final๋ก ์ ์ธ๋์ด ์๋ค. ์ด ๋๋ฌธ์, String ๊ฐ์ฒด๊ฐ ํ ๋ฒ ์ ์ธ๋๋ฉด, ์ดํ ์๋ก์ด ๊ฐ์ ์ฌํ ๋น ํ ์ ์๋ค.
(3) ๊ทธ๋ ๋ค๋ฉด ๋ฌธ์์ด ๋ณ๊ฒฝ ์ฝ๋๋ ํจ์๋ ์ด๋ป๊ฒ ์๋ํ ๊น?
์๋์ String ๊ฐ์ฒด์ ๊ฐ์ด ์ถ๊ฐ๋๋ ๊ฒ์ด ์๋๋ผ, ์๋ก์ด String ๊ฐ์ฒด๊ฐ ๋ง๋ค์ด์ง๋ค. ๊ธฐ์กด์ ๋ณ์๋ ์๋ก์ด String ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๊ฐ์ฒด ์ฃผ์๋ฅผ ๋ฐ๊พผ๋ค.
String str1 = "HELLO";
str1 += "WORLD";
์ด ๊ฒฝ์ฐ ๊ธฐ์กด "HELLO" ๊ฐ์ฒด์ "WORLD" ๊ฐ ์ถ๊ฐ๋๋ ๊ฒ์ด ์๋๋ผ, "HELLO WORLD" ๋ผ๋ ์๋ก์ด ๊ฐ์ฒด๊ฐ ๋ง๋ค์ด์ง๊ณ , str1์ ํด๋น ์๋ก์ด ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ค.
์ด๋ ๋ฌธ์์ด์ ๋ํ ๋ณ๊ฒฝ์ ๊ฐํ๋ String ๋ด๋ถ ํจ์ ๋ชจ๋์๊ฒ ์ ์ฉ๋๋ค. (์ฆ subString()
, replace()
ํจ์ ๋ชจ๋ ์๋์ ๊ฐ์ฒด์ ๋ณ๊ฒฝ์ด ๊ฐํด์ง๋ ๊ฒ์ด ์๋๋ผ, ์๋ ค์ง ๋ฌธ์์ด ๊ฐ์ฒด ํน์ ๋์ฒด ๋จ์ด๊ฐ ๋ค์ด๊ฐ ๋ฌธ์์ด ๊ฐ์ฒด๋ฅผ ์๋กญ๊ฒ ๋ง๋ค์ด ๋ฐํํ๋ ๊ฒ์ด๋ค.)
2. String์ ์ด๋ป๊ฒ ์ ์ฅ๋ ๊น?
Java 8 ๋ฒ์ ๊น์ง๋ ๋ฌธ์์ด์ String ๊ฐ์ฒด ๋ด๋ถ์ ์ผ๋ก char [] ๋ฐฐ์ด๋ก ์ ์ฅํ์ง๋ง, Java9 ๋ถํฐ๋ byte[]
๋ฐฐ์ด๋ก ์ ์ฅํ๋ค.
๋ฌธ์์ด์ byte [] ๋ฐฐ์ด๋ก ๋ณํํ์ฌ ์ ์ฅํ๊ณ , ํธ์ถ ์ ๋ค์ ๋ฌธ์์ด๋ก ๋ณํํ์ฌ ์ ์กํ๋ ๋งค์ปค๋์ฆ ์ดํด๋ฅผ ์ํด์๋ ๋ค์ ํต์ฌ ํ๋๋ค์ ๋ํ ์ดํด๊ฐ ํ์ํ๋ค.
@Stable
private final byte[] value; // ๋ฌธ์ ์ ์ฅ์ ์ํ ๋ฐ์ดํธ ๋ฐฐ์ด
private final byte coder; // ์ธ์ฝ๋ฉ ๋ฐฉ์ ์๋ณ์
(1) coder
๋ฌธ์์ด์ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ธ์ฝ๋ฉํ์ฌ byte ๋ฐฐ์ด๋ก ๋ง๋ค๊ฑด์ง๋ฅผ ์๋ณํ๋ ๋ณ์์ด๋ค.
coder = 0
:LATIN1
๋ฐฉ์์ ํ์ฉํด ๋ฌธ์๋ค์ ์ ์ฅ ํ๊ฒ ๋ค๋ ๋ง์ด๋ค.
LATIN1๋ฐฉ์์ ๋ฌธ์์ด์ ์ฐ์ธ ๋ชจ๋ ๋ฌธ์๊ฐ ์ ๋์ฝ๋ ์ 0 ~ 255 ๋ฒ์ ์ ์ผ ๋, (์ฆ ์ซ์์ ์์ด, ๊ธฐ๋ณธ ๋ฌธ์๋ก ํํ ๊ฐ๋ฅ ์ผ ๋) ์ฌ์ฉ ํ ์ ์๋ ๋ฐฉ์์ผ๋ก, char์ ํ์ 8 bit๋ฅผ 1byte๋กbyte [] value
์ ์ ์ฅํ๋ค. ๋ฐ๋ผ์ ๋ชจ๋ ๋ฌธ์๋ฅผ 1byte ๋จ์๋ก value ๋ฐฐ์ด์ ์ ์ฅํ๋ค.coder = 1
:UTF16
๋ฐฉ์์ ํ์ฉํด ๋ฌธ์๋ค์ ์ ์ฅ ํ๊ฒ ๋ค๋ ๋ง์ด๋ค.
UTF16 ๋ฐฉ์์ 0~255 ์ด์ธ์ ์ ๋์ฝ๋ ๋ฌธ์ ํฌํจ ์ ์ฌ์ฉํ๋ ๋ฐฉ์์ผ๋ก 2byte ๋น 1 ๊ฐ์ ๋ฌธ์๋ค. ์ฆ LATIN1 ๋ฐฉ์๋ณด๋ค byte ๋ฐฐ์ด์ด 2๋ฐฐ ๋ ํ์ํ๊ฒ ๋๋ค.
(2) ๋ฌธ์์ด <-> byte [] ๋ฐฐ์ด ๋งค์ปค๋์ฆ
- ๋ฌธ์์ด ๊ฐ์ฒด ์์ฑ ์
- ๋ฌธ์์ด์ ์ค์บํ์ฌ ๋ชจ๋ ๋ฌธ์๊ฐ ์ ๋์ฝ๋ ์ 0~255๋ฒ ์ฌ์ด์ ๋ฌธ์๋ก ํํ ๊ฐ๋ฅํ์ง ํ์ธํ๋ค.
- ๋๋ฉด LATIN1 ๋ฐฉ์์ผ๋ก 1byte = 1 ๋ฌธ์ ๋จ์๋ก byte ๋ฐฐ์ด์ ์ ์ฅ. ์๋๋ฉด 2byte = 1๋ฌธ์ ๋จ์๋ก byte ๋ฐฐ์ด์ ์ ์ฅ
- ๋ฌธ์์ด ๊ฐ์ฒด์์ ๋ฌธ์์ด ๊ฐ์ฒด๋ฅผ ๋ฐํํ ์
- ์์ ๊ณผ์ ๊ณผ ๋๊ฐ์ด ์งํ๋๋ค. (๊ฐ์ฒด์ coder ํ์ธ => ๊ทธ๊ฒ์ ๋ง๊ฒ byte => ๋ฌธ์๋ก ๋ณํ ๋ค ํฉ์น๊ธฐ)
3. String์ ์ ์ฅ ์์น
String์ String Constant Pool ์ด๋ผ๋ ๊ณณ์ ์ ์ฅ๋๋ค.
์์ธํ ์ค๋ช
์ ํด๋น ๊ธ์์ ๋ ์์ธํ ํ๊ฒ ๋ค.
4. ๋ถ๋ถ ๋ฌธ์์ด์ ์์น ์ฐพ๊ธฐ
(1) A.indexOf(B)
A๋ผ๋ ๋ฌธ์์ด์ 0๋ฒ index๋ถํฐ ์์ฐจ์ ์ผ๋ก ํ์ธํ์ ๋, B๋ผ๋ ๋ฌธ์์ด์ด ๋์ค๋ ์ฒซ ์์น
๋ฅผ ๋ฐํํ๋ค.
๋ง์ฝ์ A๋ผ๋ ๋ฌธ์์ด ๋ด์ B๋ผ๋ ๋ฌธ์์ด์ด ์๋ค๋ฉด -1
์ ๋ฐํํ๋ค.
String str = "Hello World";
int index = str.indexOf("World"); // index == 6;
int index2 = str.indexOf("o"); // index2 == 4;
(2) A.lastIndexOf(B)
A๋ผ๋ ๋ฌธ์์ด ๋ด์์ B๋ผ๋ ๋ฌธ์์ด์ด ๋์ค๋ ๋ง์ง๋ง ์์น
๋ฅผ ๋ฐํํ๋ค.
B๊ฐ A ๋ด๋ถ์ ์์ผ๋ฉด -1
๋ฐํ
String str = "Hello World";
int index = str.lastIndexOf("o"); // index == 7
5. ๋ฌธ์์ด ๋๋๊ธฐ
(1) A.subString()
A์ ๋ถ๋ถ ๋ฌธ์์ด ๋ถ๋ฆฌ ํ ๋ฐํ
๊ฐ. A.subString(int a)
A๋ผ๋ ๋ฌธ์์ด์ a๋ถํฐ ๋ง์ง๋ง๊น์ง๋ฅผ ์๋ผ์ ๋ฐํํ๋ค.
String str = "Hello World";
String sub1 = str.substring(6); // "World"
๋. A.subString(int a, int b)
A๋ผ๋ ๋ฌธ์์ด์ a๋ถํฐ b-1๊น์ง ์๋ผ์ ๋ฐํํ๋ค.
String str = "Hello World";
String sub2 = str.substring(0, 5); // "Hello"
(2) A.split(B)
A๋ผ๋ ๋ฌธ์์ด์ B๋ผ๋ ๋ฌธ์์ด์ ๊ธฐ์ค์ผ๋ก ์ ๋ถ ๋๋๋ค. (B๋ผ๋ ๋ฌธ์์ด์ ๋ถํ ์์ ๋ฏธ ํฌํจ๋จ.)
String str = "apple,banana,orange";
String[] arr = str.split(","); // ["apple", "banana", "orange"]
ํน์ง์ ๋ค์๊ณผ ๊ฐ๋ค.
- ๋ฉ์ด๋ฆฌ ๊ตฌ๋ถ์๊ฐ ๊ฐ๋ฅํ๋ค. -> ๋๊ฐ์ ๋ฌธ์์ด ๋ถ๋ฆฌ๊ฐ ๊ฐ๋ฅํ ๊ฐ์ฒด์ธ StringTokenzier์์ ์ฐจ์ด์ ์ด๋ค.
- ์ธ์๋ก ์ ๊ท ํํ์์ ์ธ ์ ์๋ค.
(1) ๋ฉ์ด๋ฆฌ ๊ตฌ๋ถ์๊ฐ ๊ฐ๋ฅ
StringTokenizer๋ delim์ด ๋๋ ๋ฌธ์์ด์ ๋ฉ์ด๋ฆฌ ์ฑ๋ก ๋ถํ ํ ์ ์์ง๋ง, String.split์ ๊ฐ๋ฅํ๋ค.
String str = "apple<div>banana<div>orange"
String [] arr = str.split("<div>"); // ["apple", "banana", "orange"];
StringTokenizer st = new StringTokenizer(str, "<div>", false); // "<", "d", "i", "v", ">" ๋ชจ๋๊ฐ ๊ตฌ๋ถ์๊ฐ ๋์ด์ ์ชผ๊ฐ์ ธ์ ๋์จ๋ค.
str.split("<div>")
์ ๊ฒฝ์ฐ <div>
์์ฒด๊ฐ ๊ตฌ๋ถ์๊ฐ ๋์ด ๋ฌธ์์ด์ ๋๋๋ค. ํ์ง๋ง StringTokenzier(str, "<div>", false)
๋ ๋ ๋ฒ์งธ ์ธ์์ธ delim ๋ฌธ์์ด์ ๋ฌธ์ ํ๋ ํ๋๊ฐ ๊ตฌ๋ถ์๊ฐ ๋๊ธฐ ๋๋ฌธ์ <
, d
, i
, v
, >
๋ง๋ ๋๋ง๋ค ๋ชจ๋ ์๋ ค์ ๋์จ๋ค.
6. ๋ฌธ์์ด ๋์ฒด
(1) A.replace(String a, String b)
A๋ผ๋ ๋ฌธ์์ด์์ ๋ง๋ ๋ชจ๋ ๋ฌธ์์ด a๋ฅผ ๋ฌธ์์ด b๋ก ๊ต์ฒดํด์ค๋ค.
String str = "Hello World Hello World";
String replaced = str.replace("World", "Java"); // "Hello Java Hello Java"
(2) A.replaceAll(String a, String b)
replace()
ํจ์์ ๋๊ฐ์ง๋ง ์ฐจ์ด์ ์ ๋ฌธ์์ด a๋ถ๋ถ์ ์ ๊ท ํํ์์ ์ธ ์ ์๋ค๋ ๊ฒ์ด๋ค.
String html = "<p>Hello <b>World</b></p>";
String cleaned = html.replaceAll("<[^>]*>", ""); // "Hello World"
7. ๋ฌธ์์ด ๋น๊ต
(1) A.equals(B)
A์ B๊ฐ ๊ฐ์์ง ๋น๊ต. ๊ฐ์ผ๋ฉด true, ์๋๋ฉด false
(2) A.equalsIgnoreCase(B)
A์ B๊ฐ ๋์๋ฌธ์ ๊ด๊ณ์์ด ๊ฐ์์ง ๋น๊ต. ๊ฐ์ผ๋ฉด true, ์๋๋ฉด false
(3) A.startWith(B)
, A.endWith(B)
- A๊ฐ B๋ก ์์ํ๋ฉด true, ์๋๋ฉด false
- A๊ฐ B๋ก ๋๋๋ฉด true, ์๋๋ฉด false
(4) A.contains(B)
A๊ฐ B๋ฅผ ํฌํจํ๋ฉด true, ์๋๋ฉด false
8. ๊ณต๋ฐฑ ์ ๊ฑฐ
(1) A.trim()
A ๋ฌธ์์ด์ ์ ๋ค ๊ณต๋ฐฑ ์ ๊ฑฐ
String str = " Hello World ";
String trimmed = str.trim(); // "Hello World"
๋ถ๋ก
A. ๋ชจ๋ฅด๋ ๋จ์ด ์ ๋ฆฌ
throughout
: … ๋ด๋ด, … ๋์
He was widely known throughout his whole career.
(๊ทธ๋ ๊ทธ์ ์ ์ฒด ์ปค๋ฆฌ์ด ๋ด๋ด ๋๋ฆฌ ์๋ ค์ ธ ์์๋ค.)reside
: ์ด๋ค. ๊ฑฐ์ฃผํ๋ค.