Class String

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#getBytes--

java.lang.Object 클래스

• 모든 클래스의 최상위 부모 클래스
• JAVA에서 정의된 모든 객체는 Ojbect 클래스를 상속받음1. Clone() : 객체의 복제본 생성3. getClass() : 객체의 런타임 클래스 정보 반환5. notifyAll() : 대기 중인 모든 스레드를 깨움7. wait(long timeout) : 지정된 시간 동안 대기
• 8. wait(long timeout, int nanos) : 지정된 시간과 나노초 동안 대기
• 6. wait() : 현재 스레드를 대기 상태로 만듦
• 4. notify() : 대기 중인 스레드 중 하나를 깨움
• 2. finalize() : 객체가 메모리에서 제거되기 전에 정리 작업 수행

public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence

• String 클래스는 문자 문자열을 나타냄
• JAVA 프로그램에서 사용되는 모든 문자 리터럴은 String 클래스의 인스턴스(객체)로 만들어짐
• "abc"라는 문자열을 코드에 작성하면 JAVA는 이 문자열을 String 클래스의 객체로 처리함

java.lang.CharSequence Interface

• JAVA에서 문자열과 관련된 다양한 클래스가 구현하는 인터페이스
• 문자 시퀀스를 다루기 위한 여러 메소드 정의
• CharSequence를 구현하는 가장 일반적인 구현체는 String, StringBuilder, StringBuffer임
• 읽기 전용 인터페이스라 문자열을 읽기 위한 메소드만 정의되어 있고 수정하는 메소드는 포함되어 있지 않음
• 문자 데이터 처리 시 유니코드 문자도 지원함

1. chars()

• IntStream을 반환하며 CharSequence의 각 문자를 int값으로 표현한 스트림 생성
• 문자 시퀀스의 각 문자에 대해 반복 작업을 수행하거나 문자 데이터를 처리할 때 유용

2. codePoints()

• IntStream을 반환하며, CharSequence의 각 문자에 대한 유니코드 코드 포인트의 스트림을 생성
• chars()보다 더 많은 문자(2개의 char로 구성된 문자)를 처리
• 유니코드 문자의 코드 포인트(유니코드에서 특정 문자를 나타내기 위해 사용하는 고유한 정수 값)에 대한 작업을 수행할 때 유용

String 클래스

• 모든 객체(String 객체 포함)는 Object Class를 상속받음(java.lang.Object)

1. 문자열 리터럴

• 코드에 직접 쓰는 문자열을 의미
• 큰따옴표로 둘러싸인 문자열이 이에 해당
• JAVA는 문자열 리터럴을 생성할 때 자동으로 String 객체를 만들어 메모리에 저장

2. Immutability(불변성)

• 상수 문자열 : String 객체는 불변임
• 문자열이 생성된 후에는 그 값을 변경할 수 없음
• "abc"라는 문자열을 생성하면 그 문자열의 내용은 변경할 수 없음

3. String Buffer

• 가변 문자열 : 문자열의 값을 변경해야 할 경우에는 StringBuffer 또는 StringBuilder 클래스를 사용하면 됨
• StringBuffer와 StringBuilder는 mutable(가변) 문자열을 지원하며, 문자열 내용을 변경할 수 있음

package day2;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class StringBufferExample {
    private static final Logger logger = LoggerFactory.getLogger(StringSharingExample.class);

    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();

        sb.append("하나");
        logger.info(sb.toString()); //print문은 toString() 메서드가 자동으로 호출되기 때문에 sb 자체를 출력해도 됨
        sb.append("둘");
        logger.info(sb.toString());
        sb.replace(0, 2, "다섯");
        logger.info(sb.toString());
    }

}

4. 문자열 공유

• 문자열이 불변이기 때문에 동일한 문자열 값을 가진 여러 객체가 메모리에서 공유될 수 있음
• String str = "abc"에서, "abc"라는 문자열이 메모리에 저장되면, 다른 곳에서 같은 문자열을 사용할 때 같은 메모리 주소를 참조

package day2;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class StringSharingExample {
    private static final Logger logger = LoggerFactory.getLogger(StringSharingExample.class);

    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        String str3 = new String("abc");

        logger.info("str1의 주소 : {}", System.identityHashCode(str1));
        logger.info("str2의 주소 : {}", System.identityHashCode(str2));
        logger.info("str3의 주소 : {}", System.identityHashCode(str3));

        logger.info("str1과 str2의 주소는 같은가? : {}", (str1 == str2));
        logger.info("str2와 str3의 주소는 같은가? : {}", (str2 == str3));
    }
}

