[Java] Class String

java.lang 패키지

자바프로그래밍에 가장 기본이 되는 클래스들을 포함하고 있다.

Class String

문자열을 저장하고 이를 다루는 데 필요한 메서드를 제공한다.

변경 불가능한(Immutable) 클래스

문자열을 저장하기 위해서 문자형 배열 변수 value를 인스턴스 변수로 정의하고 있다.

public final class String 
extends Object implements Serializable, Comparable<String>, CharSequence{
    private char[] value;
    ...

문자열 결합

• 덧셈 연산자 +
  

     연산 시 마다 새로운 문자열을 가진 String 인스턴스가 생성되어 메모리 공간을 차지한다.

     가능한 결합횟수를 줄이는 것이 좋다.

String s1 = "a";
String s2 = "b";
s1 = s1 + s2;

• StringBuffer 클래스
  

    문자열간의 결합이나 추출 등 문자열을 다루는 작업이 많이 필요한 경우 사용한다.

String 인스턴스 생성

• 문자열 리터럴
  

     같은 내용의 문자열 리터럴은 한 번만 저장되어 이미 존재하는 것을 재사용한다.

     하나의 인스턴스를 공유하기 때문에 한 번 생성하면 내용을 변경할 수 없다.

     컴파일 시에 클래스 파일에 저장된다.

String str1 = "a";
String str2 = "a";

• 생성자
  

     생성자를 이용하면 new 연산자에 의해 메모리 할당이 이루어져 항상 새로운 String 인스턴스가 생성된다.

String str1 = new String("a");
String str2 = new String("a");

문자열의 비교

equals()는 두 문자열의 내용을 비교하기 때문에 String 인스턴스를 어떤 방식(리터럴, 생성자)으로 생성하든 true를 결과로 얻는다.

각 String 인스턴스의 주소를 등가비교연산자(==)로 비교할 경우 결과가 다르다.

String s1 = "a";
String s2 = "a";
String s3 = s1;
String s4 = new String("a");

System.out.println(s1.equals(s2));    // true
System.out.println(s1.equals(s3));    // true
System.out.println(s1.equals(s4));    // true

System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // true
System.out.println(s1 == s4); // false

빈 문자열 Empty String

String str = "";

str이 참조하고 있는 String 인스턴스 내부에는 'new char[0]'과 같이 길이가 0인 char형 배열을 저장하고 있다.

char[] chArr = new char[0];

String은 참조형 타입의 기본값을 null보다 빈 문자열로, char형은 기본값인 \u0000 대신 공백으로 초기화하는 것이 보통이다.

String str = "";
char c = ' ';

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

String(String original)

주어진 문자열(original)을 갖는 String 인스턴스를 생성.

String str = new String("Love");       // "Love"

String(char[] value)

주어진 문자열(value)을 갖는 String 인스턴스를 생성.

char[] c = {'L', 'o', 'v', 'e'};
String str = new String(c);            // "Love"

String(StringBuffer buffer)

StringBuffer 인스턴스가 갖고 있는 문자열과 같은 내용의 String 인스턴스를 생성.

StringBuffer sb = new StringBuffer("Love");
String str = new String(sb);           // "Love"

char charAt(int index)

지정된 위치(index. 0~)에 있는 문자를 알려준다.

String str = "Love";
char c = str.charAt(1);                // 'o'

int compareTo(String anotherString)

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

int i0 = "a".compareTo("a");           // 0;
int i1 = "a".compareTo("b");           // -1;
int i2 = "b".compareTo("a");           // 1;

String concat(String str)

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

String str1 = "Love";
String str2 = str1.concat("field");     // "Lovefield"

boolean contains(CharSequence s)

지정된 문자열(s)이 포함되었는지 검사한다.

String str = "Love";
boolean b = str.contains("v");         // true

boolean endsWith(Strig suffix)

지정된 문자열(suffix)로 끝나는 지 검사한다.

String str = "Love";
boolean b = str.endsWith("a");         // false

boolean equals(Object anObject)

매개변수로 받은 문자열(anObject)과 Stirng 인스턴스의 문자열을 비교한다.

anObject가 String이 아니거나 문자열이 다르면 false를 반환한다.

String str = "Love";
boolean b1 = str.equals("love");        // false
boolean b2 = str.equals("lo");          // false

boolean equalsIgnoreCase(String anotherString)

문자열과 String 인스턴스의 문자열을 대소문자 구분 없이 비교한다.

String str = "Love";
boolean b = str.equalsIgnoreCase("love");     // true

byte[] getBytes(String charsetName)

문자열의 문자 인코딩을 다른 인코딩으로 변경한다.

try {
    byte[] utf8 = "가".getBytes("UTF-8");     // Encode to UTF-8
    String str = new String(utf8, "UTF-8");   // Decoding
} catch (UnsupportedEncodingException e) {
    e.printStackTrace();
}

int indexOf(int ch)

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

String str = "Love";
int ido = str.indexOf('v');            // 2

int indexOf(int ch, int fromIndex)

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

String str = "Love";
int ido1 = str.indexOf("v", 2);         // 2 
int ido2 = str.indexOf("v", 3);         // -1

int indexOf(String str)

주어진 문자열이 존재하는 지 확인하여 그 위치(index)를 알려준다. 없으면 -1을 반환한다.

String str = "abcdefg";
int id = str.indexOf("cd");            // 2

String intern()

문자열을 상수풀(constant pool)에 등록한다.

이미 상수풀에 같은 내용의 문자열이 있을 경우 그 문자열의 주소값을 반환한다.

String s1 = new String("love");
String s2 = new String("love");

boolean b1 = (s1 == s2);                    // false
boolean b2 = s1.equals(s2);                 // true
boolean b3 = (s1.intern() == s2.intern());  // true

int lastIndexOf(int ch)

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

String s = "si vis amari, ama";
int lio1 = s.lastIndexOf('a');         // 16
int lio2 = s.indexOf('a');             // 7

int length()

문자열의 길이를 알려준다.

String s = "si vis amari, ama";
int l = s.length();                    // 17

String replace(CharSequence target, CharSequence replacement)

문자열 중에서 지정된 문자열(target)을 새로운 문자열(replacement)로 모두 바꾼 문자열을 반환한다.

String s1 = "lovelove";
String s2 = s1.replace("ve", "ol");    // "loollool"

String replace(char oldChar, char newChar)

문자열 중에서 지정된 문자(oldChar)를 새로운 문자(newChar)로 바꾼 문자열을 반환한다.

String s1 = "love";
String s2 = s1.replace('l', 'L');      // "Love"

String replaceAll(String regex, String replacement)

문자열 중에서 지정된 문자열(regex)과 일치하는 것을 새로운 문자열(replacement)로 모두 변경한다.

String s1 = "lovelove";
String s2 = s1.replaceAll("ve", "ol");      // "loollool"

String replaceFirst(String regex, String replacement)

문자열 중에서 지정된 문자열(regex)과 일치하는 것 중, 첫 번째 것만 새로운 문자열로 변경한다.

String s1 = "lovelove";
String s2 = s1.replaceFirst("ov", "if");    // "lifelove"

String[] split(String regex)

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

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

String[] split(String regex, int limit)

문자열을 지정된 분리자로 나누되, 문자열 전체를 지정된 수로 잘라 문자열 배열에 담아 반환한다.

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

• join(CharSuquence delimiter, Object[] token)
  

    여러 문자열 사이에 구분자를 넣어서 결합한다.

    구분자로 문자열을 가르는 split()과 반대의 작업을 한다. (JDK1.8부터 추가)

String[] animals = {"dog", "cat", "wolf"};
String str = TextUtils.join("-", animals);      //dog-cat-wolf

boolean startsWith(String prefix)

주어진 문자열로 시작하는 지 검사한다.

String s = "si vis amari, ama";
boolean b = s.startsWith("vis");    // false

String substring(int beginIndex)

substring(int beginIndex, int endIndex)

주어진 시작 위치(beginIndex)부터 끝 위치(endIndex) 범위에 포함된 문자열을 얻는다.

시작 위치의 문자는 범위에 포함되지만, 끝 위치의 문자는 포함되지 않는다. (begin <= x < end)

String s = "si vis amari, ama";
String ss1 = s.substring(7);           // "amari, ama"
String ss2 = s.substring(7, 12);       // "amari"

• 여기서의 위치는 cursor가 가리키는 위치를 말한다. 따라서 끝 위치의 문자가 포함되지 않는다.

      - beginIndex = 7 : si vis ^amari, ama   (^ : cursor)

      - endIndex = 12 : si vis amari^, ama

String toLowerCase()

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

String s = "Si Vis Amari, Ama";
String tl = s.toLowerCase();              // "si vis amari, ama"

String toString()

String 인스턴스에 저장되어 있는 문자열을 반환한다.

String s = "Love";
String ts = s.toString();              // "Love"

String toUpperCase()

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

String s = "Si Vis Amari, Ama";
String tu = s.toUpperCase();   // "SI VIS AMARI, AMA"

String trim()

문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환한다.

문자열 중간에 있는 공백은 제거되지 않는다.

String s = " Love Field ";
String result = s.trim();              // "Love Feild"

valueOf()

기본형 값을 String으로 변환.

주어진 값을 문자열로 변환하여 반환한다.

참조 변수의 경우, toString()을 호출한 결과를 반환한다.

빈 문자열("")을 더하는 방법이 더 간단하고 편하기 때문에 성능향상이 필요한 경우에만 사용한다.

static String valueOf(boolean b)
static String valueOf(double d)
static String valueOf(char[] data, int offset, int count)
static String valueOf(float f)
static String valueOf(int i)
static String valueOf(char c)
static String valueOf(long l)
static String valueOf(Object o)
static String valueOf(char[] data)

String b = String.valueOf(true);       // true
String d = String.valueOf(10.0);       // 10.0

char[] arr = new char[] { 'l', 'o', 'v', 'e' };
String ca1 = String.valueOf(arr, 1, 2);     // ov

String f = String.valueOf(10f);        // 10.0
String i = String.valueOf(2);          // 2
String c = String.valueOf('l');        // 1
String l = String.valueOf(1043L);      // 1043

Date date = new Date();
String o = String.valueOf(date);       // Mon Aug 14 12:06:59 GMT+09:00 2017

String ca2 = String.valueOf(arr);      // love

• String을 기본형 값으로 변환하기
  

     타입.parse타입() ,  valueOf()

     메서드의 이름을 통일하기 위해 valueOf()가 나중에 추가되었다.

     두 메서드는 반환 타입만 다를 뿐 같은 메서드다.

     parse타입()은 문자열에 공백이나 문자가 포함되어 있는 경우,

     변환 시 예외(NumberFormatException)가 발생할 수 있기 때문에 trim()과 같이 사용하는 것이 좋다.

     parse타입()은 부호(+)나, 소수점(.), 자료형 접미사는 자료형에 알맞은 변환을 하는 경우에 사용 가능하다.

Boolean.parseBoolean(String s)
Byte.parseByte(String s)
Short.parseShort(String s)
Integer.parseInt(String s)
Long.parseLong(String s)
Float.parseFloat(String s)
Double.parseDouble(String s)

     Integer.valueOf()는 반환 타입이 Integer지만 오토박싱에 의해 int로 자동 변환된다.

String API

참고 서적: 자바의 정석 3판