[작성일: 2023. 02. 05]
String 클래스의 생성자와 메서드
| 메서드 / 설명 | 예제 | 결과 |
| String(String s) | String s = new String("Heelo"); | s = "Hello" |
| 주어진 문자열(s)을 갖는 String 인스턴스를 생성함. | ||
| String(char[] value) | char[] c = { 'H', 'e', 'l', 'l', 'o' }; String s = new String(c); |
s="Hello" |
| 주어진 문자열(value)을 갖는 String 인스턴스를 생성함. | ||
| String(StringBuffer buf) | StringBuffer sb = new StringBuffer("Hello"); String s = new String(sb); |
s = "Hello" |
| StringBuffer 인스턴스가 갖고 있는 문자열과 같은 내용의 String 인스턴스를 생성함. | ||
| char charAt(int index) | String s = "Hello"; String n = "123456"; char c = s.charAt(1); char c2 = n.charAt(1); |
c = 'e' c = '1' |
| 지정된 위치(index)에 있는 문자열을 알려줌.(index는 0부터 시작) | ||
| int compareTo(String str) | int i = "aaa".compareTo("aaa"); int i2 = "aaa".compareTo("bbb"); int i3 = "bbb".compareTo("aaa"); |
i = 0 i2 = -1 i3 = 1 |
| 문자열(str) 과 사전순서(ㄱㄴㄷ)로 비교함. 같으면 0, 사전순으로 이전이면 음수, 이후면 양수를 반환함. |
||
| String concat(String str) | String s = "Hello"; String s2 = s.concat(" World"); |
s2 = "Hello World" |
| 문자열(str)을 뒤에 덧붙임. | ||
| boolean contains(CharSequence s) | String s = "abcedfg"; boolean b = s.contains("bc"); |
b = true |
| 지정된 문자열(s)이 포함되었는지 검사함. | ||
| boolean endsWith(String suffix) | String file = "Hello.txt"; boolean b = file.endsWith("txt"); |
b = true |
| 지정된 문자열(suffix)로 끝나는지 검사함. | ||
| boolean equals(Object obj) | String s = "Hello"; boblean b = s.equals("Hello"); boolean b2 = s.equals("hello"); |
b = true b2 = false |
| 매개변수로 받은 문자열(obj)과 String 인스턴스의 문자열을 비교함. obj가 String이 아니거나 문자열이 다르면 false를 반환함. |
||
| bollean eqaulsIgnoreCase(String str) | String s = "Hello"; boolean b = s.equalsIgnoreCase("HELLO"); boolean b2 = s.equalsIgnoreCase("HeLLo"); |
b = true b2 = true |
| 문자열과 String 인스턴스의 문자열을 대소문자 구분없이 비교함 | ||
| int indexOf(int ch) | String s = "Hello"; int idx1 = s.indexOf('o'); int idx2 = s.indexOf('k'); |
idx1 = 4 idx2 = -1 |
| 주어진 문자(ch)가 문자열에 존재하는지 확인하여 위치(index)를 알려줌. 못 찾으면 -1을 반환(index는 0부터 시작함.) |
||
| int indexOf(int ch, int pos) | String s = "Hello"; int idx1 = s.indexOf('e', 0); int idx2 = s.indexOf('e' , 2); |
idx1 = 1 idx2 = -1 |
| 주어진 문자(ch)가 문자열에 존재하는지 지정된 위치(pos)부터 확인하여 위치(index)를 알려줌. 못 찾으면 -1 반환(index는 0부터 시작) |
||
| int indexOf(String str) | String s = "ABCDEFG"; int idx = s.indexOf("CD"); |
idx =2 |
| 주어진 문자열이 존재하는지 확인하여 그 위치(index)를 알려줌. 없으면 -1을 반환(index는 0부터 시작) |
||
| int lastIndexOf(int ch) | String s = "java.lang.Object"; int idx1 = s.lastIndexOf('.'); int idx2 = s.indexOf('.'); |
idx1 = 9 idx 2 = 4 |
| 지정된 문자 또는 문자코드를 문자열의 오른쪽 끝에서부터 찾아서 위치(index)를 알려줌. | ||
| int lastIndexOf(String str) | String s = "java.lang.java"; int idx1 = s.lastIndexOf("java"); int idx2 = s.indexOf("java"); |
idx1 = 10 idx2 = 0 |
| 지정된 문자열을 인스턴스의 문자열 끝에서 부터 찾아서 위치(index)를 알려줌. 못 찾으면 -1을 반환 | ||
| int length() | String s = "Hello"; int length = s.length(); |
length = 5 |
| 문자열의 길이를 알려줌. |
| 메서드 / 설명 | 예제 | 결과 |
| String toLowerCase() | String s = "Hello"; String s1 = s.toLowerCase(); |
s1 = "hello" |
| String 인스턴스에 저장되어 있는 모든 문자열을 소문자로 변환하여 반환함. | ||
| String toUpperCase() | String s = "Hello"; String s1 = s.toUpperCase(); |
s1 = "HELLO" |
| String 인스턴스에 저장되어 있는 모든 문자열을 대문자로 변환하여 반환함. | ||
| String trim() | String s = " Hello "; String s1 = "s.trim(); |
s1 = "Hello" |
| 문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환함. 문자열 중간에 있는 공백은 제거되지 않음. |
||
| String[] split(String regex) | String animals = "dog, cat, bear"; String[] arr = animals.split(","); |
arr[0] = "dog" arr[1] = "cat" arr[2] = "bear" |
| 문자열을 지정한 분리자(regex)로 나누어 문자열 배열에 담아 반환함. | ||
| String[] split(String regex, int limit) | String animals = "dog, cat, bear"; String[] arr = animals.split(",",2); |
arr[0] = "dog" arr[1] = "cat, bear" |
| 문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환함. 단, 문자열 전체를 지정된 수(limit)로 자름. |
||
| boolean startsWith(String prefix) | String s = "java.lang.Object"; boolean b = s.startsWith("java"); boolean b2 = s.startsWith("lang"); |
b = true b2 = false |
| 주어진 문자열(prefix)로 시작하는지 검사함. | ||
| String substring(int begin) String substring(int begin, int end) |
String s = "java.lang.Object"; String c = s.substring(10); String p = s.substring(5, 9); |
c = "Object" p = "lang" |
| 주어진 시작위치부터 끝 위치 범위에 포함된 문자열을 얻음. 시작위치의 문자는 범위에 포함되지만 끝 위치의 문자는 포함되지 않음. |
||
| static String valueOf(boolean b) static String valueOf(char c) static String valueOf(int i) static String valueOf(long l) static String valueOf(float f) static String valueOf(double d) static String valueOf(Object o) |
String b = String valueOf(true); String c = String valueOf('a'); String i = String valueOf(100); String l = String valueOf(t100L); String f = String valueOf(10f); String d = String valueOf(10.0); java.util.Data dd = new java.util.Date(); String date = String.valueOf(dd); |
b = "true" c = "a" i = "100" l = "100" f = "10.0" d = "10.0" date = "Wed Jan 27 10:01:32 KST 2023" |
| 지정된 값을 문자열로 변환하여 반환함. 참조변수의 경우, toString()을 호출한 결과를 반환함. |
join()과 StringJoiner
- join()은 여러 문자열 사이에 구분자를 넣어서 결함함.
String animals = "dog, cat, bear";
String[] arr = animals.split(","); // 문자열 ','를 구분자로 나눠서 배열에 저장
String str = String.join("-", arr); // 배열의 문자열을 '-'로 구분해서 결합
System.out.println(str);
// dog-cat-bear 출력
문자열과 기본형 간의 변환
- 숫자를 문자열로 바꾸는 방법
int i = 100;
String str1 = i + ""; // 100을 "100"으로 변환
String str2 = String.valueOf(i); // 100을 "100"으로 변환
- 문자열을 숫자로 바꾸는 방법
int i = 100;
int i = Integer.parseInt("100") // "100"을 100으로 변환하는 방법
int i2 = Integer.valuOf("100") // "100"을 100으로 변환하는 방법
Integer i2 = Integer.valuOf("100") // 원래는 반환 타입이 Integer
| 기본형 ➡️ 문자열 |
문자열 ➡️ 기본형 ⭐(valueOf도 사용 가능!!) |
|
| String String.valueOf(boolean b) String String.valueOf(char c) |
boolean | Boolean.parseBoolean(String s) |
| byte | Byte.parseByte(String s) | |
| short | Short.parseShort(String s) | |
| String String.valueOf(int i) | int | Integer.parseInt(String s) |
| String String.valueOf(long l) | long | Long.parseLong(String s) |
| String String.valueOf(flont f) | float | Float.parseFloat(String s) |
| String String.valueOf(double d) | double | Double.parseDouble(String s) |
⭐ byte, short을 문자열로 변경할 때는 String valueOf(int i)를 사용하면 됨!
Math 클래스
- 수학 관련 static 메서드의 집합 ➡️ 객체 만들 필요 없음.
| 메서드 / 설명 | 예제 | 결과 |
| static double abs(double a) static float abs(float f) static int abs(int f) static long abs(long f) |
int i = Math.abs(-10); double d = Math.abs(-10.0); |
i = 10 d = 10.0 |
| 주어진 값의 절대값을 반환함. | ||
| static double ceil(double a) | double d = Math.ceil(10.1); double d2 = Math.ceil(-10.1); double d3 = Math.ceil(10.000015); |
d = 11.0 d2 = -10.0 d3 = 11.0 |
| 주어진 값을 올림하여 반환함. | ||
| static double floor(double a) | double d = Math.floor(10.8); double d2 = Math.floor(-10.8); |
d = 10.0 d2 = -11.0 |
| 주어진 값을 버림하여 반환함. | ||
| static double max(double a, double b) static float max(float a, float b) static int max(int a, int b) static long max(long a, long b) |
double d = Math.max(9.5, 9.50001); int i = Math.max(0, -1); |
d = 9.50001 i = 0 |
| 주어진 두 값을 비교하여 큰 쪽을 반환함. | ||
| static double min(double a, double b) static float min(float a, float b) static int min(int a, int b) static long min(long a, long b) |
double d = Math.min(9.5, 9.50001); int i = Math.min(0, -1); |
d = 9.5 i = -1 |
| 주어진 두 값을 비교하여 작은 쪽을 반환함. | ||
| static double random() | double d = Math.random(); int i = (int)(Math.random() * 10) + 1 |
0.0 <= d < 1.0 1 <= i < 11 |
| 0.0 ~ 1.0 범위의 임의의 double 값을 반환함. (1.0은 범위에 포함되지 않음.) | ||
| static double rint(double a) | double d = Math.rint(1.2); double d = Math.rint(2.6); double d = Math.rint(3.5); double d = Math.rint(4.5); |
d = 1.0 d2 = 3.0 d3 = 4.0 d4 = 4.0 |
| 주어진 double 값과 가장 가까운 정수값을 double 형으로 반환함. 두 정수의 정 가운데 있는 값은 짝수를 반환함.(1.5, 2.5 등) |
||
| static long round(double a) static long round(float a) |
long l = Math.round(1.2); long l2 = Math.round(2.6); long l3 = Math.round(3.5); long l4 = Math.round(4.5); double d = 90.7552; double d2 = Math.round(d*100)/100.0; |
l = 1 l2 = 3 l3 = 4 l4 = 5 d = 90.7552 d2 = 90.76 |
| 소수점 첫째자리에서 반올림한 정수값을 반환함. 두 정수의 정 가운데에 있는 값은 항상 큰 정수를 반환함.(rint()의 결과와 비교) |
래퍼(wrapper) 클래스
- 기본형 값을 감싸는 클래스
- 8개의 기본형을 객체로 다뤄야 할 때 사용하는 클래스
class ex {
public static void main(String[] args) {
Integer i = new Integer(100);
Integer i2 = new Integer(100);
System.out.println("i==i2 ? " + (i==i2));
System.out.println("i.equals(i2) ? " + i.equals(i2));
System.out.println("i.compareTo(i2)=" + i.compareTo(i2));
System.out.println("i.toString()=" + i.toString());
System.out.println("MAX_VALUE="+Integer.MAX_VALUE);
System.out.println("MIN_VALUE="+Integer.MIN_VALUE);
System.out.println("SIZE=" + Integer.SIZE+ " bits");
System.out.println("BYTES=" + Integer.BYTES+ "bytes");
System.out.println("TYPE=" + Integer.TYPE);
}
}
// 결과
i==i2 ? false
i.equals(i2) ? true
i.compareTo(i2) = 0
i.toString() = 100
MAX_VALUE = 2147483647
MIN_VALUE = -2147483648
SIZE = 32bits
BYTES = 4bytes
TYPE = int
Number 클래스
- 모든 숫자 래퍼 클래스의 조상임.
문자열을 숫자로 변환하기
- 문자열을 숫자로 변환하는 다양한 방법
- 래퍼클래스 ➡️ 문자열은 toString() 사용하기
int i = new Integer("100").intValue();
int i2 = Integer.parseInt("100"); // 방법을 주로 사용함.
Integer i3 = Integer.valueOf("100");
| 문자열 ➡️ 기본형 | 문자열 ➡️ 래퍼 클래스 |
| byte b = Byte.parseByte("100"); short s = Short.parseShort("100"); int i = Integer.parseInt("100"); long l = Long.parseLong("100"); float f = Float.parseFloat("3.14"); double d = Double.parseDouble("3.14"); |
byte b = Byte.valueOf("100"); short s = Short.valueOf("100"); int i = Integer.valueOf("100"); long l = Long.valueOf("100"); float f = Float.valueOf("3.14"); double d = Double.valueOf("3.14"); |
- n진법의 문자열을 숫자로 변환하는 방법
int i4 = Integer.parseInt("100", 2); // 100(2) -> 4 // 2진수
int i5 = Integer.parseInt("100", 8); // 100(8) -> 64 // 8진수
int i6 = Integer.parseInt("100", 16); // 100(16) -> 256 //16 진수
int i7 = Integer.parseInt("FF", 16); // FF(16) -> 255
int i8 = Integer.parseInt("FF"); // NumberFormatException 발생
오토박싱, 언박싱
- int ➡️ Integer (오토박싱)
- Integer ➡️int (언박싱)
- JDK1.5 이전에는 기본형과 참조형간의 연상이 불가능했음.
- 기본형의 값을 객체로 자동변환 하는 것을 오토박싱, 그 반대는 언박싱이라고 함.
| 컴파일 전의 코드 | 컴파일 후의 코드 |
| int i = 5; Integer 10bj = new Integer(7) int sum = i + iObj; 컴파일러가 자동으로 오른쪽의 코드처럼 변경해줌 |
int i = 5; Integer iObj = new Integer(7); int sum = i + iObj.intValue(): |
| Integer intg = (Integer) i; Object obj = (Object) i; Long lng = 100L; |
Integer intg = Integer.valueOf(i); Object obj = (Object)Integer.valueOf(i); Long lng = new Long(100L); |
ArrayList<Integer> list = new ArrayList<Integer> ();
list.add(10); //
// list.add(new Integer(100)); // list에는 원래 객체만 추가 가능했음.
int value = list.get(0); // 언박싱. new Integer(10)을 10으로
// intr i = list.get(0).intValue(); // 원래는 이렇게 언박싱 해야 함
🐣 해당 게시글은 자바의 정석(남궁성 님) 영상으로 함께 공부하며 요약/정리한 글입니다.
🐣 입문 개발자가 작성한 글이므로 틀린 내용이나 오타가 있을 수 있습니다.