16-1.String

16-1-1.생성자

String 클래스는 문자열을 표현한다. 참조형이지만 컴파일러의 특별한 지원에 의해 기본형처럼 사용할 수 있다. 사용법이 굉장히 쉬운 편이지만 메모리 관리 방식이 독특하여 특성을 잘 파악하고 주의사항을 숙지해야 성능 저하없이 안전하게 쓸 수 있다.

생성자는 무려 15개나 있는데 디폴트 생성자, 복사 생성자는 물론이고 문자나 바이트 배열로부터 생성할 수 있고 배열의 일부만을 취할 수도 있다. 모든 생성자를 다 알 필요는 없으니 자주 사용하는 몇 가지만 구경해 보고 나머지는 필요할 때 레퍼런스를 참고하자.

String()

String(byte[] bytes)

String(char[] value)

String(String original)

String(StringBuffer builder)

취하는 인수를 보면 어떤 식으로 초기화하는지 알 수 있다. 단순히 문자열 리터럴을 대입하는 방식으로도 초기화할 수 있어 생성자를 사용하는 경우는 흔하지 않다. 문자 배열을 문자열로 바꾸거나 유니코드가 아닌 인코딩 방식의 문자열을 읽어들일 때 정도만 생성자가 사용된다. 다음은 String 객체를 생성하는 몇 가지 방법이다.

stringctor	실행결과
class JavaTest { public static void main(String[] args) { String str = new String("아름다운"); System.out.println(str); String str2 = "우리나라"; System.out.println(str2); char[] ar = { 'k', 'o', 'r', 'e', 'a' }; String str3 = new String(ar); System.out.println(str3); System.out.println("대한민국".length()); } }	아름다운 우리나라 korea 4

String 객체를 생성하는 원론적인 방법은 new 연산자로 생성자를 호출하는 것이며 인수로 초기화에 사용할 문자열 리터럴을 전달한다. 다른 객체를 생성 및 할당하는 방법과 같으며 str 문자열을 이 방법으로 생성했다.

사용 빈도가 높아 리터럴을 대입하는 간편한 방법을 허용하며 주로 이 방법을 많이 쓴다. str2 문자열은 "우리나라" 리터럴을 = 기호 다음에 대입하여 초기화했다. 생성자로 문자의 배열을 전달하면 문자 요소로 구성된 문자열이 생성된다. str3은 문자의 집합인 ar 배열의 다섯 글자를 모아 korea라는 문자열로 초기화된다.

문자열 리터럴도 String 객체로 취급되므로 String의 모든 메서드를 호출할 수 있다. "대한민국"이라는 리터럴에 대해 length() 메서드를 호출하면 리터럴의 길이인 4가 리턴된다. String 클래스의 문자열 관련 메서드를 하나씩 연구해 보자. 다음 메서드는 문자열의 기본적인 정보를 조사한다.

int length()

boolean isEmpty()

char charAt(int index)

length 메서드는 문자열의 길이를 조사한다. 유니코드 문자의 개수를 조사하며 한글도 하나의 문자로 취급된다. isEmpty는 문자열이 비어 있는지 조사한다. if (str.length() == 0) 조건으로 길이가 0인지 보면 되지만 isEmpty는 비어 있는지만 점검하기 때문에 훨씬 빠르다.

charAt은 index 위치의 문자 하나를 조사한다. index는 항상 0부터 시작하며 첫 번째 문자가 0번이고 마지막 문자는 문자열의 길이보다 하나 더 작다. index 인수는 0 ~ length()-1 범위 안에 있어야 한다.

stringlength	실행결과
class JavaTest { public static void main(String[] args) { String str = "아름다운 우리나라"; System.out.println("길이 : " + str.length()); System.out.println("2번째 문자 : " + str.charAt(2)); } }	길이 : 9 2번째 문자 : 다

문자열 변수를 하나 선언하고 length 메서드로 길이를 조사했다. 한글만 보면 여덟 글자로 보이지만 가운데 공백도 하나의 문자여서 총 9 글자이다. charAt 메서드로 2번째 문자를 조사했다. 우리가 흔히 쓰는 서수 표현인 첫 번째, 두 번째는 1을 기점으로 하지만 1번째, 2번째라는 표현은 0을 기점으로 하는 것이 관행이다.

자바에서 배열이나 문자열의 시작은 항상 0부터(Zero Base)이므로 2번째 문자는 "름"이 아닌 "다"임을 유의하자.

