[Java] String 클래스 메서드 (자바의 정석)

 

 

---

String 클래스 특징 

1) char[]와 메서드(기능)을 결합한 것이다

String 클래스 = char[] + 메서드(기능)

- char[] : 문자열 배열
- String 클래스 생성시 heap에 실제 값(문자열)이 저장되고 stack 변수에는 참조 주소값을 가짐

2) 내용을 변경할 수 없다 (read only*)

문자의 결합을 하면 새로운 문자로 바뀌고 새로운 참조 주소를 가짐

 

 

 

String 클래스의 주요 메서드

참고. substring(int from, int to)

"hamburger".substring(4, 8) returns "urge"
"smiles".substring(1, 5) returns "mile"

- 문자열 인덱스는 0번 부터 시작
- from : inclusive (포함)
- to : exclusive(제외)

 

 

참고. 동등성(identity)과 동일성(equality

 

동일성 (equality, ==)	동등성 (identity, equals())
- primitive type의 값이 동일하다 - Reference type의 경우 참조 주소 값이 동일하다 (객체 내부의 값을 비교 x)	- Reference type의 참조 주소값이 다르더라도, 객체의 필드 값이 같다면 동등하다고 말한다.  - 기본적으로 Reference Type은 Object 클래스 상속 받는데 Object.equals()는 기본적으로 동일성(==)만 확인하기 때문에, 필요에 따라 오버라이딩하여 메서드를 재정의 해줘야 동등성의 기능을 수행한다.

 

Object 클래스

public boolean equals(Object obj) {
        return this == obj; // 기본적으로 동일성만 비교한다
}

 

https://steady-coding.tistory.com/534

[Java] 동일성(identity)과 동등성(equality)

 

---

Static Method 정리

 

equals(Object anObject)

비교하는 문자열이 현재 문자열과 동등한지 확인하여 boolean형 결과 반환한다

@Test
void equalsTest() {
    // given
    String text = "test";

    // when
    String compare = "text";

    // then
    assertThat(text).isEqualTo("test");
    assertThat(text.equals(compare)).isFalse();
}

 

 

length()

문자열의 길이를 반환한다

@Test
void lengthTest() {
    // given
    String test = "hello world";

    // when
    int result = test.length();

    // then
    assertThat(result).isEqualTo(11);
}

 

 

substring(..)

문자열에서 사용자 지정 범위 만큼을 잘라 새로운 문자열을 반환한다

- from : 시작 위치 

- to : 종료 위치 (exclusive, 제외)

- 예로 from : 1, to : 10 인경우 1 ~ 9 번 인덱스만 처리

@Test
void substringTest() {
    // given
    String text = "schoolOfRock";

    // when
    // then
    assertThat(text.substring(0)).isEqualTo(text);
    assertThat(text.substring(0, 6)).isEqualTo("school");
}

 

 

split(String regex)

문자열에서 정규 표현식(regex)를 기준으로 나숴 String[] 을 반환한다

@Test
void splitTest() {
    // given
    String test = "hello world";

    // when
    String[] result = test.split(" ");

    // then
    assertThat(result).hasSize(2);
    assertThat(result).containsExactly("hello", "world");
    assertThat(Arrays.toString(result)).isEqualTo("[hello, world]");
}

 

 

valueOf(..)

primitive type 값을 String 으로 바꿔서 반환한다

@Test
void valueOfTest() {
    // given
    int value = 1004;

    // when
    String result = "1004";

    // then
    assertThat(String.valueOf(value)).isEqualTo(result);
}

 

 

compareTo(String anotherString)

- 현재 문자열과 인자로 전달받은 문자열을 비교(=문자열 코드값)하여 int 값을 반환한다

- 결과값이 positive 인 경우 현재 문자열이 비교 문자열보다 코드 값이 크다는 뜻

- 결과값이 negative인 경우 현재 문자열이 비교 문자열보다 코드 값이 작다는 뜻

- 문자열 정렬에 사용

 

@Test
void compareToTest() {
    // given , A - Z : 65 ~ 90 , a ~ z : 97 ~ 122
    String alphabet1 = "A";
    String alphabet2 = "b";
    String alphabet3 = "C";

    // when
    // then
    assertThat(alphabet1.compareTo(alphabet2)).isNegative(); // A < b , 음수값
    assertThat(alphabet3.compareTo(alphabet1)).isPositive(); // C > A , 양수값
}

 

 

contains(CharSequence s)

- 문자열에 검색할 문자가 있는지 확인하여 boolean 형 결과를 리턴한다 

- 내부적으로 indexOf()를 호출

@Test
void containsTest() {
    // given
    String text = "Let it be";

    // when
    // then
    assertThat(text.contains("a")).isFalse(); // 내부적으로 indexOf 호출하여 >= 0 이상이면 true 아니면 false
    assertThat(text.contains("L")).isTrue();
    assertThat(text.contains("b")).isTrue();
}

 

 

startWith(String prefix)

- 문자열의 시작이 prefix인지 확인 후 boolean 결과값 리턴

- 대소문자 구분

@Test
void startWithTest() {
    // given
    String text = "Beautiful";

    // when
    // then
    assertThat(text.startsWith("Be")).isTrue();
    assertThat(text.startsWith("b")).isFalse();
}

 

 

endWith(String suffix)

- 문자열의 끝이 suffix인지 확인 후 boolean 결과값 리턴

- 대소문자 구분

@Test
void endWithTest() {
    // given
    String text = "test";

    // when
    // then
    assertThat(text.endsWith("t")).isTrue();
    assertThat(text.endsWith("T")).isFalse();
}

 

 

indexOf(String str)

문자열에 찾으려는 str의 첫번째 인덱스 위치 값을 반환 (없으면 -1)

@Test
void indexOfTest() {
    // given
    String text = "hello world";

    // when
    // then
    assertThat(text.indexOf("o")).isEqualTo(4);
    assertThat(text.indexOf("l")).isEqualTo(2);
    assertThat(text.indexOf("a")).isEqualTo(-1);
}

 

 

lastIndexOf()

문자열에 찾으려는 str의 마지막 인덱스 위치 값을 반환 (없으면 -1)

@Test
void lastIndexOfTest() {
    // given
    String text = "hello world";

    // when
    // then
    assertThat(text.lastIndexOf("l")).isEqualTo(9);
    assertThat(text.lastIndexOf("o")).isEqualTo(7);
    assertThat(text.lastIndexOf("a")).isEqualTo(-1);
}

 

 

matched()

정규 표현식을 사용하여 문자열 형식이 올바른지 판별한다 (true/false)

@Test
void matchedTest() {
    // given
    String text = "fileName09.txt";

    // when
    // then
    assertThat(text.matches("^([a-zA-Z0-9])+\\.(txt)$")).isTrue();
}

 

참고. https://dev-ljw1126.tistory.com/161

정규 표현식 문법 정리

 

 

toLowerCase()

모든 문자열을 소문자로 치환한다

@Test
void toLowerCaseTest() {
    // given
    String text = "TEST";

    // when
    String result = "test";

    // then
    assertThat(text.toLowerCase()).isEqualTo(result);
}

 

 

toUpperCase()

모든 문자열을 대문자로 치환한다

@Test
void toUpperCaseTest() {
    // given
    String text = "test";

    // when
    String result = "TEST";

    // then
    assertThat(text.toUpperCase()).isEqualTo(result);
}

 

 

trim()

문자열의 양쪽 끝 공백을 제거한다

@Test
void trimTest() {
    // given
    String text = " Hello World ";

    // when
    String result = "Hello World";

    // then
    assertThat(text.trim()).isEqualTo(result);
}

 

 

replace(CharSequence target, CharSequence replacement)

target 인자에 해당하는 문자열을 모두 치환

@Test
void replaceTest() {
    // given
    String text = "Hello";

    // when
    // then
    assertThat(text.replace("l", "L")).isEqualTo("HeLLo");
}

 

 

replaceAll(String regex, String replacement)

정규식을 만족하는 문자열 모두 치환

@Test
void replaceAllTest() {
    // given
    String text = "홍길동 님이 입장하셨습니다";

    // when
    String result = "홍길동님이입장하셨습니다";

    // then
    assertThat(text.replaceAll("\\s", "")).isEqualTo(result); // white space 제거
}

 

 

replaceFirst(String regex, String replacement)

정규식을 만족하는 문자열 중 첫번째만 치환 

@Test
void replaceFirstTest() {
    // given
    String text = "how+to+do+this";

    // when
    String result = "howto+do+this";

    // then
    assertThat(text.replaceFirst("\\+", "")).isEqualTo(result);
}

 

참고. replace , replaceAll, replaceFirst 차이 정리

- replace의 경우 target 인자에 해당하는 문자열 모두 치환 

- replaceAll  과 replaceFirst 는 정규식을 만족하는 문자열 모두를 치환

- replaceAll의 경우 정규식을 만족하는 전체 문자열을 치환하고, replaceFirst는 첫번째만 치환

 

 

format(String format, Object... args)

사용자 지정 문자열 포맷 형식에 따라 값을 맵핑하여 결과값 출력

@Test
void format() {
    // given
    int a = 1;
    int b = 2;

    // when
    String result = "1 + 2 = 3";

    // then
    assertThat(String.format("%s + %s = %s", a, b, a + b)).isEqualTo(result);
}

 

 

concat(String str)

현재 문자열과 인자로 받은 문자열을 연결한다

@Test
void concat() {
    // given
    String a = "Summer";
    String b = "Sonic";

    // when
    String result = a.concat(b);

    // then
    assertThat(result).isEqualTo("SummerSonic");
}