[Java] 자료형(Data Type), 형 변환

🔹 자료형(Data Type)이란 ?

자료형(데이터 타입)은 변수에 저장되는 데이터의 종류와 크기, 연산 방법을 정의하는 요소이다.

즉, 데이터가 메모리에 어떻게 저장되고, 프로그램에서 어떻게 처리되어야 하는지를 명시하는 역할을 한다.

 

◽  자료형의 분류

Java에서 제공하는 자료형은 기본 자료형(Primitive Data Type)과 참조 자료형(Reference Data Type)으로 나뉜다.

• 기본 자료형(Primitive Data Type) : 실제 값을 저장하는 자료형
• 참조 자료형(Reference Data Type) : 데이터가 저장된 메모리의 주솟값을 저장하는 자료형

예를 들어, int 타입 변수는 정숫값을 직접 저장하지만, String 타입 변수는 문자열이 저장된 메모리 주소를 가리킨다.

 

🔍 변수(Variable)란 ?

변수(Variable)란 데이터(Data)를 저장하기 위해 프로그램이 할당한 메모리 공간이다.

변수에 저장되는 데이터를 값(value)이라 한다.

[ 변수의 중요한 특징 ]

• 변수의 이름(name)과 자료형(type)은 변경할 수 없다.
• 변수에 저장된 값(value)은 변경할 수 있다.

 

🔹기본 자료형(Primitive Data Type)

자바에서는 미리 정의된 8가지 기본 자료형이 제공된다.

기본 자료형은 실제 값을 가지는 자료형으로, 기본 값이 존재하기 때문에 null을 가질 수 없다.

📌 특징

• Heap이 아닌 Stack 메모리에 저장됨 (단, static 또는 final 상수는 Method Area 저장 가능)
• 첫 글자가 소문자로 시작
• Wrapper 클래스(Integer, Double 등)와 다르게 null을 가질 수 없음

 

🔸 정수 자료형

자바의 정수를 표현하기 위한 자료형은 대표적으로 int, long이 있다.

byte, short도 있지만 메모리 최적화가 필요한 경우를 제외하면 잘 사용하지 않는다.

정수형 타입	할당되는 메모리 크기	데이터의 표현 범위
byte	1 byte	-128 ~ 127
short	2 byte	-215 ~ (215 - 1)
		-32,768 ~ 32,767
int	4 byte	-231 ~ (231 - 1)
		-2,147,483,648 ~ 2,147,483,647
long	8 byte	-263 ~ (263 - 1)
		-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807

[ 예제 ]

int age = 20;
long countOfStr = 8764827384923849L;

🚨 주의

long 변수에 값을 대입할 때, 값이 int 자료형의 최댓값(2147483647)을 초과하면 L 접미사를 붙여야 한다.

만약 접미사를 누락하면 컴파일 오류가 발생한다.

소문자 l도 가능하지만, 숫자 1과 혼동될 수 있으므로 대문자 L 사용을 권장한다.

 

◽ 정수 오버플로우(Overflow) / 언더플로우(Underflow)

정수형 데이터를 사용할 때는 해당 자료형이 표현할 수 있는 최소/최대 크기를 고려해야 한다.

만약 자료형의 범위를 벗어나는 값을 저장하면 오버플로우(Overflow) 또는 언더플로우(Underflow)가 발생하여 원하지 않는 값이 저장될 수 있다.

• 오버플로우(overflow) : 자료형의 최댓값을 초과하는 값을 저장할 때 발생
• 언더플로우(underflow) : 자료형의 최솟값보다 작은 값을 저장할 때 발생

[ 예제 ]

byte max = 127;
byte min = -128;

System.out.println((byte)(max + 1)); // -128 (Overflow 발생)
System.out.println((byte)(min - 1)); // 127 (Underflow 발생)

자바에서 byte 타입은 -128 ~ 127 범위의 정수만 표현할 수 있다.

위의 코드처럼 범위를 초과하는 연산을 수행하면, 오버플로우 또는 언더플로우가 발생하여 예상과 다른 값이 저장될 수 있다.

 

◽ 언더 스코어 표기법 (Underscore 표기법)

언더 스코어 표기법은 JDK 7부터 지원하는 문법으로,  큰 숫자의 가독성을 높이기 위해 콤마 대신 _(밑줄)로 구분하는 방식이다.

int cost = 1_000_000_000; // 1000000000