16-1-2.비교

다음 메서드는 두 문자열을 비교한다. 대소문자 구분 여부에 따라 상등, 대소를 비교하는 4개의 메서드가 제공된다. 내용이 아닌 참조만 점검하는 == 연산자로는 정확히 비교할 수 없으며 <, > 부등 비교는 수치형에만 쓸 수 있다. 문자열의 내용을 비교할 때는 연산자 대신 메서드를 사용한다.

boolean equals(Object anObject)

boolean equalsIgnoreCase(String anotherString)

int compareTo(String anotherString)

int compareToIgnoreCase(String str)

equals 메서드는 두 문자열이 같은지 비교하며 compareTo 메서드는 어떤 문자열이 더 앞쪽인지 조사한다. 이름 뒤에 IgnoreCase가 붙은 메서드는 대소문자를 구분하지 않는다.

strcompare

실행결과

class JavaTest { public static void main(String[] args) { String str1 = "KOREA"; String str2 = "korea"; System.out.println(str1.equals(str2) ? "같다":"다르다"); System.out.println(str1.equalsIgnoreCase(str2) ? "같다":"다르다"); String apple = "Apple"; String orange = "Orange"; int Result = apple.compareTo(orange); if (Result == 0) { System.out.println("같다"); } else if (Result < 0) { System.out.println("Apple이 더 앞쪽"); } else if (Result > 0) { System.out.println("Apple이 더 뒤쪽"); } } }

다르다 같다 Apple이 더 앞쪽

str1과 str2 문자열은 내용이 같고 대소문자 구성만 다르다. equals는 철자가 같아도 대소문자 구성에 따라 다른 문자열로 평가한다. 반면 equalsIgnoreCase는 철자만 같으면 같은 문자열로 평가한다. 영문은 대소문자 구분 여부에 따라 정확한 메서드로 비교해야 한다. 한글은 대소문자의 개념이 없어 equals로 평이하게 비교하면 된다.

compareTo는 사전순으로 정렬할 때의 전후 관계를 조사하며 정수형을 리턴한다. 두 문자열이 같으면 0을, 호출 문자열이 더 앞쪽이면 음수, 호출 문자열이 더 뒤쪽이면 양수를 리턴한다. Apple과 Orange를 대소 비교하면 알파벳 순서가 빠른 Apple이 더 앞쪽이다.

문자의 대소 비교는 곧 문자 코드의 크고 작음을 의미한다. 단어를 사전순으로 나열했을 때 더 앞쪽에 오는 문자가 작은 것으로 평가된다. compareToIgnoreCase는 대소문자 구분을 무시하고 사전순으로 비교한다. 제품 코드나 사람 이름 등은 사용자가 대소문자에 신경쓰지 않고 입력하는 경우가 많아 대소문자를 무시하고 비교하는 것이 좋다.

16-1-3.검색

검색 메서드는 문자열에서 문자 하나 또는 부분 문자열을 검색한다. 앞쪽이나 뒤쪽의 시작 방향에 따라 검색 메서드를 선택하며 두 번째 옵션 인수로 검색 시작 위치를 지정한다. 시작 위치를 생략하면 처음부터 또는 끝에서부터 검색을 시작한다. 검색된 위치를 리턴하되 발견되지 않으면 -1을 리턴한다.

int indexOf(int ch [,int fromIndex])

int lastIndexOf(int ch [,int fromIndex])

int indexOf(String str [,int fromIndex])

int lastIndexOf(String str [,int fromIndex])

indexof	실행결과
class JavaTest { public static void main(String[] args) { String str = "String Search Method of String Class"; System.out.println("앞쪽 t = " + str.indexOf('t')); System.out.println("뒤쪽 t = " + str.lastIndexOf('t')); System.out.println("앞쪽 z = " + str.indexOf('z')); System.out.println("앞쪽 String = " + str.indexOf("String")); System.out.println("뒤쪽 String = " + str.lastIndexOf("String")); } }	앞쪽 t = 1 뒤쪽 t = 25 앞쪽 z = -1 앞쪽 String = 0 뒤쪽 String = 24

긴 영문 문장에서 알파벳과 부분 문자열을 여러 가지 방법으로 검색해 보았다. 알파벳 t는 여러 번 나타나는데 앞에서 찾으면 앞쪽의 t가 조사되고 뒤에서 찾으면 뒤쪽의 t가 조사된다. 알파벳 z는 없어 -1을 리턴한다.

