String 클래스

데이터(char[ ]) + 메서드(문자열 관련)

불변(immutable) 클래스

한 번 생성된 String 인스턴스가 갖고 있는 문자열은 읽어 올 수만 있고 변경할 수 없다. ( read only )

Strig 클래스에는 문자열을 저장하기 위해서 문자형 배열 참조변수(char[ ])value를 인스턴스 변수로 정의한다. 인스턴스 생성 시 생성자의 매개변수로 입력받는 문자열은 이 인스턴스 변수에 문자형 배열로 저장된다.

위 코드와 같이 '+' 연산자를 이용해 문자열을 결합하는 경우 인스턴스내의 문자열이 바뀌는 것이 아니라 새로운 문자열("ab")이 담긴 인스턴스가 생성되는 것이다.

덧셈연산자를 통해 문자열을 결합하는 것은 매 연산 시 새 인스턴스 생성으로 메모리공간을 차지하게 되므로 결합횟수를 줄이는 것이 좋다.

문자열간 결합이나 추출등의 작업이 많이 필요한 경우에는 StringBuffer 클래스를 사용하는 것이 좋다.

문자열의 비교

문자열을 만드는 두 가지 방법
1. 문자열 리터럴 저장
2. String 클래스 생성자 사용

(1) str1 == str2
String str1 = "abc";
String str2 = "abc";

(2) str3 != str4 
String str3 = new String("abc");
String str4 = new String("abc");

String 클래스의 생성자를 이용한 경우에 new 연산자에 의해서 메모리할당이 이루어지기 때문에 항상 새로운 인스턴스가 생성되지만, 문자열 리터럴은 이미 존재하는 것을 재사용하는 것이다.

문자열 리터럴

• 모든 문자열 리터럴은 컴파일 시 클래스 파일에 저장.
• 같은 내용의 문자열 리터럴은 한 번만 저장.

클래스 파일에는 소스 파일에 포함된 모든 리터럴 목록이 있다. 해당 클래스 파일이 클래스 로더에 의해 메모리에 올라갈 떄, 이 리터럴 목록에 있는 리터럴들이 JVM내에 있는 '상수 저장소(consant pool)'에 저장된다.

빈 문자열(empty String)

길이가 0인 배열을 내부적으로 가지고 있는 문자열이 빈 문자열이다. 'String s ="";'과 같은 문장이 있을 때, 참조변수 s가 참조하고 있는 String 인스턴스는 내부에 'new char[0]'과 같이 길이가 0인 char형 배열을 저장하고 있다.

(1) 빈 문자열로 초기화
String s = null;
→ String s = "";

(2) 공백으로 초기화
// char형 변수에는 반드시 하나의 문자를 지정해야 함.
char c = '\u0000'; // '\u0000'은 유니코드 첫 번째 문자로 빈 문자이다. 
→ char c = ' ';

String 클래스의 생성자와 메서드

String 생성자

(1) String(char[] value)
char[] c = {'H','e','l','l','o'};
String s = new String(c);
// s = "Hello"

(2) String(StringBuffer buf)
StringBuffer sb = new StringBuffer("World");
String s = new String(sb);
// s = "World"

⭐️char charAt(int index)

< 지정된 위치(index)에 있는 문자를 알려줌 >

String s = "Hello";
String n = "23456";
char c = s.charAt(1);
char c2 = n.charAt(3);
// c = 'e', c2 = '5'

⭐️int compareTo(String str)

< 문자열(str)과 사전순서로 비교한다. 같으면 0을,
사전순으로 이전이면 음수를, 이후면 양수를 반환한다. >

int i = "bbb".compareTo("bbb"); // 	i 	= 0;
int i2 = "bbb".compareTo("ccc"); // i2 	= -1 
int i3 = "bbb".compareTo("aaa"); // i3 	= 1;

⭐️String concat(String str)

< 문자열(str)을 뒤에 덧붙인다. >

String s1 = "Hello";
String s2 = s1.concat(" World");
// s2 = " Hellp World"

boolean contains(CharSequence s)

< 지정된 문자열(s)이 포함되어있는지 검사 >

String s ="abcedfg";
String s2 ="fg";
boolean b = s.contains("bc"); // true
boolean b2 = s.contains(s2);  // true

boolean endsWith (Strings suffix)

< 지정된 문자열(suffix)로 끝나는지 검사 >

String s = "Hello.txt";
boolean b = s.endsWith("txt"); // true

booelan equals (Object obj)

< 매개변수로 받은 문자열(obj)과 String 인스턴스의
문자열을 비교한다. obj가 String이 아니거나 문자열이 다르면 false를 반환한다. >

String s = "Hello";
boolean b = s.equals("Hello");  // true
boolean b2 = s.equals("hello"); // false

boolean equalsIgnoreCase (String str)

< 문자열과 String 인스턴스 문자열을 대소문자 구분 없이 비교 > 

String s = "Hello";
boolean b = s.equalsIgnoreCase("HELLO");  // true
boolean b2 = s.equalsIgnoreCase("heLLo"); // true

⭐️int indexOf(int ch)
int indexOf(int ch, int pos)
int indexOf(String str)