언더 스코어 _는 단순히 가독성을 위한 것이며, 숫자의 값에는 영향을 주지 않는다.

 

◽ 2진수 / 8진수 / 16진수 표기법

자바에서 2진수, 8진수, 16진수를 특정 기호를 붙여서 표현할 수 있다.

이러한 정수형 데이터는 int 자료형을 사용하여 저장된다.

진수	접두사	예제
2진수 (Binary)	0b	int binary = 0b101;
8진수 (Octal)	0	int octal = 023;
16진수 (Hexadecimal)	0x	int hex = 0xC;

[ 예제 ]

int binary = 0b101;    // 2진수: 5
int octal = 023;       // 8진수: 19
int hex = 0xC;         // 16진수: 12

• 2진수는 0b(숫자 0 + 알파벳 b)로 시작한다.
• 8진수는 0(숫자 0)으로 시작한다.
• 16진수는 0x(숫자 0 + 알파벳 x)로 시작한다.

 

🔸 실수 자료형

자바의 실수를 표현하기 위한 자료형은 대표적으로  float과 double이 있다.

과거에는 float을 많이 사용했지만, 메모리 용량 증가와 연산 성능 향상으로 인해 현재는 double이 더 많이 사용된다.

따라서 자바의 기본 실수형 타입은 double이다.

실수형 타입	할당되는 메모리 크기	데이터 표현 범위	리터럴 타입 접미사
float	4 byte	(1.4 × 10⁻⁴⁵) ~ (3.4 × 10³⁸)	F 또는 f
double	8 byte	(4.9 × 10⁻³²⁴) ~ (1.7 × 10³⁰⁸)	D 또는 d (생략 가능)

[ 예제 ]

float pi = 3.14F;
double morePi = 3.14159265358979323846;

🚨 주의

float을 사용할 경우, F 또는 f 접미사를 반드시 붙여야 한다.

 

◽ 실수 연산 오차

컴퓨터는 실수를 2진수 형태로 변환하여 저장하는데, 이 과정에서 일부 실수를 정확하게 표현할 수 없어 부동 소수점 방식을 사용해 근삿값으로 저장한다.

부동 소수점 방식은 고정 소수점 방식에 비해 큰 범위의 실수를 표현할 수 있지만, 여전히 오차가 발생할 수 있다. 따라서 매우 정확한 계산이 필요한 프로그램에서는 실수형 데이터 타입의 사용을 피하는 것이 좋다.

[ 예제 ]

double value1 = 12.23;
double value2 = 34.45;

// 기대값: 46.68
System.out.println(value1 + value2); // 46.68000000000001

위 예제에서 두 실수를 더한 결과가 기대값인 46.68과 약간 차이가 나는 것을 확인할 수 있다.

이는 부동 소수점 방식의 근삿값 저장으로 인한 연산 오차 때문이다.

 

따라서 이러한 실수 연산 문제를 해결하기 위해 자바에서는 두 가지 방법을 제공한다.

 

◽ 부동소수점 오차 해결 방법

1️⃣ 정수형 타입을 사용하여 계산

실수를 정수로 변환하여 연산 후 다시 나누는 방식이다.

double a = 1000.0;
double b = 999.9;

// 오차 발생
System.out.println(a - b); // 0.10000000000002274

// 정수형 변환 후 연산
long a2 = (long)(a * 10);
long b2 = (long)(b * 10);
double result = (a2 - b2) / 10.0;
System.out.println(result); // 0.1

소수점을 정수로 변환하여 연산하면, 오차를 줄일 수 있다.

 

2️⃣ BigDecimal 클래스 사용

정확한 소수 연산이 필요한 경우 BigDecimal을 사용하면 좋다.

이때, BigDecimal.valueOf() 사용을 권장한다.

import java.math.BigDecimal;

public class Main {
    public static void main(String[] args) {
        BigDecimal bigNumber1 = BigDecimal.valueOf(1000.0);
        BigDecimal bigNumber2 = BigDecimal.valueOf(999.9);
        BigDecimal result2 = bigNumber1.subtract(bigNumber2);

        System.out.println(result2); // 0.1
    }
}

✅ BigDecimal.valueOf(double)을 사용하면 내부적으로 정확한 값으로 변환되며, 가독성과 안전성 면에서 new BigDecimal(String)보다 유리하다.

📍 new BigDecimal(double) 방식은 오차가 발생할 수 있으므로 지양해야 한다.

 