String Class Method

Class

• 객체를 만들기 위한 설계도

구조

class  클래스명{ }

Package ...; // 패키지
import ...; // 임포트
class 클래스명 {}; // 외부 클래스

public class A{
    int a = 3; // 필드
    double ab() {...}; // 메소드
    A(); // 생성자
    class B {...}; // 이너 클래스
}

1. Field(필드)

Modifier and Type	Field and Description
static Comparator<String>	CASE_INSENSITIVE_ORDER : compareToIgnoreCase에 의해 String 객체를 정렬하는 Comparator

• 클래스의 중괄호 안에 선언된 변수
• 클래스 중괄호 내 어디서든 사용 가능하며, 힙 영역 객체 내부에 저장됨
• 객체의 속성을 정의하는 공간
• class variable(클래스 변수, cv), instance variable(인스턴스 변수, iv), local variable(지역 변수, lv) 중 cv와 iv만 필드에서 다룸
• class variable(=static variable) : 필드 내에서 static 키워드와 함께 선언된 변수
• instance variable : 필드 내에서 선언된 변수
• class Variable { static int classVariable; //클래스 변수 int instanceVariable; //인스턴스 변수 void variableMethod() { int localVariable; //지역 변수 } }

2. Method(메소드)

• 클래스 내부에 정의된 함수
• 특정 작업을 수행하는 코드 블록
• 객체의 속성을 조작하거나 특정 기능을 수행
• 호출 시 실행됨
• 클래스가 메모리에 로드될 때 생성됨(클래스가 실행될 준비가 되었을 때 메소드의 정의가 메모리에 존재)

자바제어자 리턴타입 메소드명(매개변수명) {
    메서드 내용
}

3. Constructor(생성자)

• 클래스의 인스턴스(객체)를 생성할 때 호출되는 특수한 메소드
• 객체가 생성될 때 초기화를 위해 사용됨
• 클래스 이름과 동일한 이름을 가지며 반환 타입이 없음
• 객체가 생성될 때 자동으로 호출되며, 인스턴스 변수를 초기화하는 데 주로 사용됨
• 인스턴스가 생성될 때 호출됨(new 키워드를 사용하여 클래스의 인스턴스를 생성할 때 실행됨)
• 인스턴스가 메모리에 할당되고 초기화되는 시점에 호출됨

접근제어자 클래스명(매개변수타입 매개변수명) {
    //생성자 내용
}

String() : 새로 생성된 String 객체를 초기화하여 빈 문자 시퀀스를 나타냄

String(byte[] bytes) : 지정된 바이트 배열을 플랫폼의 기본 문자 집합을 사용하여 디코딩하여 새 문자열을 생성

String(byte[] bytes, Charset charset) : 지정된 바이트 배열을 지정된 문자 집합을 사용하여 디코딩하여 새 문자열을 생성

String(byte[] bytes, int offset, int length) : 지정된 바이트 배열의 특정 부분을 플랫폼의 기본 문자 집합을 사용하여 디코딩하여 새 문자열을 생성

String(byte[] bytes, int offset, int length, String charsetName) : 지정된 바이트 배열의 특정 부분을 지정된 문자 집합 이름을 사용하여 디코딩하여 새 문자열을 생성

String(byte[] bytes, String charsetName) : 지정된 바이트 배열을 지정된 문자 집합을 사용하여 디코딩하여 새 문자열을 생성

String(char[] value) : 주어진 문자 배열의 현재 문자 시퀀스를 나타내는 새 문자열을 생성

String(char[] value, int offset, int count) : 주어진 문자 배열의 특정 부분에서 문자를 포함하는 새 문자열을 생성

String(int[] codePoints, int offset, int count) : 유니코드 코드 포인트 배열의 특정 부분에서 문자를 포함하는 새 문자열을 생성

String(String original) : 주어진 문자열과 동일한 문자 시퀀스를 나타내는 새 문자열 객체를 초기화. 새로 생성된 문자열은 인수 문자열의 복사본

String(StringBuffer buffer) : 주어진 문자열 버퍼에 현재 포함된 문자 시퀀스를 기반으로 새 문자열을 생성

String(StringBuilder builder) : 주어진 문자열 빌더에 현재 포함된 문자 시퀀스를 기반으로 새 문자열을 생성

package day2;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class StringConstructorExample {

    private static final Logger logger = LoggerFactory.getLogger(StringSharingExample.class);

    public static void main(String[] args) throws UnsupportedEncodingException {
        // String()
        String emptyString = new String();
        logger.info("빈 문자열 : " + emptyString);

        // String(byte[] bytes)
        byte[] byteArray = { 65, 66, 67 }; //A,B,C
        String fromByteArray = new String(byteArray);
        logger.info("바이트 배열로 생성된 문자열 : " + fromByteArray);

        // String(byte[] bytes, Charset charset)
        String fromByteArrayWithCharset = new String(byteArray, Charset.forName("UTF-8"));
        logger.info("문자 집합으로 생성된 문자열 : " + fromByteArrayWithCharset);

        // String(byte[] bytes, int offset, int length)
        String subArrayString = new String(byteArray, 1, 2);
        logger.info("바이트 배열의 특정 부분으로 생성된 문자열 : " + subArrayString);

        // String(byte[] bytes, int offset, int length, String charsetName)
        String subArrayWithCharsetName = new String(byteArray, 0, 3, "UTF-8");
        System.out.println("문자 집합 이름으로 생성된 문자열 : " + subArrayWithCharsetName);

        // String(byte[] bytes, String charsetName)
        String fromByteArrayWithName = new String(byteArray, "UTF-8");
        System.out.println("문자 집합 이름으로 생성된 문자열 : " + fromByteArrayWithName);

        // String(char[] value)
        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
        String fromCharArray = new String(charArray);
        System.out.println("문자 배열로 생성된 문자열 : " + fromCharArray);

        // String(char[] value, int offset, int count)
        String subCharArrayString = new String(charArray, 1, 3); // e, l, l
        System.out.println("문자 배열의 특정 부분으로 생성된 문자열 : " + subCharArrayString);

        // String(int[] codePoints, int offset, int count)
        int[] codePoints = {72, 101, 108, 108, 111}; // H, e, l, l, o
        String fromCodePoints = new String(codePoints, 0, codePoints.length);
        System.out.println("유니코드 코드 포인트 배열로 생성된 문자열 : " + fromCodePoints);

        // String(String original)
        String originalString = "Original String";
        String copyString = new String(originalString);
        System.out.println("복사된 문자열 : " + copyString);

        // String(StringBuffer buffer)
        StringBuffer stringBuffer = new StringBuffer("StringBuffer");
        String fromStringBuffer = new String(stringBuffer);
        System.out.println("StringBuffer로 생성된 문자열 : " + fromStringBuffer);

        // String(StringBuilder builder)
        StringBuilder stringBuilder = new StringBuilder("StringBuilder");
        String fromStringBuilder = new String(stringBuilder);
        System.out.println("StringBuilder로 생성된 문자열 : " + fromStringBuilder);

    }

}

String Class의 주요 Method

char charAt(int index) : 지정된 인덱스에 있는 문자 값(16비트의 char)을 반환. 주로 기본 아스키문자에 대해 사용

int codePointAt(int index) : index번째의 문자(유니코드 코드포인트)를 반환. 모든 유니코드 문자에 대해 사용될 수 있으며, 이모지와 같은 복합 문자를 정확하게 처리할 수 있음

int codePointBefore(int index) : index-1번째의 문자 반환

int codePointCount(int beginIndex, int endIndex) : beginIndex부터 endIndex-1의 범위에 해당하는 코드 포인트의 수 반환

String str = "A😊"; // A는 1 code point, 😊는 1 code point로 표현됨
int count = str.codePointCount(0, 2); // 'A'와 '😊'를 포함
System.out.println(count); // 출력: 2

int compareTo(String anotherString) : 두 문자열을 사전식으로 비교

int compareToIgnoreCase(String str) : 대소문자를 무시하고 두 문자열을 사전식으로 비교

String concat(String str) : 지정된 문자열을 현재 문자열의 끝에 추가하여 새 문자열을 반환

boolean contains(CharSequence s) : 현재 문자열이 지정된 문자 시퀀스를 포함하는지 여부를 반환

boolean contentEquals(CharSequence cs) : 현재 문자열과 지정된 CharSequence를 비교

boolean contentEquals(StringBuffer sb) : 현재 문자열과 지정된 StringBuffer를 비교

static String copyValueOf(char[] data) : 주어진 문자 배열을 문자열로 변환. valueOf(char[])와 동일

static String copyValueOf(char[] data, int offset, int count) : 주어진 문자 배열의 특정 부분을 문자열로 변환. valueOf(char[], int, int)와 동일. offset번 방에 있는 문자열부터 count개

public class CopyValueOfExample {
    public static void main(String[] args) {
        // 문자 배열 생성
        char[] data = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!'};

        // offset = 0, count = 5
        String str1 = String.copyValueOf(data, 0, 5); // "Hello"
        System.out.println("첫 번째 문자열: " + str1);

        // offset = 6, count = 5
        String str2 = String.copyValueOf(data, 6, 5); // "World"
        System.out.println("두 번째 문자열: " + str2);

        // offset = 11, count = 1
        String str3 = String.copyValueOf(data, 11, 1); // "!"
        System.out.println("세 번째 문자열: " + str3);
    }
}

boolean endsWith(String suffix) : 현재 문자열이 지정된 접미사로 끝나는지 여부를 테스트

boolean equals(Object anObject) : 현재 문자열과 지정된 객체를 비교

boolean equalsIgnoreCase(String anotherString) : 대소문자를 무시하고 현재 문자열과 다른 문자열을 비교

static String format(Locale l, String format, Object... args) : 지정된 로케일(특정 언어와 지역을 나타내는 정보) 및 형식 문자열을 사용하여 형식화된 문자열을 반환

import java.util.Locale;

public class FormatExample {
    public static void main(String[] args) {
        // 미국 로케일
        Locale usLocale = Locale.US;
        String usFormatted = String.format(usLocale, "Hello, %s! Your balance is $%.2f.", "Alice", 1234.56);
        System.out.println("미국 형식화: " + usFormatted);

        // 독일 로케일
        Locale germanyLocale = Locale.GERMANY;
        String germanyFormatted = String.format(germanyLocale, "Hallo, %s! Ihr Kontostand ist %.2f €.", "Bob", 1234.56);
        System.out.println("독일 형식화: " + germanyFormatted);
    }
}

미국 형식화: Hello, Alice! Your balance is $1234.56.
독일 형식화: Hallo, Bob! Ihr Kontostand ist 1234,56 €.

static String format(String format, Object... args) : 지정된 형식 문자열을 사용하여 형식화된 문자열을 반환

public class FormatExample {
    public static void main(String[] args) {
        // 문자열 형식화 예시
        String name = "Alice";
        int age = 30;
        double balance = 1234.56;

        // 형식 문자열을 사용하여 문자열 생성
        String formattedString = String.format("이름: %s, 나이: %d, 잔액: $%.2f", name, age, balance);
        System.out.println(formattedString);
    }
}

이름: Alice, 나이: 30, 잔액: $1234.56

byte[] getBytes() : 현재 문자열을 플랫폼의 기본 문자 집합을 사용하여 바이트 배열로 인코딩

import java.nio.charset.StandardCharsets;

public class GetBytesExample {
    public static void main(String[] args) {
        // 문자열 생성
        String originalString = "Hello, World!";

        // 문자열을 바이트 배열로 변환
        byte[] byteArray = originalString.getBytes();

        // 바이트 배열 출력
        System.out.println("원본 문자열: " + originalString);
        System.out.print("바이트 배열: ");
        for (byte b : byteArray) {
            System.out.print(b + " ");
        }
        System.out.println();

        // 바이트 배열을 다시 문자열로 변환
        String convertedString = new String(byteArray);
        System.out.println("변환된 문자열: " + convertedString);
    }
}

원본 문자열: Hello, World!
바이트 배열: 72 101 108 108 111 44 32 87 111 114 108 100 33 
변환된 문자열: Hello, World!

byte[] getBytes(Charset charset) : 현재 문자열을 지정된 문자 집합을 사용하여 바이트 배열로 인코딩

byte[] getBytes(String charsetName) : 현재 문자열을 지정된 문자 집합 이름을 사용하여 바이트 배열로 인코딩

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) : 문자열의 srcBegin번째 인덱스부터 srcEnd까지의 문자를 dst의 dstBegin 인덱스부터 복사

