API - String, StringBuffer, StringBuilder
java.lang
ํด๋์ค
์ฉ๋
String
๋ฌธ์์ด์ ์ ์ฅํ๊ณ ์ฌ๋ฌ ๊ฐ์ง ์ ๋ณด๋ฅผ ์ป์ ๋ ์ฌ์ฉ
StringBuffer, StringBuilder
๋ฌธ์์ด์ ์ ์ฅํ๊ณ ๋ด๋ถ ๋ฌธ์์ด์ ์กฐ์ํ ๋ ์ฌ์ฉ
String ํด๋์ค
์๋ฐ์ ๋ฌธ์์ด์ String ํด๋์ค์ ์ธ์คํด์ค๋ก ๊ด๋ฆฐ๋๋ค. String ํด๋์ค์ ๋ค์ํ ์์ฑ์๋ฅผ ์ด์ฉํด์ ์ง์ String๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค.
๋ฆฌํด ํ์
๋ฉ์๋๋ช (๋งค๊ฐ ๋ณ์)
์ค๋ช
char
charAt(int index)
ํน์ ์์น์ ๋ฌธ์ ๋ฆฌํด
boolean
equals(Object anObject)
๋ ๋ฌธ์์ด์ ๋น๊ต
byte[]
getBytes()
byte[]๋ก ๋ฆฌํด
byte[]
getBytes(charset charset)
๋ฌธ์์ด ๋ด์์ ์ฃผ์ด์ง ๋ฌธ์์ด์ ์์น๋ฅผ ๋ฆฌํด
int
length()
์ด ๋ฌธ์์๋ฅผ ๋ฆฌํด
String
replace(CharSequence target, CharSequence replacement)
target๋ถ๋ถ์ replacement๋ก ๋์ฒดํ ์๋ก์ด ๋ฌธ์์ด ๋ฆฌํด
String
substring(int beginIndex)
beginIndex ์์น์์ ๋๊น์ง ์๋ผ๋ธ ์๋ก์ด ๋ฌธ์์ด ๋ฆฌํด
String
substring(int beginIndex, int endIndex)
beginIndex ์์น์์ endIndex๊น์ง ์๋ผ๋ธ ์๋ก์ด ๋ฌธ์์ด ๋ฆฌํด
String
toLowerCase()
์ํ๋ฒณ ์๋ฌธ์๋ก ๋ณํํ ์๋ก์ด ๋ฌธ์์ด ๋ฆฌํด
String
toUpperCase()
์ํ๋ฒณ ๋๋ฌธ์๋ก ๋ณํํ ์๋ก์ด ๋ฌธ์์ด ๋ฆฌํด
String
trim()
์๋ค ๊ณต๋ฐฑ์ ์ ๊ฑฐํ ์๋ก์ด ๋ฌธ์์ด ๋ฆฌํด
String
valueOf(int i) valueOf(double d)
๊ธฐ๋ณธ ํ์ ๊ฐ์ ๋ฌธ์์ด๋ก ๋ฆฌํด
์ฌ์ฉ ๋น๋๊ฐ ๋์ ์์ฑ์
๋คํธ์ํฌ๋ฅผ ํตํด ๋ฐ์ ๋ฐ์ดํฐ๋ ๋ณดํต byte[] ๋ฐฐ์ด์ด๋ฏ๋ก ์ด๊ฒ์ ๋ฌธ์์ด๋ก ๋ณํํ๊ธฐ ์ํด ์ฌ์ฉํ๋ค.
//๋ฐฐ์ด ์ ์ฒด๋ฅผ String ๊ฐ์ฒด๋ก ์์ฑ
String str = new String(byte[] bytes);
//์ง์ ํ ๋ฌธ์์
์ผ๋ก ๋์ฝ๋ฉ
String str = new String(byte[] bytes, String charsetName);
//๋ฐฐ์ด์ offset ์ธ๋ฑ์ค ์์น๋ถํฐ length๋งํผ String ๊ฐ์ฒด ์์ฑ
String str = new String(byte[] bytes,int offset, int length);
// ์ง์ ํ ๋ฌธ์์
์ผ๋ก ๋์ฝ๋ฉ
String str = new String(byte[] bytes, ,int offset, int length,String charsetName);
public static void main(String[] args){
byte[] bytes = {72, 101, 108, 111, 32, 74, 97, 118, 97};
String str1 = new String(bytes);
System.out.println(str1); //=> Hello Java
String str2 = new String(bytes,6,4);
System.out.println(str2); //=>Java
}
ํค๋ณด๋๋ก๋ถํฐ ์
๋ ฅ๋ฐ๋ ๋ฌธ์์ด์๋ ์ํฐํค๋ฅผ ๋๋ ๋ค๋ฉด \r
, \n
์ ์ฝ๋๊ฐ์ด ๋ฐ์ดํธ ๋ฐฐ์ด์ ์ ์ฅ๋๋ค. ์์ด๋ 1byte, ๋ค๋ฅธ ๋๋ผ ์ธ์ด๋ 2byte๋ก ํํ๋๊ธฐ ๋๋ฌธ์ ์
๋ ฅ๋ ๋ฌธ์ ์์ ๋ฐ์ดํธ ์๊ฐ ๋ค๋ฅผ ์ ์๋ค.
public static void main(String[] args){
byte[] bytes = new byte[100];
System.out.println("์
๋ ฅ : ");
int readByteNo = System.in.read(bytes);
String str2 = new String(bytes,0,readByteNo-2);
System.out.println(str2);
}
๋ฌธ์์ถ์ถ(charAt())
๋งค๊ฐ๊ฐ์ผ๋ก ์ฃผ์ด์ง ์ธ๋ฑ์ค์ ๋ฌธ์๋ฅผ ๋ฆฌํดํ๋ค.
String sub = "์๋ฐ ํ๋ก๊ทธ๋๋ฐ";
char charVal = sub.charAt(3);
//=>ํ
๋ฌธ์์ด ๋น๊ต(equals())
String val1 = new String("Java");
String val2 = "java";
va1.equals(val2);
//=>true
๋ฐ์ดํธ ๋ฐฐ์ด๋ก ๋ณํ(getBytes())
๋คํธ์ํฌ๋ก ๋ฌธ์์ด์ ์ ์กํ๊ฑฐ๋, ๋ฌธ์์ด์ ์ํธํํ ๋ ๋ฌธ์์ด์ ๋ฐ์ดํธ ๋ฐฐ์ด๋ก ๋ณํํ๋ค.
byte[] bytes = "๋ฌธ์์ด".getBytes();
์์คํ ์ ๊ธฐ๋ณธ ๋ฌธ์์ ์ผ๋ก ์ธ์ฝ๋ฉ๋ ๋ฐ์ดํธ ๋ฐฐ์ด์ ๋ฆฌํดํ๋ค. ๋ง์ฝ ํน์ ๋ฌธ์์ ์ผ๋ก ์ธ์ฝ๋ฉ๋ ๋ฐ์ดํธ ๋ฐฐ์ด์ ์ป์ผ๋ ค๋ฉด ๋ค์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด๋๋ค.
byte[] bytes = "๋ฌธ์์ด".getBytes(Charset charset);
byte[] bytes = "๋ฌธ์์ด".getBytes("UTF-8");
์ฌ๊ธฐ์ EUC-KR์ ํ๊ธ 2byte, UTF-8์ 3byte๋ก ๋ณํํ๋ค.
์์คํ ๊ธฐ๋ณธ ๋ฌธ์์ ๊ณผ ๋ค๋ฅธ ๋ฌธ์์ ์ผ๋ก ์ธ์ฝ๋ฉ๋ ๋ฐ์ดํธ ๋ฐฐ์ด์ผ ๊ฒฝ์ฐ ๋ค์ String ์์ฑ์๋ฅผ ์ด์ฉํด ๋์ฝ๋ฉ ํ ์ ์๋ค.
String str = new String(byte[] bytes,String charsetName);
getBytes(Charset charset)
๋ฉ์๋๋ ์๋ชป๋ ๋ฌธ์์
์ ๋งค๊ฐ๊ฐ์ผ๋ก ์ค ๊ฒฝ์ฐ UnsupportedEncodingException์์ธ๊ฐ ๋ฐ์ํ๋ฏ๋ก ์์ธ์ฒ๋ฆฌ๊ฐ ํ์ํ๋ค.
try{
byte[] bytes = "๋ฌธ์์ด".getBytes("UTF-8");
}catch(UnsupportedEncodingException e){
e.printStackTrace();
}
๋ฌธ์์ด ์ฐพ๊ธฐ(indexOf())
๋งค๊ฐ๊ฐ์ผ๋ก ์ฃผ์ด์ง ๋ฌธ์์ด์ด ์์๋๋ ์ธ๋ฑ์ค๋ฅผ ๋ฆฌํดํ๋ค. ๋ง์ฝ ์ฃผ์ด์ง ๋ฌธ์์ด์ด ํฌํจ๋์ด ์์ง์์ผ๋ฉด -1์ ๋ฆฌํดํ๋ค.
String sub = "java programming";
int index = sub.indexOf("programming");
//=>5
if(๋ฌธ์์ด.indexOf("์ฐพ๋ ๋ฌธ์์ด")!=-1){
//ํฌํจ๋ ๊ฒฝ์ฐ
}else{
//ํฌํจ๋์ด์์ง์์ ๊ฒฝ์ฐ
}
๋ฌธ์์ด ๊ธธ์ด(length())
๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๋ฆฌํดํ๋ค.
String sub = "java programming";
int length = sub.length();
//=>16
๋ฌธ์์ด ๋์น(replace())
์ฒซ ๋ฒ์งธ ๋งค๊ฐ๊ฐ์ธ ๋ฌธ์์ด์ ์ฐพ์ ๋๋ฒ์งธ ๋งค๊ฐ๊ฐ์ธ ๋ฌธ์์ด๋ก ๋์นํ ์๋ก์ด ๋ฌธ์์ด์ ์์ฑํ๊ณ ๋ฆฌํดํ๋ค.
String old = "ruby programming";
String new = old.replace("ruby","java");
//=>java programming
๋ฌธ์์ด ์๋ผ๋ด๊ธฐ(substring())
์ฃผ์ด์ง ์ธ๋ฑ์ค์์ ๋ฌธ์์ด์ ์ถ์ถํ๋ค.
String old = "java programming";
String first = old.substring(0,4);
//=>java
String seconde = old.substring(5);
์ธ๋ฑ์ค ํฌํจ ๋ฒ์๋ startIndex<= new < endIndex์ด๋ค.
์ํ๋ฒณ ๋์๋ฌธ์ ๋ณ๊ฒฝ(toLowerCase(),toUpperCase())
toLowerCase()๋ ๋ชจ๋ ์๋ฌธ์๋ก ๋ณ๊ฒฝ, toUpperCase()๋ ๋ชจ๋ ๋๋ฌธ์๋ก ๋ณ๊ฒฝํด์ค๋ค.
String str = "Java Programming";
str.toLowercase();
//=>"java programming"
str.toUppercase();
//=>"JAVA PROGRAMMING"
์ด๋ ๋์๋ฌธ์ ๊ด๊ณ์์ด ๊ฐ์์ง ๋น๊ตํด์ฃผ๋ ค๋ฉด equalsIgnoreCase() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
str1.equalsIgnoreCase(str);
๋ฌธ์์ด ์๋ค ๊ณต๋ฐฑ ์๋ผ๋ด๊ธฐ(trim())
๋ฌธ์์ด์ ์๋ค ๊ณต๋ฐฑ์ ์ ๊ฑฐํ ์๋ก์ด ๋ฌธ์์ด์ ์์ฑํ๊ณ ๋ฆฌํดํ๋ค.
String str = " Java Programming ";
str.trim();
//=>"Java Programming"
trim์ ์ฌ์ฉํ๋ค๊ณ ํด์ ์๋ ๋ฌธ์์ด์ ๊ณต๋ฐฑ์ด ์ ๊ฑฐ๋๋ ๊ฒ์ ์๋๋ค.
๋ฌธ์์ด ๋ณํ(valueOf())
๊ธฐ๋ณธ ํ์ ์ ๊ฐ์ ๋ฌธ์์ด๋ก ๋ณํํ๋ ๊ธฐ๋ฅ์ ๊ฐ์ง๊ณ ์๋ค. ๋งค๊ฐ๋ณ์ ํ์ ๋ณ๋ก ์ค๋ฒ๋ก๋ฉ ๋์ด์๋ค.
static String valueOf(boolean b)
static String valueOf(char c)
static String valueOf(int i)
static String valueOf(long l)
static String valueOf(double d)
static String valueOf(float f)
StringBuffer, StringBuilder ํด๋์ค
๋ฌธ์์ด์ ์ ์ฅํ๋ String์ ๋ด๋ถ์ ๋ฌธ์์ด์ ์์ ํ ์ ์๋ค. ์๋ฅผ ๋ค์ด์ String์ replace() ๋ฉ์๋๋ ๋์น๋ ์๋ก์ด ๋ฌธ์์ด์ ๋ฆฌํดํ๋ ๊ฒ์ด์ง ๋ด๋ถ ๋ฌธ์์ด์ ๋์นํ๋ ๊ฒ์ด ์๋๋ค.
+
์ฐ์ฐ์๋ ๋ง์ฐฌ๊ฐ์ง ์ด๋ค.
String str1 = "abc";
str1+="defg";
๋ "abc"๊ฐ์ฒด๋ ๊ทธ๋๋ก ์๊ณ , "abcdefg"์ ์๋ก์ด ๊ฐ์ฒด๊ฐ ์์ฑ๋ ํ ์๋ก ์์ฑ๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๋ค.
๋ฌธ์์ด์ ๊ฒฐํฉํ๋ +
์ฐ์ฐ์๋ฅผ ๋ง์ด ์ฌ์ฉํ๋ฉด ํ ์๋ก ๊ทธ๋งํผ String ๊ฐ์ฒด์ ์๊ฐ ๋์ด๋๊ธฐ ๋๋ฌธ์ ํ๋ก๊ทธ๋จ ์ฑ๋ฅ์ ๋๋ฆฌ๊ฒ ํ๋ ์์ธ์ด ๋๋ค.
๋ฌธ์์ด์ ๋ณ๊ฒฝํ๋ ์์
์ด ๋ง์ ๊ฒฝ์ฐ์๋ String ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค StringBuffer
, StringBuilde
ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค. ์ด ๋ ํด๋์ค๋ ๋ด๋ถ Buffer(:๋ฐ์ดํฐ๋ฅผ ์์๋ก ์ ์ฅํ๋ ๋ฉ๋ชจ๋ฆฌ)์ ๋ฌธ์์ด์ ์ ์ฅํด๋๊ณ , ๊ทธ ์์์ ์ถ๊ฐ, ์์ , ์ญ์ ์์
์ ํ ์ ์๋๋ก ์ค๊ณ๋์ด ์๋ค. ์ฆ, String์ฒ๋ผ ์๋ก์ด ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ง ์๊ณ ๋ ๋ฌธ์์ด์ ์กฐ์ํ ์ ์๋ ๊ฒ์ด๋ค.
๋ ํด๋์ค์ ์ฌ์ฉ๋ฐฉ๋ฒ์ ๋์ผํ๋ ์ฐจ์ด์ ์ StringBuffer๋ ๋ฉํฐ ์ค๋ ๋ ํ๊ฒฝ์์ ์ฌ์ฉํ ์ ์๋๋ก ๋๊ธฐํ๊ฐ ์ ์ฉ๋์ด ์์ด ๋ฉํฐ ์ค๋ ๋์ ์์ (thread-safe)ํ์ง๋ง, StringBuilder ๋ ๋จ์ผ ์ค๋ ๋ ํ๊ฒฝ์์๋ง ์ฌ์ฉํ๋๋ก ์ค๊ณ๋์ด ์๋ค.
StringBuilder
// 16๊ฐ ๋ฌธ์๋ค์ ์ ์ฅํ ์ ์๋ ์ด๊ธฐ๋ฒํผ
StringBuilder sb = new StringBuilder();
//์ฃผ์ด์ง ๊ฐ์๋งํผ ๋ฌธ์๋ค์ ์ ์ฅํ ์ ์๋ ์ด๊ธฐ ๋ฒํผ
StringBuilder sb = new StringBuilder(16);
// ์ฃผ์ด์ง str๋งค๊ฐ๊ฐ์ ๋ฒํผ์ ์ด๊ธฐ๊ฐ์ผ๋ก ์ ์ฅ
StringBuilder sb = new StringBuilder("Java");
๋ฒํผ๊ฐ ๋ถ์กฑํ ๊ฒฝ์ฐ ์๋์ผ๋ก ๋ฒํผ ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๊ธฐ ๋๋ฌธ์ ์ด๊ธฐ ๋ฒํผ์ ํฌ๊ธฐ๋ ๊ทธ๋ค์ง ์ค์ํ์ง ์๋ค.
๋ฉ์๋
์ค๋ช
append(...)
๋ฌธ์์ด ๋์ ์ฃผ์ด์ง ๋งค๊ฐ๊ฐ์ ์ถ๊ฐ
insert(...)
๋ฌธ์์ด ์ค๊ฐ์ ์ฃผ์ด์ง ๋งค๊ฐ๊ฐ ์ถ๊ฐ
delete(int start,int end)
๋ฌธ์์ด์ ์ผ๋ถ๋ถ ์ญ์
deleteCharAt(int index)
๋ฌธ์์ด์์ ์ฃผ์ด์ง index์ ๋ฌธ์๋ฅผ ์ญ์
replace(int start, int end, String str)
๋ฌธ์์ด์ ์ผ๋ถ๋ถ์ ๋ค๋ฅธ ๋ฌธ์์ด๋ก ๋์น
StringBuilder reverse()
๋ฌธ์์ด์ ์์๋ฅผ ๋ค๋ฐ๊ฟ
setCharAt(int index, char ch)
๋ฌธ์์ด์์ ์ฃผ์ด์ง index์ ๋ฌธ์๋ฅผ ๋ค๋ฅธ ๋ฌธ์๋ก ๋์น
append์ insert ๋ฉ์๋๋ ๋งค๊ฐ๋ณ์๊ฐ ๋ค์ํ ํ์ ์ผ๋ก ์ค๋ฒ๋ก๋ฉ ๋์ด ์์ผ๋ฏ๋ก ๋๋ถ๋ถ ๊ฐ์ ๋ฌธ์๋ก ์ถ๊ฐ, ์ฝ์ ํ ์ ์๋ค.
StringBuilder sb = new StringBuilder();
sb.append("JAVA ");
sb.append("Programming");
// ๋ฒํผ์ ์๋ ๊ฒ์ Stringํ์
์ผ๋ก ๋ฆฌํด
sb.toString();
sb.insert(4,"2");
//=>JAVA2 Programming
sb.setCharAt(4,'6');
//=>JAVA6 Programming
sb.replace(6,17,"Book");
//=>JAVA6 Book
sb.delete(4,5);
//=>JAVA Book
StringBuffer
StringBuffer stringBuffer = new StringBuffer();
StringBuilder stringBuilder = new StringBuilder();
new Thread(() -> {
for(int i=0; i<10000; i++) {
stringBuffer.append(i);
stringBuilder.append(i);
}
}).start();
new Thread(() -> {
for(int i=0; i<10000; i++) {
stringBuffer.append(i);
stringBuilder.append(i);
}
}).start();
new Thread(() -> {
try {
Thread.sleep(5000);
System.out.println("StringBuffer.length: "+ stringBuffer.length());
System.out.println("StringBuilder.length: "+ stringBuilder.length());
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
StringBuffer.length: 77780
StringBuilder.length: 76412
StringBuilder์ StringBuffer์ ๊ฒฐ๊ณผ ๊ฐ์ด ๋ค๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค. ์ด๋ thread๋ค์ด ๋์์ StringBuilder ํด๋์ค์ ์ ๊ทผํ ์ ์์ด ๋ ์์ ์๊ฐ ๋์จ ๊ฒ์ด๋ค. String Buffer๋ multi-thread ํ๊ฒฝ์์ ๋ค๋ฅธ ๊ฐ์ ๋ณ๊ฒฝํ์ง ๋ชปํ๋๋ก ๋๊ธฐํ(Synchronization)๋์ด์๋ค.
๊ทธ๋ฌ๋ฏ๋ก Web์ด๋ Socket๊ณผ ๊ฐ์ด ๋น๋๊ธฐ๋ก ๋์ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์๋๋ StringBuffer๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์์ ํ๋ค.
์ฐธ์กฐ ๋ฌธ์
Last updated
Was this helpful?