ํฐ์คํ ๋ฆฌ ๋ทฐ
[ JAVA ] String ํด๋์ค์ StringBuffer ์ StringBuilder ํด๋์ค ์ฐจ์ดโ๏ธ
Kithub 2023. 2. 21. 00:51โ๏ธ String๊ณผ StringBuffer, StringBuilder ๋ฌด์์ด ๋ค๋ฅธ๊ฑธ๊น
๊ฒฐ๋ก ๋ถํฐ ์ด์ผ๊ธฐํ๋ฉด ํ๋ฒ ์์ฑ๋ ๋ฌธ์์ด์ ๋ํด์ String ํด๋์ค๋ ๋ณ๊ฒฝ๋ถ๊ฐ๋ฅํ๊ณ , StringBuffer ํน์ StringBuilder ํด๋์ค๋ ๋ณ๊ฒฝ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ด๋ค.
String ํด๋์ค
- ๊ฐ์ฒด(new ํค์๋)๋ก ์ ์ธํ ๋ฌธ์์ด์ ํ๋์ ์ธ์คํด์ค๊ฐ ๋๋ค.
- ํ๋ฒ ์์ฑ๋ String ์ธ์คํด์ค๋ ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํ ๋ถ๊ฐ๋ณ ๋ฌธ์์ด์ด๋ค.
- ๋ฆฌํฐ๋ด๋ฐฉ์(๋ฐ์ดํ)์ ๊ฐ์ ๋ฌธ์์ด์ผ ๊ฒฝ์ฐ ํ๋์ ์ธ์คํด์ค๋ฅผ ์ฐธ์กฐํ๋ค.
- ์ฌ๋ฌ ๋ณ์๋ค์ ๋ฆฌํฐ๋ด ๋ฌธ์์ด์ด ๋์ผํ๋ค๋ฉด ํ๋์ ์ธ์คํด์ค๋ง ์ฐธ์กฐํ๊ฒ ๋๋ค.
์๋ ์ฝ๋๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๊ตฌ์กฐ๋ฅผ ๋ณด๋ฉฐ ์ข ๋ ์์ธํ ์ด์ผ๊ธฐ ํด๋ณด์.
String str1 = "a";
String str2 = "a";
String str3 = new String("a");
String str4 = new String("a");
์ฝ๋์ ๋ฉ๋ชจ๋ฆฌ๊ตฌ์กฐ๋ฅผ ์๊ฐํํด๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๋ํ๋ผ์ ์์๊ฒ์ด๋ค.

์ ๊ทธ๋ฆผ์์๋ ๋ฌธ์์ด์ด ์์ฑ๋ ๋๋ง๋ค heap area์์ญ์ ์ธ์คํด์ค๊ฐ ์์ฑ๋จ์ ์ ์ ์๋ค. ์ด๋ ์ฃผ๋ชฉํด์ผํ ๊ฒ์ str1๊ณผ str2์ด๋ค. str3๊ณผ str4๋ ๋ฌธ์์ด์ด ์ ์๋ ๋๋ง๋ค ์๋ก์ด ์ธ์คํด์ค๋ฅผ ์์ฑํ๊ณ ์๋ ๊ฒ์ ๋ณผ ์ ์๋ค. ํ์ง๋ง str1,str2๋ ํ๋์ ์ธ์คํด์ค๋ง์ ๊ณต์ ํ๊ณ ์๋ค. ์ด๊ฒ์ด ์์์ ์ธ๊ธํ String์ ํน์ง์ธ " ๋ฆฌํฐ๋ด๋ฐฉ์์ ๊ฐ์ ๋ฌธ์์ด์ผ ๊ฒฝ์ฐ ์ธ์คํด์ค๋ฅผ ๊ณต์ ํ๋ค" ์ด๋ค. jvm์ ๊ธฐ๋ณธ์ ์ผ๋ก String Constant Pool์ ํ์ธํ์ฌ, ํด๋น ์ธ์คํด์ค๊ฐ ์กด์ฌํ๋ฉด ์๋ก์ด ์ธ์คํด์ค๋ฅผ ์์ฑํ์ง ์๊ณ , ๊ฐ์ ์ธ์คํด์ค์ ์ฐธ์กฐ๊ฐ์ ๋ฆฌํดํ๋ค๊ณ ํ๋ค.
Here the JVM checks the String Constant Pool. If the string does not exist then a new string instance is created and placed in the pool if the string exists then it will not create a new object rather it will return the reference to the same instance
๊ทธ๋ ๋ค๋ฉด ์ด์ ab ๋ฌธ์์ด์ ๋ง๋ค์ด๋ณด๋๋ก ํด๋ณด์. ๊ทธ๋ฌ๋ฉด ๋ฉ๋ชจ๋ฆฌ์ ๋ชจ์ต์ ๋ค์๊ณผ ๊ฐ์ด ๋ํ๋ผ ์ ์๋ค.