public class GetCharsExample {
    public static void main(String[] args) {
        // 원본 문자열
        String originalString = "Hello, World!";

        // 복사할 문자 배열 생성
        char[] destinationArray = new char[5]; // 복사할 공간을 위한 배열

        // 문자열의 0번 인덱스부터 5번 인덱스까지의 문자를 destinationArray의 0번 인덱스부터 복사
        originalString.getChars(0, 5, destinationArray, 0);

        // 복사된 문자 배열을 문자열로 변환하여 출력
        String copiedString = new String(destinationArray);
        System.out.println("복사된 문자열: " + copiedString); // "Hello"
    }
}

복사된 문자열: Hello

int hashCode() : 현재 문자열의 해시 코드를 반환

int indexOf(int ch) : 현재 문자열에서 지정된 문자의 첫 번째 발생 인덱스를 반환

int indexOf(int ch, int fromIndex) : 현재 문자열에서 지정된 문자의 첫 번째 발생 인덱스를 지정된 인덱스부터 검색

int indexOf(String str) : 현재 문자열에서 지정된 부분 문자열의 첫 번째 발생 인덱스를 반환

int indexOf(String str, int fromIndex) : 현재 문자열에서 지정된 부분 문자열의 첫 번째 발생 인덱스를 지정된 인덱스부터 검색

