String 메서드
concat
concat(String str)
이 메서드는 현재 문자열에 다른 문자열을 붙여 새로운 문자열을 만든다.
"Java".concat("Tutor")
// "JavaTutor"라는 새로운 문자열을 반환한다.equalsIgnoreCase
equalsIgnoreCase(String anotherString)
대소문자를 구분하지 않고 두 문자열이 같은지 비교한다.
"JAVA".equalsIgnoreCase("java")
// true를 반환한다.chartAt
charAt(int index)
지정된 인덱스에 있는 문자를 반환한다. 인덱스는 0부터 시작한다.
"Java".charAt(2)
// 'v'를 반환한다.compareTo
compareTo(String anotherString)
두 문자열을 사전순으로 비교한다. 같으면 0을, 호출 문자열이 파라미터로 주어진 문자열보다 사전순으로 앞서면 음수를, 뒤쳐지면 양수를 반환한다.
System.out.println("aaa vs aaa : " + "aaa".compareTo("aaa")); // 0
System.out.println("aaa vs bbb : " + "aaa".compareTo("bbb")); // b가 한 칸 뒤에 있으므로, 차이가 -1
System.out.println("ccc vs aaa : " + "ccc".compareTo("aaa")); // c가 두 칸 뒤에 있으므로, 차이가 2
System.out.println("aba vs aaa : " + "aba".compareTo("aaa")); // b가 한 칸 뒤에 있으므로, 차이가 1copyValueOf
copyValueOf(char[] data, int offset, int count)
지정된 문자 배열의 특정 부분을 문자열로 변환한다.
char[] data = {'J', 'a', 'v', 'a'};
String.copyValueOf(data, 1, 2) // "av"를 반환한다.indexOf
indexOf(int ch) 및 indexOf(String str)
문자 또는 문자열이 처음으로 등장하는 인덱스를 반환한다. 찾지 못하면 -1을 반환한다.
"Java".indexOf('v') // 2를 반환한다.
"Java".indexOf("va") // 2를 반환한다.lastIndexOf
compareTo(String anotherString)
indexOf와 비슷하지만, 문자 또는 문자열이 마지막으로 등장하는 인덱스를 찾는다.
"Java".lastIndexOf('a') // 3을 반환한다.startsWith
startsWith(String prefix)
이 메서드는 문자열이 특정 문자열로 시작하는지 여부를 확인한다.
"Java".startsWith("Ja") // true를 반환한다.endsWith
endsWith(String suffix)
문자열이 특정 문자열로 끝나는지 여부를 확인한다.
"Java".endsWith("va") // true를 반환한다.isEmpty
compareTo(String anotherString)
문자열이 비어있는지 여부를 확인한다. 문자열 길이가 0이면 true, 그렇지 않으면 false를 반환한다.
"".isEmpty() // true를 반환한다.substring
substring(int beginIndex), substring(int beginIndex, int endIndex)
문자열의 특정 부분을 추출한다. beginIndex는 추출 시작 위치를, endIndex는 추출 종료 위치를 나타낸다(endIndex는 포함되지 않음).
"Java".substring(1, 3) // "av"를 반환한다.toUpperCase
toUpperCase()
문자열의 모든 문자를 대문자로 변환한다.
"Java".toUpperCase() // "JAVA"를 반환한다.toLowerCase
toLowerCase()
문자열의 모든 문자를 소문자로 변환한다.
"Java".toLowerCase() // "java"를 반환한다.trim
trim()
trim() 메서드는 문자열의 앞과 뒤에 있는 공백을 제거한다. 중간에 있는 공백은 제거하지 않는다. 이 메서드는 사용자로부터 입력받은 문자열에서 불필요한 공백을 제거할 때 유용하다.
" Java Tutor ".trim() // "Java Tutor"를 반환한다.valueOf
valueOf(다양한 타입)
valueOf 메서드는 다양한 타입의 데이터를 문자열로 변환한다. 이 메서드는 오버로딩되어 있어서 정수, 실수, 객체 등 다양한 타입의 인수를 받을 수 있다. 이 메서드는 기본 타입의 값을 문자열로 쉽게 변환할 때 매우 유용하다.
String.valueOf(123) // 정수 123을 "123"이라는 문자열로 변환한다.toCharArray
toCharArray()
toCharArray() 메서드는 문자열을 문자 배열로 변환한다. 이 메서드를 사용하면 문자열의 각 문자에 쉽게 접근할 수 있다. 이 메서드는 문자열을 문자 단위로 처리해야 할 때 사용된다.
"Java".toCharArray() // ['J', 'a', 'v', 'a']라는 문자 배열을 반환한다실습예제 1
package com.mystudy.string;
public class Ex01_String_basic {
public static void main(String[] args) {
/*
* String 클래스 : 문자열 저장, 처리하기 위한 클래스
* String 데이터 자체는 불변임(immutable)
* 사용형식 2가지
* String str = '홍길동'; // 기본 데이터 타입처럼 사용 가능 - 리터럴(literal) 값
* String str = new String("홍길동"); // 객체(인스턴스) 생성
*/
String str1 = "홍길동";
String str2 = "홍길동";
System.out.println(str1);
System.out.println(str2);
System.out.println("str1 == str2 : " + (str1 == str2)); // 동일객체 여부 : true
// == : 객체(인스턴스, 주소값) 비교(동일 객체 여부 확인)
String strObj1 = new String("홍길동");
String strObj2 = new String("홍길동");
System.out.println("str1 == str2 : " + (strObj1 == strObj2)); // 동일객체 여부 : false
System.out.println("=== 문자열 값 비교 equals() 사용할 것 ===");
System.out.println("strObj1.equals(strObj2) : " + strObj1.equals(strObj2)); // 동일 문자열 여부 : True
System.out.println("=========================================");
System.out.println("--- concat() ---");
String a = "Hello";
String b = "World";
String c = "~~~~~";
System.out.println("a + b = " + (a + b));
System.out.println("a.concat(b) : " + a.concat(b));
// chainning 기법(체이닝 기법)
String result = a.concat(b).concat(c).concat("!!!");
System.out.println("a.concat(b).concat(c).concat(\"!!!\") : " + result); // 이스케이프 문자(역슬래쉬)
System.out.println("a : " + a);
System.out.println("a.toString() : " + a.toString());
System.out.println("=========================================");
str1 = "JAVA";
str2 = "java";
System.out.println("str1 : " + str1);
System.out.println("str2 : " + str2);
System.out.println("str1.equals(str2) : " + str1.equals(str2));
System.out.println("str1.equalsIgnoreCase(str2) : " + str1.equalsIgnoreCase(str2)); // 대소문자 구문x : True
}
}홍길동
홍길동
str1 == str2 : true
str1 == str2 : false
=== 문자열 값 비교 equals() 사용할 것 ===
strObj1.equals(strObj2) : true
=========================================
--- concat() ---
a + b = HelloWorld
a.concat(b) : HelloWorld
a.concat(b).concat(c).concat("!!!") : HelloWorld~~~~~!!!
a : Hello
a.toString() : Hello
=========================================
str1 : JAVA
str2 : java
str1.equals(str2) : false
str1.equalsIgnoreCase(str2) : true실습예제 2
package com.mystudy.string;
import java.util.Arrays;
public class Ex02_String_method {
public static void main(String[] args) {
// String 클래스 메소드를 사용 문자열 처리(단, 원본문자열 불변)
// 0123456789
String str = "Java World";
System.out.println("str : " + str);
char ch = str.charAt(0);
System.out.println("str.charAt(0) : " + ch);
System.out.println("str.charAt(1) : " + str.charAt(1));
// char[] ch2 = { str.charAt(0), str.charAt(1), str.charAt(2), str.charAt(3) };
char[] ch2 = new char[4];
for (int i = 0; i < ch2.length; i++) {
ch2[i] = str.charAt(i);
}
System.out.println(Arrays.toString(ch2));
System.out.println("--- compareTo() : 문자열비교(결과: 음수, 0, 양수) ---");
System.out.println("java vs java : " + "java".compareTo("java")); // 문자열은 앞에서부터 비교. 같은 문자열이므로 차이가 없으니 0을 반환
System.out.println("aaa vs aaa : " + "aaa".compareTo("aaa")); // 마찬가지로 0
System.out.println("aaa vs bbb : " + "aaa".compareTo("bbb")); // b가 한 칸 뒤에 있으므로, 차이가 -1
System.out.println("ccc vs aaa : " + "ccc".compareTo("aaa")); // c가 두 칸 뒤에 있으므로, 차이가 2
System.out.println("aba vs aaa : " + "aba".compareTo("aaa")); // b가 한 칸 뒤에 있으므로, 차이가 1
char[] ch3 = {'a', 'b', 'c', 'd'};
System.out.println(Arrays.toString(ch3));
str = String.copyValueOf(ch3);
System.out.println("String.copyValueOf(ch3) : " + str);
System.out.println("String.copyValueOf(ch3, 0, 2) : " + String.copyValueOf(ch3, 0, 2)); // 인덱스 0부터 2개
System.out.println("=========================");
// 0123456789
str = "Java World";
System.out.println("--- indexOf() : 문자열로부터 문자 찾기 ---");
System.out.println("str.indexOf('J') : " + str.indexOf('J')); // 0
System.out.println("str.indexOf(\"Java\") : " + str.indexOf("Java")); // 0
System.out.println("str.indexOf('a') : " + str.indexOf('a'));
System.out.println("str.indexOf('a', 2) : " + str.indexOf('a', 2)); // 2번째 인덱스로부터 찾는다.
System.out.println("str.lastIndexOf('d') ; " + str.lastIndexOf('d')); // 마지막 인덱스로부터 찾는다. (뒤에서 부터 찾기)
System.out.println("str.lastIndexOf('a') ; " + str.lastIndexOf('a')); // 마지막 인덱스로부터 찾는다. (뒤에서 부터 찾기)
System.out.println("str.lastIndexOf('l') ; " + str.lastIndexOf('l')); // 마지막 인덱스로부터 찾는다. (뒤에서 부터 찾기)
System.out.println("str.indexOf(\"Hello\") : " + str.indexOf("Hello")); // 없는 경우: -1 반환
System.out.println("str.startsWith(\"Java\") : " + str.startsWith("Java")); // "Java"로 시작하는지 여부 확인 : True
System.out.println("str.startsWith(\"World\") : " + str.startsWith("World")); // "World"로 시작하는지 여부 확인 : False
System.out.println("str.endsWith(\"Java\") : " + str.endsWith("Java")); // "Java"로 끝나는가? : False
System.out.println("str.endsWith(\"World\") : " + str.endsWith("World")); // "World"로 끝나는가?: true
System.out.println();
System.out.println("--- isEmpty() : 문자열이 비었는지 확인 ---");
System.out.println("str.isEmpty() : " + str.isEmpty()); // 문자가 하나라도 존재하면 False, 아무것도 없으면 True 현재는 false
str = "";
System.out.println("str.isEmpty() : " + str.isEmpty()); // 문자가 하나라도 존재하면 False, 아무것도 없으면 True 현재는 true
System.out.println();
System.out.println("--- length() : 문자갯수 확인 ---");
System.out.println("str.length() : " + str.length()); // 길이 확인
System.out.println();
//=================================================================
// 0123456789
str = "Java World";
System.out.println("str.replace(\"Java\", \"Hello\") : " + str.replace("Java", "Hello")); // 문자열을 찾아서 변경, 원본은 변경되지 않는다. Hello World
System.out.println("str.replace(\"a\", \"m\") : " + str.replace("a", "m")); // 문자열을 찾아서 변경, 원본은 변경되지 않는다. Jmvm World
System.out.println("str : " + str);
System.out.println();
System.out.println("-------------------------------");
str = "java java";
System.out.println("str : " + str);
System.out.println("str.replaceAll(\"ja\", \"JA\") : " + str.replaceAll("ja", "JA"));
System.out.println("===============================");
// 0123456789
str = "Java World";
System.out.println("str : " + str);
System.out.println("str.substring(5) : " + str.substring(5)); // 5번 인덱스부터 끝까지 발췌
System.out.println("str.length() : " + str.length());
System.out.println("str.substring(0, 10) : " + str.substring(0, 10)); // 시작위치, 끝위치 지정해서 발췌 (end point는 포함되지 않는다.)
// 앞에서 4글자 추출하기
System.out.println("str.substring(0, 4) : " + str.substring(0, 4)); // 시작위치, 끝위치 지정해서 발췌 (end point는 포함되지 않는다.)
// 뒤에서 5글자 추출하기
System.out.println("str.substring(str.length() - 5, str.length()) : " + str.substring(str.length() - 5, str.length())); // 시작위치, 끝위치 지정해서 발췌 (end point는 포함되지 않는다.)
System.out.println();
System.out.println("-------------------------------");
str = " Java World ";
System.out.println("str : -" + str + "-");
System.out.println("str.toUpperCase() : " + str.toUpperCase()); // 대문자로 바꾸기
System.out.println("str.toLowerCase() : " + str.toLowerCase()); // 소문자로 바꾸기
System.out.println("str.trim() : -" + str.trim() + "-"); // 좌우 공백 삭제
System.out.println("--- String.valueOf(): 문자열로 변환 ---");
int num = 100;
// str = num; // 타입이 달라서 안된다!
str = num + ""; // 인트타입을 스트링으로 변환 후 대입!
str = String.valueOf(100); // 100을 문자열로 변환
str = String.valueOf(num); // 인트를 문자열로 변환
System.out.println();
System.out.println("--- toCharArray() : 문자열을 char[] 타입의 배열로 ---");
str = "Java World";
System.out.println("str : " + str);
char[] chArr = str.toCharArray();
System.out.println(Arrays.toString(chArr));
}
}str : Java World
str.charAt(0) : J
str.charAt(1) : a
[J, a, v, a]
--- compareTo() : 문자열비교(결과: 음수, 0, 양수) ---
java vs java : 0
aaa vs aaa : 0
aaa vs bbb : -1
ccc vs aaa : 2
aba vs aaa : 1
[a, b, c, d]
String.copyValueOf(ch3) : abcd
String.copyValueOf(ch3, 0, 2) : ab
=========================
--- indexOf() : 문자열로부터 문자 찾기 ---
str.indexOf('J') : 0
str.indexOf("Java") : 0
str.indexOf('a') : 1
str.indexOf('a', 2) : 3
str.lastIndexOf('d') ; 9
str.lastIndexOf('a') ; 3
str.lastIndexOf('l') ; 8
str.indexOf("Hello") : -1
str.startsWith("Java") : true
str.startsWith("World") : false
str.endsWith("Java") : false
str.endsWith("World") : true
--- isEmpty() : 문자열이 비었는지 확인 ---
str.isEmpty() : false
str.isEmpty() : true
--- length() : 문자갯수 확인 ---
str.length() : 0
str.replace("Java", "Hello") : Hello World
str.replace("a", "m") : Jmvm World
str : Java World
-------------------------------
str : java java
str.replaceAll("ja", "JA") : JAva JAva
===============================
str : Java World
str.substring(5) : World
str.length() : 10
str.substring(0, 10) : Java World
str.substring(0, 4) : Java
str.substring(str.length() - 5, str.length()) : World
-------------------------------
str : - Java World -
str.toUpperCase() : JAVA WORLD
str.toLowerCase() : java world
str.trim() : -Java World-
--- String.valueOf(): 문자열로 변환 ---
--- toCharArray() : 문자열을 char[] 타입의 배열로 ---
str : Java World
[J, a, v, a, , W, o, r, l, d]실습예제3 : 주민등록번호 생년월일 출력
package com.mystudy.string;
public class Ex03_StringExam {
public static void main(String[] args) {
/*
* String str = "951012-1234567" // 주민번호
* 1. 전체자리수 14개 여부확인, '-' 위치: 가 7번째에 존재하는지 확인
* 2. 생년월일 출력
* 예) 92년 10월 12일 또는 1995년 10월 12일
* 3. 성별 확인하고 출력(1, 3: 남성, 2, 4: 여성)
* 4. 데이터 값 검증(월:1~12, 일:1~31)
* 참고) int num = Integer.parseInt("10"); //"10" ---> 10
*/
String str = "000201-1234567";
printIdentification(str);
}
static void printIdentification(String str) {
checkLength(str);
}
static void checkLength(String str) {
if (str.length() == 14) {
checkHyphen(str);
} else {
System.out.println("주민등록번호의 자리가 14자리가 아닙니다.");
}
}
static void checkHyphen(String str) {
if ((str.indexOf('-') == 6) && (str.lastIndexOf('-') == 6)) {
printBirth(str);
} else {
System.out.println(" '-' 가 올바른 위치에 있지 않습니다.");
}
}
static void printBirth(String str) {
if (checkBirth(str) == false) {
System.out.println("생년월일의 날짜가 맞지 않습니다. 다시입력해주세요.");
} else {
String year = "";
if (Integer.parseInt(str.substring(0, 2)) < 24) {
year = "20" + str.substring(0, 2);
} else {
year = "19" + str.substring(0, 2);
}
String month = str.substring(2, 4);
String day = str.substring(4, 6);
checkSex(str, year, month, day);
}
}
static Boolean checkBirth(String str) {
if (Integer.parseInt(str.substring(2, 4)) > 12 || Integer.parseInt(str.substring(2, 4)) <= 0) {
return false;
}
// 윤달체크, 윤년이 아닐 경우
if (((Integer.parseInt(str.substring(2, 4)) == 2) && (Integer.parseInt(str.substring(0, 2)) % 4 > 0))) {
if (Integer.parseInt(str.substring(4, 6)) > 28 || Integer.parseInt(str.substring(4, 6)) <= 0) {
return false;
}
// 윤달체크, 윤년일 경우
} else if (((Integer.parseInt(str.substring(2, 4)) == 2) && (Integer.parseInt(str.substring(0, 2)) % 4 == 0))) {
if (Integer.parseInt(str.substring(4, 6)) > 29 || Integer.parseInt(str.substring(4, 6)) <= 0) {
return false;
}
// 홀수인 월일 경우
} else if ((Integer.parseInt(str.substring(2, 4)) % 2) == 1) {
if (Integer.parseInt(str.substring(4, 6)) > 31 || Integer.parseInt(str.substring(4, 6)) <= 0) {
return false;
}
// 짝숭니 월일 경우
} else if ((Integer.parseInt(str.substring(2, 4)) % 2) == 0) {
if (Integer.parseInt(str.substring(4, 6)) > 30 || Integer.parseInt(str.substring(4, 6)) <= 0) {
return false;
}
}
return true;
}
static void checkSex(String str, String year, String month, String day) {
if ((Integer.parseInt(str.substring(7, 8)) > 0) && (Integer.parseInt(str.substring(7, 8)) < 5)) {
int sex = Integer.parseInt(str.substring(7, 8));
if ((sex == 1) || (sex == 2)) {
System.out.printf("%s년 %s월 %s일 남성입니다.\n", year, month, day);
} else if ((sex) == 3 || (sex == 4)) {
System.out.printf("%s년 %s월 %s일 여성입니다.\n", year, month, day);
}
} else {
System.out.println("주민등록번호 8번째 자리를 잘못 입력하셨습니다.");
}
}
}
2000년 02월 01일 남성입니다.실습예제 4
package com.mystudy.string;
public class Ex04_String_array_exam {
public static void main(String[] args) {
/* String[]과 String 메소드 사용 실습
문자열 : "홍길동","이순신","이순신","을지문덕","김유신","연개소문","Tom","TOM"
1. 위의 문자열 값을 저장할 수 있는 문자열 배열(names) 변수를 선언하고 입력
2. 배열에 있는 값을 구분자 콤마(,)로 구분하여 한 라인에 출력
출력 예) 홍길동,이순신,이순신,을지문덕....
3. 배열에 있는 데이터의 첫 글자만 출력-구분자 콤마(,) 사용 한 라인에 출력
출력 예) 홍,이,이,을,김,연,T,T...
4. 이름의 글자수가 4글자 이상인 이름을 검색해서 "인덱스번호:이름" 형태로 출력
예) 3:을지문덕
5. 이름이 같은 데이터를 "인덱스번호:이름=인덱스번호:이름" 형태로 출력
예) 1:이순신=2:이순신
(기타) 이름 비교시에는 대소문자 구분 없이 비교처리(Tom, TOM 은 같다)
========================================================= */
String[] arr = {"홍길동", "이순신", "이순신", "을지문덕", "김유신", "연개소문", "Tom", "TOM"};
printArray(arr);
printFirstChar(arr);
printMoreThan4(arr);
findSameData(arr);
}
static void printArray(String[] arr) {
if (arr.length == 0) {
System.out.println("데이터가 비어있습니다.");
} else {
int i = 0;
for (String str : arr) {
System.out.print(str);
if (i < arr.length - 1) {
System.out.print(", ");
}
i++;
}
System.out.println();
}
}
static void printFirstChar(String[] arr) {
if (arr.length == 0) {
System.out.println("데이터가 비어있습니다.");
} else {
int i = 0;
for (String str : arr) {
System.out.print(str.charAt(0));
if (i < arr.length - 1) {
System.out.print(", ");
}
i++;
}
System.out.println();
}
}
static void printMoreThan4(String[] arr) {
String[] newArr = new String[arr.length];
int i = 0;
int k = 0;
for (String str : arr) {
if (str.length() >= 4) {
newArr[k] = i + " : " + str;
k++;
}
i++;
}
deleteNull(newArr);
}
static void findSameData(String[] arr) {
if (arr.length == 0) {
System.out.println("데이터가 비어있습니다.");
} else {
String[] newArr = new String[arr.length];
int k = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i+1; j < arr.length; j++) {
if (arr[i].equalsIgnoreCase(arr[j])) {
newArr[k] = i + ":" + arr[i] + " = " + j + ":" + arr[j];
k++;
}
}
}
deleteNull(newArr);
}
}
static void deleteNull(String[] arr) {
if (arr.length == 0) {
System.out.println("데이터가 비어있습니다.");
} else {
int k = 0;
for(int i = 0; i < arr.length; i++) {
if (arr[i] != null) {
k++;
}
}
String[] newArr = new String[k];
for(int i = 0; i < k; i++) {
newArr[i] = arr[i];
}
printArray(newArr);
}
}
}홍길동, 이순신, 이순신, 을지문덕, 김유신, 연개소문, Tom, TOM
홍, 이, 이, 을, 김, 연, T, T
3 : 을지문덕, 5 : 연개소문
1:이순신 = 2:이순신, 6:Tom = 7:TOM리팩토링
package com.mystudy.string;
public class Ex04_String_array_exam_refactoring {
public static void main(String[] args) {
String[] names = {"홍길동", "이순신", "이순신", "을지문덕", "김유신", "연개소문", "Tom", "TOM"};
printArray(names);
printFirstChar(names);
printMoreThan4(names);
findSameData(names);
}
static void printArray(String[] arr) {
if (isEmpty(arr)) return; // return 하나로 깔끔하게 정리된다. void여도 return을 사용할 수 있구나. 함수 종료를 목적으로.
StringBuilder sb = new StringBuilder(); // 뭐지? StringBuilder로 array를 만든건가?
for (int i = 0; i < arr.length; i++) {
sb.append(arr[i]); // append 메소드 존재 확
if (i < arr.length - 1) {
sb.append(", ");
}
}
System.out.println(sb.toString());
}
static void printFirstChar(String[] arr) {
if (isEmpty(arr)) return;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
sb.append(arr[i].charAt(0));
if (i < arr.length - 1) {
sb.append(", ");
}
}
System.out.println(sb.toString());
}
static void printMoreThan4(String[] arr) {
for (int i = 0; i < arr.length; i++) {
if (arr[i].length() >= 4) {
System.out.print(i + " : " + arr[i] + " ");
}
}
System.out.println();
}
static void findSameData(String[] arr) {
if (isEmpty(arr)) return;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i].equalsIgnoreCase(arr[j])) {
System.out.print(i + ":" + arr[i] + " = " + j + ":" + arr[j] + " ");
}
}
}
System.out.println();
}
static boolean isEmpty(String[] arr) {
if (arr == null || arr.length == 0) {
System.out.println("데이터가 비어있습니다.");
return true;
}
return false;
}
}홍길동, 이순신, 이순신, 을지문덕, 김유신, 연개소문, Tom, TOM
홍, 이, 이, 을, 김, 연, T, T
3 : 을지문덕 5 : 연개소문
1:이순신 = 2:이순신 6:Tom = 7:TOM
StringBuilder sb = new StringBuilder();
배열을 새로 만든건가? 라고 생각했지만 다르다!!
다음은 for문 안에서 sb가 어떻게 변하는지에 관한 내용이다. 살펴보면 배열의 형식이 아니라, 문자열의 형식인 것을 볼 수 있다.
홍길동,
홍길동, 이순신,
홍길동, 이순신, 이순신,
홍길동, 이순신, 이순신, 을지문덕,
홍길동, 이순신, 이순신, 을지문덕, 김유신,
홍길동, 이순신, 이순신, 을지문덕, 김유신, 연개소문,
홍길동, 이순신, 이순신, 을지문덕, 김유신, 연개소문, Tom,
홍길동, 이순신, 이순신, 을지문덕, 김유신, 연개소문, Tom, TOM
홍길동, 이순신, 이순신, 을지문덕, 김유신, 연개소문, Tom, TOMStringBuilder sb = new StringBuilder(); 라인에서 sb는 StringBuilder 타입의 객체를 선언하고 생성하는 것이다. StringBuilder는 배열과는 다르게 작동한다. 배열은 동일한 타입의 요소들을 연속적으로 저장하는 구조이다. 반면에 StringBuilder는 변경 가능한 문자열을 효율적으로 처리할 수 있는 클래스이다.
StringBuilder의 주요 특징은 다음과 같다
- 가변성: StringBuilder 객체는 문자열을 추가, 삭제, 수정할 수 있으며, 이러한 작업을 할 때 새로운 객체를 생성하지 않는다. 이는 기존의 String 객체와 비교했을 때 메모리 사용과 성능 면에서 효율적이다.
- 메서드 체이닝: append, insert, delete 등의 메서드를 사용해 문자열을 조작할 수 있으며, 이 메서드들은 StringBuilder 객체 자체를 반환하기 때문에 메서드 체이닝이 가능하다.
예를 들어, StringBuilder를 사용하여 여러 문자열을 하나로 결합하는 것은 배열을 사용하는 것보다 효율적이며, 메모리 사용량을 줄일 수 있다. 따라서 문자열을 반복적으로 변경하거나 연결할 때 StringBuilder를 사용하는 것이 좋다.
신입사원...