str3๋ ์๋ก์ด ab ์ธ์คํด์ค๊ฐ ์์ฑ๋ ๊ฒ์ ๋ณผ ์ ์์ผ๋ฉฐ, str2_1์ ๊ฒฝ์ฐ ab์ ๋ฌธ์์ด์ด String Contant Pool์ ์์ฑ๋ ๊ฒ์ ์ ์ ์๋ค. ์ด์ฒ๋ผ String์ ๋ด์ฉ์ด ๋ณ๊ฒฝ๋ ๋๋ง๋ค ๋ฉ๋ชจ๋ฆฌ์ ์๋ก์ด ์ธ์คํด์ค๊ฐ ์์ฑ๋๊ณ ์ ์ฌ๋๋ค. ์ด๋ฅผ ๋ค๋ฅด๊ฒ ์ด์ผ๊ธฐ ํ๋ฉด String ํด๋์ค๋ ๋ด์ฉ์ ๋ณํ๊ฐ ์์ฃผ ๋ฐ์ํ๋ค๋ฉด ๋ฉ๋ชจ๋ฆฌ๊ด๋ฆฌ ์ธก๋ฉด์์ ๋ถ์ ์ ํ ๋ฐฉ๋ฒ์ผ ์ ์๋ค๋ ๊ฒ์ด๋ค. ๊ทธ๋์ ์ด๋ฅผ ๋ณด์ํ๊ธฐ ์ํด ๋์จ๊ฒ์ด StringBuffer, StringBuilder ํด๋์ค์ด๋ค.
StringBuffer ์ StringBuilder ํด๋์ค
- String ํด๋์ค์ ๋ค๋ฅด๊ฒ ๋ฌธ์์ด์ ๋ด์ฉ์ ๋ณ๊ฒฝ ํ ์ ์๋ ๊ฐ๋ณ ๋ฌธ์์ด์ด๋ค.
- StringBuffer๋ ๋ฉํฐ์ฐ๋ ๋ ํ๊ฒฝ์ ๋ง์ถ์ด ๋๊ธฐํ๊ฐ ๊ฐ๋ฅํ๋ ์ด๋ ์ฑ๋ฅ์ ์ ํ์ํค๋ ์์ธ์ด ๋๊ธฐ๋ ํ๋ค.
- StringBuilder๋ StringBuffer๊ฐ ๊ฐ์ถ๊ณ ์๋ ๋๊ธฐํ๋ฅผ ์ ๊ฑฐํ ํด๋์ค์ด๋ค.(๋ฉํฐ์ฐ๋ ๋ ํ๊ฒฝ์ด ์๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค.)
- ์ด ๋ ํด๋์ค๋ ๋ฉ์๋์ ์ฌ์ฉ๋ฒ ๋ชจ๋ ๋์ผํ๋ค.
- String ํด๋์ค์ ๋น๊ตํ์๋ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ณด์ฌ์ค๋ค. ์๋ ๊ทธ๋ฆผ์ฒ๋ผ stringBuilder์ ์ฐ์ํ ์ฑ๋ฅ์ ๋ณด์ฌ์ฃผ๊ณ ์๋ค.

โ๏ธ StringBuffer์ StringBuilder๋ ์ด๋ป๊ฒ ๋์ํ๋
์์์ String ํด๋์ค์ ๊ฒฝ์ฐ ์ง์์ ์ผ๋ก ๋ณ๊ฒฝ์ด ์ด๋ฃจ์ด์ง ๊ฒฝ์ฐ ์๋ง์ ์ธ์คํด์ค๊ฐ ์์ฑ๋๊ณ GC์ ๋ฉ๋ชจ๋ฆฌ์ ๋ง์ ๋ถํ๋ฅผ ์ค ์์์์ ์ ์ ์์๋ค. ๊ทธ๋์ ์ฐ๋ฆฌ๋ SB ํด๋์ค(์ดํ StringBuffer, StringBuilder)๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฌํ ๋ฌธ์ ์ ์ ๋ฐฉ์ง ํ ์ ์์ ๊ฒ์ด๋ค. SBํด๋์ค๋ ๋์ผํ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค. ๊ทธ ์ค ๊ธฐ๋ณธ์ ์ผ๋ก ์ฌ์ฉ๋๋ ๊ฒ์ append() ๋ฉ์๋๋ฅผ ํตํ ๋ฌธ์์ด์ ๋ค๋ฃจ๋ ๊ฒ์ด๋ค.
StringBuffer sb = new StringBuffer();
sb.append("kithub");
sb.append("stringBuffer");
StringBuilder sb2 = new StringBuilder();
sb2.append("kithub");
sb2.append("stringBuilder");
System.out.println(sb.toString() + " / "+ sb2.toString());
์ค์ ๋ก ๋ฉ๋ชจ๋ฆฌ ์ธก๋ฉด์์ SBํด๋์ค๋ ํ๋์ ์ธ์คํด์ค ์ฃผ์๋ฅผ ๊ณ์ํด์ ์ฐธ์กฐํ๊ณ , ๋ฌธ์์ด์ ๋ด์ฉ์ ๋ณ๊ฒฝ ํ๋๊ฒ์ ํ์ธ ํ ์ ์๋ค.