< 주어진 문자(ch)가 문자열에 존재하는지 확인하여 위치(Index)를 알려준다.
못 찾으면 -1을 반환한다. >

String s = "Hello";
int idx1 = s.indexOf('o'); // idx1 = 4
int idx2 = s.indexOf('l'); // idx2 = 2
int idx3 = s.indexOf('k'); // idx3 = -1

int indexOf(int ch, int pos)
< 주어진 문자가 문자열에 존재하는지 지정된 위치(pos)부터 확인하여 알려준다 > 

int idx4 = s.indexOf('e', 0); // idx4 = 1
int idx5 = s.indexOf('e', 2); // idx5 = -1

int indexOf(String str)
< 주어진 문자열이 존재하는지 확인하여 그 위치(index)를 알려준다. >
int idx6 = s.indexOf("ll"); // idx6 = 2

⭐️int lastIndexOf(int ch)
int lastIndexOf(String str)

< 지정된 문자 또는 문자코드 / 문자열 (을)를 문자열의 오른쪽 끝에서부터 찾아서
위치(index)를 알려준다. 못 찾으면 -1 반환 > 

String s ="java.lang.java"; 
int idx1 = s.lastIndexOf('.');	  // idx1 = 9
int idx2 = s.indexOf('.');	 	  // idx2 = 4
int idx3 = s.lastIndexOf("java"); // idx3 = 10
int idx4 = s.indexOf("java"); 	  // idx4 = 0

String replace(char old, char nw)
String replace(charSequence old, charSequence nw)

< 문자열 중 문자(old)/문자열을(를) 새로운 문자/문자열로 바꾼 후 반환한다. > 
 
 String s ="Hello";
 String s1 = s.repalce('H','C'); // s1 = "Cello"
 
 String s2 ="Hello";
 String s3 =s2.repalce("ll", 'LL') // s2 = "HeLLo"

String replaceAll(String srt, String restr)
String replaceFirst(String srt, String restr)

< 문자열 중에서 지정된 문자열과 일치하는 것을 새로운 문자열로 모두 변경 >

String srt = "aabbaabb";
String reSrt = srt.replaceAll("aa", "AA"); // reSrt = "AAbbAAbb"

< 문자열 중 지정된 문자열과 일치하는 건 중 첫 번째 것만 변경 > 
String srt = "aabbaabb";
String reSrt = srt.replaceFirst("aa", "AA"); // reSrt = "AAbbaabb"

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

< 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다. >

String animals = "dog,cat,bear"
String [] arr = animals.split(",");
// arr[0] = "dog", arr[1] = "cat", arr[2] = "bear" 

< 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다. 단 문자열 전체를 지정딘 수(limit)으로 자른다. >
String animals = "dog,cat,bear"
String [] arr = animals.split(",", 2);
// arr[0] = "dog" arr[1] = "cat,bear"

boolean startWith(String prefix)

< 주어진 문자열(prefix)로 시작하는지 검사 > 
String s = "java.lang.Object";
boolean b = s.startWith("java");  // true
boolean b2 = s.startWith("lang"); // false

⭐️String substring(int begin)
String substring(int begin, int end)

< 주어진 시작위치(begin)부터 끝 위치(end) 범위에 포함된 문자열을 얻는다.
이 떄, 시작 위치의 문자는 범위에 포함되지만, 끝 위치의 문자는 포함되지 않는다.
(begin <= x < end) >
String s = "java.lang.Object";
String c = s.substring(10);	  // c = "Object"
String p = s.substring(5,9);  // p = "lang"

⭐️String toLowerCase()

< String 인스턴스에 저장되어 있는 모든 문자열을 소문자로 변환하여 반환.>

String s = "HellO";
String s1 = s.toLowerCase(); // s1= "hello"

⭐️String toUpperCase()

< String 인스턴스에 저장되어 있는 모든 문자열을 대문자로 변환하여 반환.>
String s = "HellO";
String s1 = s.toUperCase(); // s1 = "HELLO"

⭐️String trim()

< 문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환.
이 때, 문자열 중간에 있는 공백은 제거되지 않는다.>

String s = "   Hello  World   ";
String s1 = s.trim(); // s1 = "Hello  World"

static String valueOf()

< 지정된 값을 문자열로 변환하여 반환한다.
참조 변수의 경우, toString()을 ㅎ출한 결과를 반환한다.>

String booleanType = String.valueOf(true); // booleanType = "true"
String charType = String.valueOf('a'); 	   // charType = "a"
String intType = String.valueOf(10); 	   // intType = "10"
String floatType = String.valueOf(10f);    // floatType = "10.0"
String dobuleTYpe = String.valueOf(10.0);  // dobuleTYpe = "10.0"

java.util.Date ObjectType = new java.util.Date();
String date = String.valueOf(ObjectType); 	// date = "Thu Sep 29 18:06:06 KST 2022"

parseInt()

String을 기본형 값으로 변환해준다.

int i = Integer.pareInt("100"); // i = 100;
int i2 = Integer.valueOf("100"); // i =100;
// 두 메서드는 반환타입만 다를 뿐 같은 메서드다.