String intern() : 문자열 객체의 정규 표현을 반환

boolean isEmpty() : 문자열의 길이가 0인지 여부를 반환

static String join(CharSequence delimiter, CharSequence... elements) : 지정된 구분자를 사용하여 주어진 CharSequence 요소들을 결합하여 새로운 문자열을 반환

static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) : 지정된 구분자를 사용하여 주어진 CharSequence 요소들을 결합하여 새로운 문자열을 반환

int lastIndexOf(int ch) : 현재 문자열에서 지정된 문자의 마지막 발생 인덱스를 반환

int lastIndexOf(int ch, int fromIndex) : 현재 문자열에서 지정된 문자의 마지막 발생 인덱스를 지정된 인덱스부터 역으로 검색

int lastIndexOf(String str) : 현재 문자열에서 지정된 부분 문자열의 마지막 발생 인덱스를 반환

int lastIndexOf(String str, int fromIndex) : 현재 문자열에서 지정된 부분 문자열의 마지막 발생 인덱스를 지정된 인덱스부터 역으로 검색

int length() : 현재 문자열의 길이를 반환

boolean matches(String regex) : 현재 문자열이 주어진 regex(정규 표현식)과 일치하는지 여부를 반환

int offsetByCodePoints(int index, int codePointOffset) : index에서 codePointOffset만큼 이동한 인덱스를 반환. 양수이면 오른쪽으로 이동, 음수이면 왼쪽으로 이동

boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) : 대소문자를 무시할지를 결정(true면 대소문자 무시, false이면 대소문자 구분)한 후 첫 번째 문자열의 시작 인덱스인 toffset부터 시작하여 비교할 문자열 other의 offset 인덱스부터 비교를 시작. len개의 수 만큼 비교

boolean regionMatches(int toffset, String other, int ooffset, int len) : toffset은 첫 번째 문자열에서 비교를 시작할 인덱스, other은 비교할 두 번째 문자열, ooffset은 두 번째 문자열에서 비교를 시작할 인덱스, len은 비교할 문자 수

String replace(char oldChar, char newChar) : 현재 문자열에서 모든 oldChar를 newChar로 교체하여 새로운 문자열을 반환

String replace(CharSequence target, CharSequence replacement) : 현재 문자열에서 일치하는 부분 문자열을 지정된 대체 문자열로 교체

String replaceAll(String regex, String replacement) : 주어진 정규 표현식과 일치하는 모든 부분 문자열을 지정된 대체 문자열로 교체

String replaceFirst(String regex, String replacement) : 주어진 정규 표현식과 일치하는 첫 번째 부분 문자열을 지정된 대체 문자열로 교체

String[] split(String regex) : 주어진 정규 표현식에 따라 문자열을 분할하여 문자열 배열을 반환

String[] split(String regex, int limit) : 주어진 정규 표현식에 따라 문자열을 분할하여 문자열 배열을 반환. limit 매개변수로 분할 횟수를 제한할 수 있음

boolean startsWith(String prefix) : 현재 문자열이 지정된 접두사로 시작하는지 여부를 테스트

boolean startsWith(String prefix, int toffset) : 접두사 문자열인 prefix에서 toffset의 인덱스부터 비교를 시작하여 동일한지 비교

CharSequence subSequence(int beginIndex, int endIndex) : beginIndex부터 endIndex까지를 반환

String substring(int beginIndex) : 현재 문자열의 지정된 인덱스부터 끝까지의 부분 문자열을 반환

String substring(int beginIndex, int endIndex) : 현재 문자열의 지정된 인덱스 범위 내의 부분 문자열을 반환