๊ทธ๋ ๋ค๋ฉด ์ด๋ฐํ์๊ฐ ์ด๋ป๊ฒ ๊ฐ๋ฅํ ๊ฒ์ผ๊น ? ์ค์ append์ ๋ฉ์๋๋ฅผ ์ดํด๋ณด๋ฉด ๋ค์ ์ฝ๋๋ฅผ ํ์ธ ํ ์ ์๋ค.
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = value.length >> coder;
int newCapacity = (oldCapacity << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
return (newCapacity <= 0 || SAFE_BOUND - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
๋ฌธ์์ด์ ๊ธธ์ด์ ๋ฐ๋ผ ์ธ์คํด์ค์ ๋ถ์ฌ๋ ์ฌ์ด์ฆ๋ฅผ ์๋กญ๊ฒ ๊ตฌ์ฑํ๊ณ ์์์ ์ ์ ์๋ค. ์ฆ, String ํด๋์ค๋ ์ธ์คํด์ค๊ฐ ์์ฑ๋ ๋ ์ฌ์ด์ฆ๊ฐ ์ ํด์ ธ ์๋๋ฐ๋ฉด, SB ํด๋์ค๋ ๋ฌธ์์ด์ ํฌ๊ธฐ๊ฐ ๋ณ๊ฒฝ ๋ ๋๋ง๋ค ๊ธฐ์กด ์ธ์คํด์ค์ ๋ฆฌ์ฌ์ด์ง์ ์ํํ๋ค๋ ์๋ฏธ๊ฐ ๋๋ค. ๊ทธ๋์ ์ฐ๋ฆฌ๋ SBํด๋์ค๊ฐ ๊ฐ๋ณ์ฑ์ ์ง๋๋ค๊ณ ์ด์ผ๊ธฐ ํ๋ ๊ฒ์ด๋ค.
โ ๋ฌด์กฐ๊ฑด StringBuffer๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์๊น
๊ทธ๊ฑด ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅด๋ค. StringBuffer ์๋ฃํ์ String ์๋ฃํ๋ณด๋ค ๋ฌด๊ฑฐ์ด ํธ์ ์ํ๋ค. new StringBuffer() ๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ๊ฒ์ ์ผ๋ฐ String์ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋๋ ๋ง๊ณ ์๋๋ ๋๋ฆฌ๋ค. ๋ฐ๋ผ์ ๋ฌธ์์ด ์ถ๊ฐ๋ ๋ณ๊ฒฝ ๋ฑ์ ์์ ์ด ๋ง์ ๊ฒฝ์ฐ์๋ SBํด๋์ค๋ฅผ , ๋ฌธ์์ด ๋ณ๊ฒฝ ์์ ์ด ๊ฑฐ์ ์๋ ๊ฒฝ์ฐ์๋ String ํด๋์ค๋ฅผ ํ์ฉํ๋๊ฒ์ด ์ข์ ๊ฒ์ด๋ค.
โ๏ธ๊ฒฐ๋ก
์๋น์ค์ ๊ด๋ จํด ์์ฒญ/์๋ต์ ๋ํด ๋ง์ ์์ ๋ฌธ์์ด์ Stirng์ผ๋ก ๋ถ์์์ฑ์ ํ๊ณ ์๋ค๋ฉด, StirngBuilder ํน์ StringBuffer๋ฅผ ํตํด ์ฑ๋ฅ๊ฐ์ ์ ์๋ํด๋ณด๋ ๊ฒ์ด ์ข์๋ฏ ํ๋ค.
โ๏ธ += ์ฐ์ฐ์๋ String Constatnt Pool์ ์์ฑ๋์ง ์๋๋ค.
String str1 = "kithub";
String str2 = "kithub";
System.out.println("์ฃผ์๊ฐ ๊ฐ์ > "+(str1==str2));
String str3 = "kit";
str3+="hub";
String str4 = "kithub";
System.out.println("์ฃผ์๊ฐ ๋ค๋ฆ > "+(str3==str4));
===========================================
์ฃผ์๊ฐ ๊ฐ์ > true
์ฃผ์๊ฐ ๋ค๋ฆ > false
'โ Programming > โ JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ JAVA ] ์๋ฐ์ ์ถ์ํด๋์ค( abstract class )์ ์ถ์๋ฉ์๋(abstract method ) (3) | 2023.02.14 |
---|---|
[ Jsoup ] ์์๋๋ฉด ์ข์ Jsoup ๋์ฒ๋ฒ (1) | 2020.11.30 |
[JAVA] ์ฐ๋ ๋(Thread)๋ (1) | 2019.04.08 |