◽ 실수의 유효 자릿수(정밀도)

자바에서는 실수를 표현할 때, 부동소수점 방식을 사용하며, 실수 타입별로 유효 자릿수의 제한이 존재한다.

유효 자릿수(Precision)란, 실수가 표현할 수 있는 전체 자릿수를 의미하며, 일반적으로 가수부 크기에 의해 결정된다.

실수형 타입	지수의 길이	가수의 길이	유효 자릿수
float	8 bit	23 bit	약 6~7자리 정확도
double	11 bit	52 bit	약 15~16자리 정확도

위 표와 같이, double은 float보다 가수부(bit 수)가 크기 때문에 더 높은 정밀도를 제공한다.

즉, 유효 자릿수는 실수의 정밀도를 의미하기도 한다.

[ 예제 ]

// 짧은 실수
double var1 = 3.14;
float var2 = 3.14f;

System.out.println("var1 : " + var1); // var1 : 3.14
System.out.println("var2 : " + var2); // var2 : 3.14


// 긴 실수 (정밀도 테스트)
double var3 = 3.14159265358979;
float var4 = 3.14159265358979f;

System.out.println("var3 : " + var3); // var3 : 3.14159265358979 - 정확히 표현
System.out.println("var4 : " + var4); // var4 : 3.1415927 - (유효 자리 제한으로 반올림됨)

💡 실수형의 선택 기준

만약 실수의 정밀도가 중요하다면, 변수의 타입을 double로 설정하면 된다.

double 타입은 float 타입보다 약 2배 높은 정밀도(유효 자릿수 15~16자리)를 제공하므로, 정확한 계산이 필요할 때 적합하다.

하지만 메모리 절약과 속도가 중요한 경우 float 타입을 고려할 수 있다.

하지만 정밀도가  낮아 오차가 발생할 수 있으므로, 필요한 경우에만 사용해야 한다.

 

◽ 실수 오버플로우 / 언더플로우

[ 오버플로우(Overflow) ]

실수형 변수의 값이 최댓값을 초과하면 오버플로우(Overflow)가 발생한다.

하지만 정수형과 달리, 실수형의 경우 오버플로우가 발생하면 값이 무한대 (Infinity)로 설정된다.

double max = Double.MAX_VALUE;
System.out.println(max * 2); // Infinity (오버플로우)

[ 언더플로우(Underflow) ]

실수형 변수의 값이 표현 가능한 최솟값보다 작은 값이 되는 경우 언더플로우(Underflow)가 발생한다.

자바에서는 이런 값이 발생하면 0으로 반올림(RTZ, Rounded to Zero) 되거나, 서브 노멀(subnormal) 값이 될 수도 있다. (대부분의 연산에서 0으로 처리됨)

double min = Double.MIN_VALUE;
System.out.println(min / 2); // 0.0 (언더플로우)

 

◽ 지수(e) 표기법

지수 표기법은 아주 큰 숫자 또는 작은 숫자를 간결하게 표현하는 방법으로, 과학적 표기법(scientific notation)이라고도 불린다. 자바에서는 e(또는 E)를 사용하여 표현할 수 있다.

[ 예제 ]

double d1 = 1.234e2;  // 1.234 × 10^2  → 123.4
double d2 = 1.7e+3;   // 1.7 × 10^3   → 1700.0
double d3 = 1.7e-3;   // 1.7 × 10^-3  → 0.0017

System.out.println(d1); // 123.4
System.out.println(d2); // 1700.0
System.out.println(d3); // 0.0017

 

🔸 논리 자료형

논리형 자료형은 참(true) 또는 거짓(false)의 값을 가지는 자료형을 의미한다.

이 자료형은 주로 조건문(if, while 등)에서 조건을 판별할 때 사용된다.

논리형 타입	할당되는 메모리 크기	데이터의 표현 범위
boolean	1 byte	true, false

다음과 같이 비교 연산 (>, <, ==, !=)과 논리 연산(&&, ||, !)의 결괏값이 boolean 변수에 저장될 수 있다.

[ 예제 ]

boolean result1 = (2 > 1);           // true
boolean result2 = (1 == 2);          // false
boolean result3 = (3 % 2 == 1);      // true (3을 2로 나눈 나머지는 1이므로 참)
boolean result4 = ("3".equals("2")); // false (문자열 비교)

[ 조건문 예제 ]

int base = 180;
int height = 185;