char[] toCharArray() : 현재 문자열을 새 문자 배열로 변환

public class ToCharArrayExample {
    public static void main(String[] args) {
        // 문자열 생성
        String str = "Hello, World!";

        // 문자열을 문자 배열로 변환
        char[] charArray = str.toCharArray();

        // 문자 배열 출력
        System.out.println("원본 문자열: " + str);
        System.out.print("문자 배열: ");
        for (char c : charArray) {
            System.out.print(c + " ");
        }
        System.out.println();
    }
}

원본 문자열: Hello, World!
문자 배열: H e l l o ,   W o r l d ! 

String toLowerCase() : 현재 문자열의 모든 문자를 소문자로 변환하여 반환

String toLowerCase(Locale locale) : 지정된 로케일의 규칙에 따라 문자열의 모든 문자를 소문자로 변환하여 반환

String toString() : 현재 객체(문자열)를 반환

String toUpperCase() : 현재 문자열의 모든 문자를 대문자로 변환하여 반환

String toUpperCase(Locale locale) : 지정된 로케일의 규칙에 따라 문자열의 모든 문자를 대문자로 변환하여 반환

String trim() : 현재 문자열의 앞뒤 공백을 제거하여 새로운 문자열을 반환

static String valueOf(boolean b) : 불리언 인수의 문자열 표현을 반환

public class ValueOfExample {
    public static void main(String[] args) {
        boolean flagTrue = true;
        boolean flagFalse = false;

        // 불리언 값을 문자열로 변환
        String strTrue = String.valueOf(flagTrue);
        String strFalse = String.valueOf(flagFalse);

        // 결과 출력
        System.out.println("불리언 true의 문자열 표현: " + strTrue);   // "true"
        System.out.println("불리언 false의 문자열 표현: " + strFalse); // "false"
    }
}

불리언 true의 문자열 표현: true
불리언 false의 문자열 표현: false

static String valueOf(char c) : 문자를 문자열로 반환(char를 string으로)

static String valueOf(char[] data) : 주어진 문자 배열의 모든 문자를 연결하여 하나의 문자열로 만듦

public class ValueOfCharArrayExample {
    public static void main(String[] args) {
        // 문자 배열 생성
        char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!'};

        // 문자 배열을 문자열로 변환
        String str = String.valueOf(charArray);

        // 결과 출력
        System.out.println("문자 배열의 문자열 표현: " + str); // "Hello World!"
    }
}

문자 배열의 문자열 표현: Hello World!

static String valueOf(char[] data, int offset, int count) : data배열의 offset부터 count개 만큼 변환

public class ValueOfCharArrayPartialExample {
    public static void main(String[] args) {
        // 문자 배열 생성
        char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!'};

        // 문자 배열의 특정 부분을 문자열로 변환
        String str = String.valueOf(charArray, 6, 5); // offset 6에서 시작하여 5개의 문자

        // 결과 출력
        System.out.println("문자 배열의 특정 부분의 문자열 표현: " + str); // "World"
    }
}

문자 배열의 특정 부분의 문자열 표현: World

static String valueOf(double d) : double -> String

static String valueOf(float f) : float -> String

static String valueOf(int i) : int -> String

static String valueOf(long l) : long -> String

static String valueOf(Object obj) : obj -> String

public class ValueOfObjectExample {
    public static void main(String[] args) {
        // 문자열 객체
        String str = "Hello, World!";

        // Integer 객체
        Integer number = 42;

        // null 객체
        Object nullObject = null;

        // 객체를 문자열로 변환
        String strValue = String.valueOf(str);
        String numberValue = String.valueOf(number);
        String nullValue = String.valueOf(nullObject);

        // 결과 출력
        System.out.println("문자열 객체의 문자열 표현: " + strValue); // "Hello, World!"
        System.out.println("Integer 객체의 문자열 표현: " + numberValue); // "42"
        System.out.println("null 객체의 문자열 표현: " + nullValue); // "null"
    }
}

문자열 객체의 문자열 표현: Hello, World!
Integer 객체의 문자열 표현: 42
null 객체의 문자열 표현: null

Field Detail

CASE_INSENSITIVE_ORDER

• 대소문자를 구분하지 않고 String 객체를 정렬하는 Comparator를 정의

  public static final Comparator<String> CASE_INTENSIVE_ORDER

List<String> list = Arrays.asList("banana", "Apple", "orange");
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
System.out.println(list); // [Apple, banana, orange]