뒤쪽에서부터 찾더라도 리턴되는 검색 위치는 항상 앞에서부터의 순서값이다. 뒤쪽에서 t를 찾으면 뒤쪽에서 10번째가 아닌 앞쪽에서 25번째로 리턴된다. 부분 문자열 String의 위치도 앞에서 찾는가 뒤에서 찾는가에 따라 검색 위치가 달라진다. 다음 두 메서드는 문자열의 앞부분과 뒷부분이 특정 문자열인지 조사하여 진위형 값을 리턴한다.

boolean startsWith(String prefix)

boolean endsWith(String suffix)

indexOf나 lastIndexOf로 부분 문자열을 검색해서 처음이나 끝이 맞는지 확인할 수도 있지만 이 메서드는 진위형을 리턴하므로 조건문에 바로 사용할 수 있어 간편하다.

startswith	실행결과
class JavaTest { public static void main(String[] args) { String[] files = { "girl.jpg", "boy.png", "child.avi", "school.jpg", "book.gif" }; for (String s : files) { if (s.endsWith(".jpg")) { System.out.println(s); } } } }	girl.jpg school.jpg

다섯 개의 파일 중 확장자가 .jpg 인 파일만 골라낸다. 배열을 순회하며 각 문자열에 대해 endsWith 메서드로 끝부분이 ".jpg"인지 조사해 보면 된다. startsWith 메서드로 문자열 앞부분을 점검하면 사람 이름 목록에서 성이 "김"가인 사람만 추출해낼 수 있다.

16-1-4.변경

문자열 변경 메서드는 문자열을 조작하여 내용을 변경한다. 다음과 같은 메서드가 있는데 어떤 변경을 가하는지 메서드 이름으로부터 쉽게 알 수 있다.

메서드	설명
String toLowerCase()	영문자를 모두 소문자로 변경한다. 대소문자 규칙은 디폴트 로케일을 따른다. 로케일을 별도의 인수로 지정할 수도 있다.
String toUpperCase()	영문자를 모두 대문자로 변경한다.
String trim()	앞뒤의 불필요한 공백을 제거한다.
String concat(String str)	문자열을 연결한다.
String replace(char oldChar, char newChar)	문자열 내의 모든 oldChar 문자를 newChar로 치환한다.
String replace(CharSequence target, CharSequence replacement)	부분 문자열을 찾아 다른 문자열로 치환한다.
String replaceFirst(String regex, String replacement)	처음 검색되는 부분 문자열을 치환한다.
String replaceAll(String regex, String replacement)	부분 문자열을 모두 찾아 치환한다. 검색 문자열은 정규 표현식이다.

변경 메서드는 문자열 자체를 직접 변경하는 것이 아니라 변경된 새로운 문자열을 리턴한다는 점을 유의하자. 대표적으로 가장 쉬운 대소문자 변환 메서드를 테스트해 보자.