if (height > base) { // 조건이 참이므로
    System.out.println("키가 큽니다."); // 출력
}

 

🔸 문자 자료형

문자 자료형은 한 개의 문자 값을 저장하는 자료형이며, 16비트(2바이트)를 사용하여 유니코드 문자를 표현한다.
이때, 음수 값은 저장할 수 없다. (char 타입은 부호 없는 정수)

문자형 타입	할당되는 메모리 크기	데이터의 표현 범위
char	2 byte (16 bit)	\u0000 (0) ~ \uffff (65,535) (유니코드 문자)

이 자료형은 문자 값을 표현할 때 단일 인용부호(')를 사용해야 하며, 쌍따옴표(")를 사용하면 오류 발생한다.

char a1 = 'a';

char 타입은 문자, 아스키코드 값, 유니코드 값으로 표현 가능하다.

아래 예제에서 'a', 97, \u0061 은 모두 같은 문자('a')를 의미한다.

[ 예제 ]

char a1 = 'a';       // 문자로 표현
char a2 = 97;        // 아스키코드 값(97 = 'a')
char a3 = '\u0061';  // 유니코드 값(0061 = 'a')

System.out.println(a1);  // a 출력
System.out.println(a2);  // a 출력
System.out.println(a3);  // a 출력

아스키코드를 활용하면 문자 연산이 가능하다.

[ 예제 ]

char a = 'C' - 2; // 'C'의 아스키코드 값(67) - 2 = 65 ('A')

System.out.println(a); // A 출력

'C'의 아스키코드 값은 67이다.

67 - 2 = 65, 즉, 'A'에 해당하므로 결과적으로  'A'가 출력된다.

 

💡 아스키코드
아스키코드는 1963년 미국표준협회(ASA, 현재 ANSI)에서 제정한 문자 인코딩 표준으로, 영어 알파벳, 숫자, 특수 문자 등을 표현하기 위해 사용된다.

📌 특징

• 7비트(128개 문자)로 구성 → 0 ~ 127
• 영문 대/소문자, 숫자(0~9), 특수 문자, 제어 문자 포함
• 확장 아스키(8비트, 256개 문자) → 유럽 언어 및 그래픽 문자 추가

 

💡 유니코드

유니코드는 전 세계 모든 문자를 통합적으로 표현하기 위해 개발된 문자 인코딩 표준이다.

과거에는 아스키코드(ASCII)처럼 각 언어별로 문자 인코딩 방식이 달라 서로 다른 시스템 간 데이터 교환이 어려웠다. 이를 해결하기 위해 각 문자에 고유한 코드 값을 부여하는 유니코드 체계가 등장했다.

📌 특징

• 운영체제, 프로그램, 언어에 관계없이 동일한 문자 코드 사용 가능
• 초기에는 16비트(2바이트, 65,536자)로 설계되었으나, 현재는 최대 1,114,112개 문자 표현 가능
• 17개의 평면(Plane)으로 구성
  • BMP (Basic Multilingual Plane, 기본 다국어 평면, U+0000 ~ U+FFFF) → 65,536자
  • 추가 평면(Supplementary Planes, U+010000 ~ U+10FFFF) → 확장 문자 표현 가능

 

🔹 참조 자료형(Reference Data Type)

🔸 문자열 자료형

문자는 하나의 글자로 작은따옴표(')로 감싸고, 문자열은 글자의 집합으로 쌍 따옴표(")로 감싼다는 차이가 있다.

자바에서는 이 둘을 엄격하게 구분한다.

char c = 'a';        // 문자 (char)
String s1 = "Happy"; // 문자열 (String)
String s2 = "123";   // 숫자로 보이지만 문자열

 

◽  String 클래스

자바에서는 문자열을 다루기 위해 String 클래스를 별도로 제공한다.

하지만 내부적으로 보면 String도 char 배열로 구성된 데이터 자료형이다.

public final class String implements java.io.Serializable, Comparable<String> {
    /* The value is used for character storage */
    private final char[] value; // String 내부 구조는 char 배열
}

 

이러한 String 자료형을 이용해 문자열 변수를 선언하는 방법은 다음과 같이 두 가지가 있다.

String str1 = "Happy Java"; // 리터럴 방식 (String Pool)
String str2 = new String("Happy Java"); // 생성자 방식 (Heap 메모리)

[ 리터럴 방식 (String Pool 이용) ]

• "Happy Java"가 String Pool에 저장되고, 동일한 값이 있으면 재사용됨 → 메모리 효율적
• 문자열 비교 시 == 연산자를 사용하면 동일 객체인지 확인 가능

[ new 생성자 방식 (Heap 메모리 할당) ]

• new String("Happy Java")는 무조건 새로운 객체 생성 → 불필요한 객체 증가 가능
• 가급적이면 리터럴 방식을 사용하는 것이 좋음

 

◽ String과 원시 자료형(Primitive Type)의 차이

 int, double, char, boolean은 기본(원시, primitive) 자료형으로 분류되고, String은 참조(Reference) 자료형으로 분류된다.

이 둘은 메모리 저장 방식에 차이가 있는데,

• 기본 자료형 → Stack 메모리에 직접 값 저장
• 참조 자료형 → Heap 메모리에 객체 저장, Stack에는 주소 저장

 

◽ String의 불변성 (Immutable)

String 객체는 한 번 생성되면 값을 변경할 수 없다.

즉, 문자열을 수정하면 기존 객체를 변경하는 것이 아니라 새로운 객체를 생성한다.

String s = "ABC";
s += "DEF"; // "ABCDEF"라는 새로운 객체 생성

이 때문에 문자열을 자주 변경해야 한다면 StringBuffer 또는 StringBuilder를 사용하는 것이 좋다.

StringBuilder sb = new StringBuilder("ABC");
sb.append("DEF"); // 기존 객체를 수정 (메모리 효율적)
System.out.println(sb.toString()); // ABCDEF

 

◽ 문자열 내장 메서드

String 클래스에는 문자열을 다를 때 유용한 다양한 메서드가 포함되어 있다.

 

1️⃣ 문자열 비교 (equals)

문자열 같은지 비교할 때 equals() 메서드를 사용한다.

String a = "hello";
String b = "java";
String c = "hello";

System.out.println(a.equals(b)); // false 출력
System.out.println(a.equals(c)); // true 출력

📌 == 연산자는 참조(주소)를 비교하므로 문자열 비교 시에는 equals()를 사용해야 한다.

 

2️⃣ 문자열 순서 비교 (compareTo)

사전 순(알파벳 순서) 비교를 할 때 사용하며, 결과는 음수(앞), 0(같음), 양수(뒤)로 반환된다.

System.out.println("abc".compareTo("jzis")); // -9 (abc가 더 앞)
System.out.println("jzis".compareTo("abc")); // 9 (abc가 더 앞)
System.out.println("aa".compareTo("aaa"));   // -1 (aa가 더 앞)

📌 compareToIgnoreCase()를 사용하면 대소문자 구분 없이 비교할 수 있다.

 

3️⃣ 특정 문자열 포함 여부 (contains)

String a = "Hello Java";

System.out.println(a.contains("Java")); // true 출력
System.out.println(a.contains("Python")); // false 출력

4️⃣ 문자열의 시작 확인 (startsWith) / 끝 확인 (endsWith)

String a = "Hello Java";

System.out.println(a.startsWith("Hello")); // true 출력
System.out.println(a.endsWith("Java"));   // true 출력

5️⃣ 문자열에서 특정 문자의 위치 찾기 (indexOf)

String a = "Hello Java";

System.out.println(a.indexOf("Java"));  // 6 출력
System.out.println(a.indexOf("World")); // -1 출력 (없으면 -1 반환)

6️⃣ 특정 위치의 문자 가져오기 (charAt)

String a = "Hello Java";

System.out.println(a.charAt(6)); // 'J' 출력
System.out.println(a.charAt(0)); // 'H' 출력

📌 배열처럼 0부터 시작하는 인덱스를 사용한다.

 

7️⃣ 문자열 일부 추출 (substring)

String a = "Hello Java";

System.out.println(a.substring(0, 4)); // "Hell" 출력 (0 ≤ 인덱스 < 4)
System.out.println(a.substring(6));    // "Java" 출력 (6부터 끝까지)

8️⃣ 문자열 합치기 (concat)

String a = "Hello";
String b = "World";

System.out.println(a.concat(" ").concat(b)); // "Hello World" 출력

📌 + 연산자로도 문자열을 합칠 수 있다.

System.out.println(a + " " + b); // "Hello World"

9️⃣ 문자열 치환 (replace, replaceAll)

String a = "Hello Java";
System.out.println(a.replace("Java", "World")); // "Hello World" 출력

String text = "카페라떼, 녹차라떼, 코드라떼";
System.out.println(text.replace("라떼", "AA")); // "카페AA, 녹차AA, 코드AA"

🔟 문자열 나누기 (split)

String a = "a:b:c:d";
String[] arr = a.split(":");  // {"a", "b", "c", "d"}

for (String s : arr) {
    System.out.println(s);
}

📌 배열을 다시 하나의 문자열로 합칠 때는 String.join()을 사용한다.

System.out.println(String.join(".", arr)); // "a.b.c.d"

1️⃣1️⃣ 대소문자 변환 (toUpperCase, toLowerCase)

String a = "Hello Java";

System.out.println(a.toUpperCase()); // "HELLO JAVA" 출력
System.out.println(a.toLowerCase()); // "hello java" 출력

1️⃣2️⃣ 문자열 앞뒤 공백 제거 (trim)

String a = "  Hello Java  ";
System.out.println(a.trim()); // "Hello Java" (앞뒤 공백 제거)

📌 중간의 공백은 제거되지 않는다. 모든 공백을 제거하려면 replaceAll("\\s", "")을 사용한다.

System.out.println(a.replaceAll("\\s", "")); // "HelloJava"

 

메서드	설명
String(String s)	문자열 s를 기반으로 새로운 String 인스턴스를 생성
String(char[] value)	주어진 문자 배열 value를 기반으로 String 인스턴스를 생성
String(StringBuffer buf)	StringBuffer 인스턴스 buf와 동일한 내용을 갖는 String 인스턴스를 생성
char charAt(int index)	지정한 위치 index(0부터 시작)의 문자를 반환
int compareTo(String anotherString)	현재 문자열과 anotherString을 사전순으로 비교하여 결과를 반환    같으면 0, 현재 문자열이 작으면 음수, 크면 양수를 반환
boolean endsWith(String suffix)	현재 문자열이 지정한 suffix로 끝나는지 여부를 반환
boolean equals(Object obj)	현재 문자열과 obj의 내용이 같은지 비교하여 결과를 반환
boolean startsWith(String prefix)	현재 문자열이 지정한 prefix로 시작하는지 여부를 반환
int indexOf(String str)	현재 문자열에서 지정한 str이 처음 나타나는 위치를 반환    없으면 -1을 반환
int lastIndexOf(String str)	현재 문자열에서 지정한 str이 마지막으로 나타나는 위치를 반환    없으면 -1을 반환
int length()	현재 문자열의 길이를 반환
String replace(char oldChar,    char newChar)	현재 문자열에서 oldChar를 찾아 newChar로 변경한 새로운 문자열을 반환
String toLowerCase()	현재 문자열의 모든 문자를 소문자로 변환한 새로운 문자열을 반환
String toUpperCase()	현재 문자열의 모든 문자를 대문자로 변환한 새로운 문자열을 반환
String substring(int beginIndex)	현재 문자열에서 beginIndex부터 끝까지의 문자열을 반환
String substring(int beginIndex,    int endIndex)	현재 문자열에서 beginIndex부터 endIndex 전까지(포함 X) 부분 문자열을    반환
String[] split(String regex)	현재 문자열을 지정한 정규 표현식 regex를 기준으로 나누어 문자열 배열로    반환
String[] split(String regex, int limit)	현재 문자열을 정규 표현식 regex를 기준으로 최대 limit 개수만큼 분할하여    문자열 배열로 반환    마지막 요소는 남은 문자열을 포함
String trim()	현재 문자열의 양 끝에 있는 공백 문자를 제거한 새로운 문자열을 반환
byte[] getBytes()	현재 문자열을 바이트 배열로 변환하여 반환    (getBytes(Charset charset)을 사용하면 인코딩을 지정할 수 있음
boolean contains(CharSequence s)	현재 문자열이 주어진 s를 포함하는지 여부를 반환
String join(CharSequence delimiter,    CharSequence... elements)	여러 개의 문자열을 delimiter(구분자)로 이어 붙여 하나의 문자열로 반환
boolean isEmpty()	현재 문자열이 비어있는지(길이가 0인지) 확인하여 결과를 반환
int codePointAt(int index)	지정한 위치 index의 문자의 유니코드 코드 포인트를 반환

 

 

 

 

 

📃 reference

• https://inpa.tistory.com/entry/JAVA
• https://velog.io/@sdeung01/Java