changecase	실행결과
class JavaTest { public static void main(String[] args) { String str = "Kim Sang Hyung"; System.out.println(str.toLowerCase()); System.out.println(str.toUpperCase()); // 문자열 자체를 변경하는 것은 아니다. str.toUpperCase(); System.out.println(str); // 문자열을 변경하려면 다시 대입받아야 한다. str = str.toUpperCase(); System.out.println(str); } }	kim sang hyung KIM SANG HYUNG Kim Sang Hyung KIM SANG HYUNG

대소문자가 섞여 있는 str 문자열을 각각 소문자와 대문자로 바꾸어 출력했다. 모두 소문자로 바뀌거나 모두 대문자로 바뀌어 출력된다. 여기까지만 보면 아주 쉬워 보인다. 주의할 것은 toUpperCase 메서드는 문자열 자체를 대문자로 변경하는 것이 아니라 원본은 그대로 두고 대문자로 구성된 새로운 문자열을 리턴한다는 것이다.

str에 대해 toUpperCase 메서드를 호출한다고 해서 str이 모두 대문자로 바뀌는 것은 아니며 원래의 내용을 유지한다. str 자체는 그대로 두고 str의 내용을 읽어 대문자로 구성된 새 문자열을 만들어 리턴할 뿐이다. 세 번째 출력 결과를 보면 str은 전혀 변경되지 않았다. 만약 str 자체를 대문자로 바꾸고 싶다면 변경된 결과를 자신이 다시 대입받는다.

str = str.toUpperCase();

이렇게 하면 str로부터 대문자로 변경한 새 문자열을 str이 다시 대입받아 참조하는 문자열이 바뀐다. 자바의 String 객체는 최초 생성된 후 내용이 절대 바뀌지 않는다. 즉, 자바의 String 객체는 최초 초기화된 후 항상 읽기 전용이다. 다음 코드를 보자.

String str = "Java";

str = "자바";

str을 "Java"로 초기화한 후 "자바"를 대입했다. str의 내용이 바뀌는 것 같지만 그렇지 않으며 str 변수가 참조하는 문자열이 바뀌는 것이다. str은 어디까지나 문자열을 가리키는 참조 변수일 뿐이며 대상 문자열이 변경되는 것이 아니라 새로운 문자열을 가리키는 것이다.

참조 변수가 가리키지 않는 문자열 객체는 더 이상 쓸모가 없어 가비지 컬렉터에 의해 제거된다. 모든 문자열 변경 메서드는 호출 객체는 그대로 두고 변경된 결과를 새 문자열 객체로 만들어 리턴한다.

trim 메서드는 앞뒤의 불필요한 공백을 제거한다. 사용자가 입력한 문자열은 의미없는 공백이 있는 경우가 많은데 저장이나 비교 전에 제거하는 것이 좋다. concat 메서드는 문자열을 연결하는데 + 연산자를 사용하는 것과 효과가 같다.

trim	실행결과
class JavaTest { public static void main(String[] args) { String str = " Kim Sang Hyung "; System.out.println(str.trim()); System.out.println(str.trim().concat(" BABO")); } }	Kim Sang Hyung Kim Sang Hyung BABO

앞뒤로 공백이 있는 문자열을 trim으로 정리했으며 concat으로 뒤에 문자열을 덧붙였다. 대부분의 문자열 메서드는 변경된 String을 리턴하므로 메서드를 연쇄적으로 호출할 수 있다. trim이 리턴한 객체에 대해 concat을 바로 호출하여 잘라낸 문자열 뒤에 또 뭔가를 덧붙였다. concat도 String을 리턴하므로 다른 문자열 처리 메서드를 연쇄적으로 호출할 수 있다.

str.trim().concat(....).toUpperCase().replace (....)

replace* 메서드는 문자나 문자열을 찾아 내용을 치환한다. 원래 문자열과 치환되는 문자열의 길이가 달라도 상관없다.

replace
class JavaTest { public static void main(String[] args) { String str = "독도는 일본땅이다. 대마도는 일본땅이다."; System.out.println(str.replace("일본", "한국")); System.out.println(str.replaceFirst("일본", "한국")); } }
실행결과	독도는 한국땅이다. 대마도는 한국땅이다. 독도는 한국땅이다. 대마도는 일본땅이다.

replace 메서드는 모든 문자열을 찾아 변경하며 replaceFirst는 첫 번째 문자열만 변경한다. replaceFirst와 replaceAll 메서드는 인수로 정규식을 사용하여 더 복잡한 치환을 처리할 수 있다. 다음 메서드는 문자열의 일부를 잘라 새로운 문자열 객체를 만든다.

String substring(int beginIndex [, int endIndex])

시작점에서 끝점 바로 직전까지 추출하며 끝점을 생략하면 끝까지 추출한다. 끝점 자체는 부분 문자열에 포함되지 않음을 유의하자.

substring	실행결과
class JavaTest { public static void main(String[] args) { String str = "0123456789"; System.out.println(str.substring(3,7)); String name = "제 이름은 <김한결>입니다."; int st, ed; st = name.indexOf('<'); ed = name.indexOf('>'); System.out.println(name.substring(st+1,ed)); } }	3456 김한결

0~9의 숫자를 가진 문자열에서 3에서 7까지 추출했다. 3은 포함되지만 7은 포함되지 않는다. 아래쪽 코드는 문자열에서 < > 괄호 안의 내용을 추출한다. < 와 >의 위치를 찾아 부분 문자열을 추출하되 < 자체는 내용에 포함되지 않아 시작점보다 한 칸 더 뒤쪽에서 추출을 시작한다. >는 추출 대상이 아니므로 >의 위치를 끝점으로 전달하면 > 이전의 문자까지 정확하게 추출된다.

문자열은 참조형이면서 기본형과 유사한 특성을 보인다. 참조형 변수는 사본이 원본과 같은 대상을 가리킬 때 사본을 변경하면 원본도 같이 변경되지만 문자열은 예외적으로 동작한다. 다음 예제를 보자.

strassign	실행결과
class JavaTest { public static void main(String[] args) { String s = "korea"; String s2 = s; s2 += " fighting"; System.out.println("s = " + s); System.out.println("s2 = " + s2); } }	s = korea s2 = korea fighting

s2를 s의 사본으로 초기화하고 s2에 문자열을 덧붙였다. 원본인 s도 바뀔 거 같지만 s2만 바뀌며 원본은 영향을 받지 않는다. 이렇게 되는 이유는 문자열은 읽기 전용이며 변경할 때 별도의 사본을 생성하기 때문이다. 최초 s2가 s를 대입받을 때는 같은 문자열을 가리키지만 내용이 바뀌면 새로운 객체를 생성하도록 되어 있어 원본인 s는 영향을 받지 않는다.

이런 특성에 의해 문자열은 참조형이면서도 기본형처럼 사용할 수 있다. 문자열 필드에 대해 깊은 복사를 하지 않아도 변경 직전에 새로운 메모리가 할당되는 식이라 깊은 복사를 한 것과 같은 효과가 나타난다.

16-1-5.토큰 분할

문자열은 길이 제한이 없고 특별한 형식없이 임의의 정보를 표기할 수 있어 범용적이다. 한 문자열에 여러 가지 정보를 통합 저장하는데 이때 각 자료 사이에 구분자 기호가 삽입된다. 예를 들어 디렉터리 경로 문자열을 보자.

user/data/app/local

최종 디렉터리에 이르는 경로 정보를 표현하며 각 디렉터리 사이에 / 구분자가 있다. 구분자로 구분된 부분 문자열을 토큰이라고 한다. 경로 문자열은 디렉터리 이름이 토큰이다. 다음 메서드는 통합 문자열에서 토큰을 분리한다.

String[] split(String regex, [int limit])

첫 번째 인수 regex는 구분자를 표현하는 정규 표현식이며 간단하게 구분자 문자라고 생각하면 된다. 두 번째 인수 limit는 전체 문자열을 몇 개의 토큰으로 나눌 것인가를 지정하는데 생략시 0이 적용되어 모든 토큰을 추출한다. limit를 지정하면 이 개수만큼만 추출하며 나머지 뒤쪽은 모두 하나로 합친다. 추출된 토큰은 문자열의 배열로 리턴된다.

split	실행결과
class JavaTest { public static void main(String[] args) { String city = "서울,대전,대구,부산"; String[] token = city.split(","); for (String s : token) { System.out.println(s); } } }	서울 대전 대구 부산

콤마 구분자로 도시명이 저장된 city 문자열에서 각각의 도시명을 분리하여 출력했다. 콤마를 구분자로 하여 split 메서드를 호출하면 토큰의 배열이 리턴되며 루프로 배열을 순회하면서 4개의 도시를 출력했다. 다음 메서드는 split 메서드와 반대로 구분자를 문자열 사이에 끼워 넣어 전체 문자열을 조립한다.

static String join(CharSequence delimiter, CharSequence... elements)

static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

첫 번째 인수로 구분자를 주고 두 번째 인수로 각각의 문자열이나 문자열 컬렉션을 전달하면 구분자를 삽입한 문자열을 조립하여 리턴한다.

join
import java.util.*; class JavaTest { public static void main(String[] args) { String path = String.join("/", "user", "data", "app", "local"); System.out.println(path); String seoul = "서울", daejun = "대전", daegu = "대구", busan = "부산"; String city = String.join(",", seoul, daejun, daegu, busan); //String city = seoul + "," + daejun + "," + daegu + "," + busan; System.out.println(city); List<String> subway = Arrays.asList("서울역", "남영", "용산", "노량진"); System.out.println(String.join(" -> ", subway)); } }
실행결과	user/data/app/local 서울,대전,대구,부산 서울역 -> 남영 -> 용산 -> 노량진

디렉터리 구분자와 함께 서브 디렉터리 목록을 전달하여 하나의 경로로 합쳤다. 도시명과 콤마를 전달하면 도시명 사이에 콤마가 삽입된 문자열이 만들어진다. + 연산자로 일일이 구분자를 끼워 넣을 수 있지만 불편하다. 문자열의 리스트를 전달하면 모든 요소 사이에 구분자를 삽입한다. 구분자는 문자가 아닌 문자열이어서 여러 문자를 삽입할 수 있다.

16-1-6.StringBuffer

String 객체는 상수의 성질을 가지며 한 번 정해지면 내용을 변경할 수 없다. 이렇게 되어 있는 이유는 문자열을 변경할 일이 예상보다 빈번하지 않기 때문이다. 부득이하게 변경할 때는 객체의 내용이 바뀌는 것이 아니라 변경된 새로운 객체를 생성한다. 따라서 빈번하게 변경할 때는 성능이 떨어진다.

자주 변경되는 문자열에 대해서는 String 대신 사용할 수 있는 별도의 클래스가 제공되는데 이것이 StringBuffer이다. StringBuffer는 일종의 문자 배열이며 메모리를 자동으로 관리하여 삽입, 삭제, 추가를 고속으로 처리한다. 속도차가 얼마나 나는지 직접 테스트해 보자. 다음 예제는 빈 String 객체를 생성한 후 알파벳 A 에서 z까지 덧붙이기를 1000번 반복한다.

atoz
class JavaTest { public static void main(String[] args) { long start = System.currentTimeMillis(); String str = ""; for (int i = 0; i < 1000; i++) { for (char ch = 'A'; ch <= 'z'; ch ++) { str += ch; } str += '\n'; } System.out.println(str); System.out.println((System.currentTimeMillis()-start)/1000.0 + "초"); } }
실행결과	ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz 1.867초

+= 연산자로 문자를 계속 붙이면 원하는 문자열이 만들어지는데 최종 문자열과 걸린 시간을 출력했다. 컴퓨터 성능에 따라 차이가 있는데 대략 2초면 엄청난 세월이다. 문자를 덧붙일 때마다 새로운 문자열이 생성되니 느릴 수밖에 없으며 이전 객체까지 삭제해야 하니 가비지 컬렉터에게도 부담을 준다. 이번에는 똑같은 예제를 StringBuffer 클래스로 만들어 보았다.

atoz2
class JavaTest { public static void main(String[] args) { long start = System.currentTimeMillis(); StringBuffer str = new StringBuffer(); for (int i = 0; i < 1000; i++) { for (char ch = 'A'; ch <= 'z'; ch ++) { str.append(ch); } str.append('\n'); } System.out.println(str); System.out.println((System.currentTimeMillis()-start)/1000.0 + "초"); } }
실행결과	ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz 0.005초

+= 연산자 대신 append 메서드로 문자를 덧붙인다. 문자가 추가되면 메모리를 더 할당할 뿐 새로운 객체를 만들지 않아 실행하자 마자 결과가 바로 출력된다. 문자열 변경 횟수가 늘어나면 두 예제의 속도차는 엄청나게 벌어진다. 그래서 자주 변경되는 문자열은 String 클래스를 쓰는 것보다는 StringBuffer 클래스를 쓰는 것이 속도상 유리하다.

다음은 StringBuffer 클래스의 주요 메서드이다. 추가, 삽입, 삭제, 대체 등 문자열 편집 기능이 제공된다. 문자나 문자열 뿐만 아니라 정수, 실수 등의 타입에 대해서도 오버로딩되어 있어 임의의 자료를 조립할 수 있다.

StringBuffer append(char c)

StringBuffer insert(int offset, String str)

StringBuffer delete(int start, int end)

StringBuffer replace(int start, int end, String str)

String과 StringBuffer는 똑같이 문자열을 다루지만 사용하는 목적이 완전히 다르다. String은 문자열을 표현하는 것이 목적이고 StringBuffer는 문자열을 조작하는 것이 목적이다. 두 객체는 직접 대입할 수 없으며 변환을 거쳐야 한다. String 객체를 StringBuffer로 바꾸려면 StringBuffer의 생성자로 전달한다. 반대의 경우는 StringBuffer객체의 toString 메서드를 호출한다.

StringBuilder도 StringBuffer와 같되 멀티 스레드를 지원하지 않는 구형이다. StringBuffer는 여러 개의 스레드에서 동시에 사용해도 문제없도록 되어 있지만 대신 동기화 처리가 필요해 미세하게 느리다. 한 스레드에서만 문자열을 조작한다면 StringBuilder가 약간 유리하지만 굳이 구분하는 것보다 StringBuffer를 일관되게 쓰는 것이 바람직하다.