Java

[자바의 정석] 9장 java.lang 패키지

woochii 2023. 7. 23. 19:03
728x90
반응형

1. Object

1-1. Object 클래스

  • 모든 클래스의 최고 조상.
  • 오직 11개의 메서드만을 가지고 있다.
  • notify(), wait() 등은 쓰레드와 관련된 메서드이다.
Object 클래스의 메서드 설명
protected Object clone() 객체 자신의 복사본을 반환한다.
public boolean equals(Object obj) 객체 자신과 객체 obj가 같은 객체인지 알려준다.(같으면 true)
protected void finalize() 객체가 소멸될 때 가비지 컬렉터에 의해 자동적으로 호출된다.
이때 거의 수행되어야하는 코드가 있을 때 오버라이딩 한다.
(거의 사용X)
public Class getClass() 객체 자신의 클래스 정보를 담고 있는 Class인스턴스를 반환한다.
public int hashCode() 객체 자신의 해시코드를 반환한다.
public String toString() 객체 자신의 정보를 문자열로 반환한다.
public void notify() 객체 자신을 사용하려고 기다리는 쓰레드를 하나만 깨운다.
public void notifyAll() 객체 자신을 사용하려고 기다리는 모든 쓰레드를 깨운다.
public void wait()
public void wait(long timeout)
public void wait(long timeout, int nanos)		 다른 쓰레드가 notify()나 notifyAll()을 호출할 때 까지 현재 쓰레드를 무한히 또는 지정된 시간(timeout, nanos)동안 기다리게 한다.
(timeout은 천 분의 1초, nanos는 10⁹ 분의 1초)

 

 

1-2. equals(Object obj) 

  • 객체 자신(this)과 주어진 객체(obj)를 비교한다. 같으면 true, 다르면 false.
  • Object클래스의 equals()는 객체 주소를 비교(참조변수 값 비교)

1-2-1. equals(Object obj)의 오버라이딩

  • 인스턴스 변수(iv)의 값을 비교하도록 equals()를 오버라이딩 해야 한다.

 

1-3. hashCode()

  • 객체의 해시코드(hash code)를 반환하는 메서드
  • Object 클래스의 hashCode()는 객체의 주소를 int로 변환해서 반환
  • equals()를 오버라이딩 하면, hashCode()도 오버라이딩 해야 한다.
    -> equals()의 결과가 true인 두 객체의 해시코드는 같아야 하기 때문이다.
  • System.identityHashCode(Object obj)는 Object클래스의 hashCode()와 동일

 

1-4. toString()

  • 객체를 문자열(String)로 변환하기 위한 메서드

2. String

2-1. String 클래스

  • 데이터(char[]) + 메서드(문자열 관련)
  • 내용을 변경할 수 없는 불변(immutable)클래스
  • 덧셈 연산자(+)를 이용한 문자열 결합은 성능이 떨어짐.
    -> 문자열의 결합이나 변경이 잦다면, 내용을 변경 가능한 StringBuffer를 사용

 

2-2. 문자열의 비교

  • String str = "abc"; 와 String str = new String("abc");의 비교
String str1 = "abc"; // 문자열 리터럴 "abc"의 주소가 str1에 저장됨
String str2 = "abc"; // 문자열 리터럴 "abc"의 주소가 str2에 저장됨
String str3 = new String("abc"); // 새로운 String 인스턴스를 생성
String str4 = new String("abc"); // 새로운 String 인스턴스를 생성

str1 == str2 // true
str1.equals(str2) // true
str3 == str4 // false
str3.equals(str4) // true

 

2-3. 문자열 리터럴

  • 문자열 리터럴은 프로그램 실행 시 자동으로 생성된다.

 

2-4. 빈 문자열("", empty string)

  • 내용이 없는 문자열. 크기가 0인 char형 배열을 저장하는 문자열
  • 크기가 0인 배열을 생성하는 것은 어느 타입이나 가능

 

2-5. String 클래스의 생성자와 메서드

메서드 / 설명 예제 결과
String(String s) String s = new String("Hello"); s = "Hello"
주어진 문자열(s)를 갖는 String 인스턴스를 생성한다.
String(char[] value) char[] c = {'H', 'e', 'l', 'l', 'o'};
String c = 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 = "0123456";
char c = s.charAt(1);
char c2 = n.charAt(1);		 c = 'e'
c2 = '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 = "abcdefg";
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";
boolean b = s.equals("Hello");
boolean b2 = s.equals("hello");		 b = true
b2 = false
매개변수로 받은 문자열(obj)과 String 인스턴스의 문자열을 비교한다. obj가 String이 아니거나 문자열이 다르면 false를 반환한다.
boolean equalsIgnoreCase(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을 반환한다.
int indexOf(String str) String s = "ABCDEFG";
int idx = s.indexOf('CD');		 idx = 2
주어진 문자열이 존재하는지 확인하여 그 위치(index)를 알려준다. 없으면 -1을 반환한다.
int lastIndexOf(int ch) String s = "java.lang.Object";
int idx1 = s.lastIndexOf('.');
int idx2 = s.indexOf('.');		 idx1 = 9
idx2 = 4
지정된 문자 또는 문자 코드를 문자열의 오른쪽 끝에서부터 찾아서 위치(index)를 알려준다.
못찾으면 -1을 반환한다.
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[] 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 startWith(String prefix) String s = "java.lang.Object";
boolean b = s.startWith("java");
boolean b2 = s.startWith("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"
주어진 시작위치(begin)부터 끝 위치(end)범위에 포함된 문자열을 얻는다. 이 때, 시작 위치의 문자는 범위에 포함되지만, 끝 위치의 문자는 포함되지 않는다.
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 World.   ";
String s1 = s.trim();		 s1 = "Hello World"
문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환한다. 이때 문자열 중간에 있는 공백은 제거되지 않는다.
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(100L);
String f = String.valueOf(10f);
String d = String.valueOf(10.0);		 b = true
c = "a"
i = "100"
l = "100"
f = "10.0"
d = "10.0"
지정된 값을 문자열로 변환하여 반환한다.
참조변수의 경우, toString()을 호출한 결과를 반환한다.

 

2-6. join()과 StringJoiner

  • join()은 여러 문자열 사이에 구분자를 넣어서 결합한다.
String animals = "dog, cat, bear";
String[] arr = animals.split(",");  // 문자열을 ','를 구분자로 나눠서 배열에 저장
String str = String.join("-", arr); // 배열의 문자열을 '-'로 구분해서 결합
System.out.println(str);            // dog-cat-bear

3. StringBuffer

3-1. StringBuffer 클래스

  • String처럼 문자형 배열(char[])을 내부적으로 가지고 있다.
  • 그러나, String과 달리 내용을 변경할 수 있다. (mutable)

 

3-2. StringBuffer의 생성자

  • 배열은 길이 변경불가. 공간이 부족하면 새로운 배열을 생성해야 한다.
  • StringBuffer는 저장할 문자열의 길이를 고려해서 적절한 크기로 생성해야 한다.
public StringBuffer(int length) {
    value = new char[length];   // 크기 지정
    shared = false;
}

public StringBuffer() {
    this(16);                   // 버퍼의 크기를 지정하지 않으면 버퍼의 크기는 16이 된다.
}

public StringBuffer(String str) {
    this(str.length() + 16);    // 지정한 문자열의 길이보다 16이 더 크게 버퍼를 생성한다.
    append(str);
}

 

3-3. StringBuffer의 변경

  • StringBuffer는 String과 달리 내용 변경이 가능하다.
  • append()는 지정된 내용을 StringBuffer에 추가 후, StringBuffer의 참조를 반환한다.
StringBuffer sb = new StringBuffer("abc");
sb.append("123");   // sb의 내용 뒤에 "123"을 추가한다.

StringBuffer sb2 = sb.append("ZZ");
System.out.println(sb);    // abc123ZZ
System.out.println(sb2);   // abc123ZZ

 

3-4. StringBuffer의 비교

  • StringBuffer는 equals()가 오버라이딩 되어있지 않다.(주소 비교)
  • StringBuffer를 String으로 변환한 후에 equals()로 비교해야 한다.

 

3-5. StringBuffer 클래스의 메서드

메서드 / 설명 예제 결과
StringBuffer() StringBuffer sb = new StringBuffer(); sb = ""
16문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스를 생성한다.
StringBuffer(int length) StringBuffer sb = new StringBuffer(10); sb = ""
지정된 개수의 문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스를 생성한다.
StringBuffer(String str) StringBuffer sb = new StringBuffer("Hi"); sb = "Hi"
지정된 문자열 값(str)을 갖는 StringBuffer 인스턴스를 생성한다.
StringBuffer append(boolean b)
StringBuffer append(char c)
StringBuffer append(char[] str)
StringBuffer append(double d)
StringBuffer append(float f)
StringBuffer append(int i)
StringBuffer append(long l)
StringBuffer append(Object obj)
StringBuffer append(String str)
 StringBuffer sb = new StringBuffer("abc");
StringBuffer sb2 = sb.append(true);
sb.append('d').append(10.0f);

StringBuffer sb3 = sb.append("ABC")
                                     .append(123);		 sb = "abctrued10.0ABC123"
sb2 = "abctrued10.0ABC123"
sb3 = "abctrued10.0ABC123"
매개변수로 입력된 값을 문자열로 변환하여 StringBuffer 인스턴스가 저장하고 있는 문자열의 뒤에 덧붙인다.
int capacity() StringBuffer sb = new StringBuffer(100);
sb.append("abcd");
int bufferSize = sb.capacity();
int stringSize = sb.length();		 bufferSize = 100
stringSize = 4
StringBuffer 인스턴스의 버퍼크기를 알려준다.length()는 버퍼에 담긴 문자열의 길이를 알려준다.
char charAt(int index) StringBuffer sb = new StringBuffer("abc");
char c = sb.charAt(2);		 c = 'c'
지정된 위치(index)에 있는 문자를 반환한다.
StringBuffer delete(int start, int end) StringBuffer sb = new StringBuffer("01234");
StringBuffer sb2 = sb.delete(2, 3);		 sb = "014"
sb2 = "014"
시작위치(start)부터 끝 위치(end) 사이에 있는 문자를 제거한다. 단 끝 위치의 문자는 제외
StringBuffer deleteCharAt(int index) StringBuffer sb = new StringBuffer("01234");
sb.deleteCharAt(3);		 sb = "0124"
지정된 위치(index)의 문자를 제거한다.
StringBuffer insert(int pos, boolean b)
StringBuffer insert(int pos, char c)
StringBuffer insert(int pos, char[] str)
StringBuffer insert(int pos, double d)
StringBuffer insert(int pos, float f)
StringBuffer insert(int pos, int i)
StringBuffer insert(int pos, long l)
StringBuffer insert(int pos, Object obj)
StringBuffer insert(int pos, String str)		 StringBuffer sb = new StringBuffer("01234");
sb.insert(2, '.');		 sb = "01.234"
두 번째 매개변수로 받은 값을 문자열로 변환하여 지정된 위치(pos)에 추가한다. pos는 0부터 시작
int length() StringBuffer sb = new StringBuffer("01234");
int length = sb.length();		 length = 5
StringBuffer 인스턴스에 저장되어 있는 문자열의 길이를 반환한다.
StringBuffer replace(int start, int end, String str) StringBuffer sb = new StringBuffer("01234");
sb.replace(1, 3, "AB")		 sb = "0AB4"
지정된 범위(start~end)의 문자들을 주어진 문자열로 바꾼다. end위치의 문자는 범위에 포함되지 않는다.
StringBuffer reverse() StringBuffer sb = new StringBuffer("01234");
sb.reverse();		 sb = "43210"
StringBuffer 인스턴스에 저장되어 있는 문자열의 순서를 거꾸로 나열한다.
void setCharAt(int index, char ch) StringBuffer sb = new StringBuffer("01234");
sb.setCharAt(2, 'o');		 sb = "01o34"
지정된 위치의 문자를 주어진 문자(ch)로 바꾼다.
void setLength(int newLength) StringBuffer sb = new StringBuffer("01234");
sb.setLength(3);

StringBuffer sb2 = new StringBuffer("01234");
sb2.setLength(10);
String str = sb2.toString().trim();

 sb = "012"
sb2 = "01234     "
str = "01234"
지정된 길이로 문자열의 길이를 변경한다.
길이를 늘리는 경우에 나머지 빈 공간을 널문자 '\u0000'로 채운다.
String toString() StringBuffer sb = new StringBuffer("01234");
String str = sb.toString()		 str = "01234"
StringBuffer 인스턴스의 문자열을 String으로 변환
String subString(int start)
String subString(int start, int end)
 StringBuffer sb = new StringBuffer("01234");
String str = sb.substring(1);
String str2 = sb.substring(1,3);		 str = "1234"
str2 = "12"
지정된 범위 내의 문자열을 String으로 뽑아서 반환한다. 시작위치(start)만 지정하면 시작위치부터 문자열 끝까지 뽑아서 반환한다.

 

 

3-6. StringBuilder 클래스

  • StringBuffer는 동기화되어 있다. 멀티 쓰레드에 안전(thread-safe)
  • 멀티 쓰레드 프로그램이 아닌 경우, 동기화는 불필요한 성능 저하
    이럴 땐 StringBuffer 대신 StringBuilder를 사용하면 성능 향상

4. Math

4-1. Math 클래스

  • 수학 관련 static메서드의 집합
public static final double E = 2.7182818284... // 자연로그
public static final double PI = 3.1415926535... // 원주율

4-2. Math 클래스의 메서드

메서드 / 설명 예제 결과
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 d2 = Math.rint(2.6);
double d3 = Math.rint(3.5);
double d4 = Math.rint(4.5);		 d = 1.0
d2 = 3.0
d3 = 4.0
d4 = 4.0
주어진 double값과 가장 가까운 정수값을 double형으로 반환한다. 단, 두 정수가 정가운데 있는 값(1.5, 2.5, 3.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
소수점 첫째자리에서 반올림한 정수값(long)을 반환한다. 두 정수의 정가운데 있는 값은 항상 큰 정수를 반환.

5. 래퍼(wrapper) 클래스

5-1. 래퍼클래스

  • 8개의 기본형을 객체로 다뤄야할 때 사용하는 클래스
public final class Integer extends Number implements Comparable {
    ...
    private int value; //기본형을 감싸고 있음
    ...
}
기본형 래퍼클래스 생성자 활용 예
boolean Boolean Boolean(boolean value)
Boolean(String s)		 Boolean b = new Boolean(true);
Boolean b2 = new Boolean("true");
char Character Character(char value) Character c = new Character('a');
byte Byte Byte(byte value)
Byte(String s)		 Byte b = new Byte(10);
Byte b2 = new Byte("10");
short Short Short(short value)
Short(String s)		 Short s = new Short(10);
Short s2 = new Short("10");
int Integer Integer(int value)
Integer(String s)		 Integer i = new Integer(100);
Integer i2 = new Integer("100");
long Long Long(long value)
Long(String s)		 Long l = new Long(100);
Long l2 = new Long("100");
float Float Float(double value)
Float(float value)
Float(String s)		 Float f = new Float(1.0);
Float f2 = new Float(1.0f);
Float f3 = new Float("1.0f");
double Double Double(double value)
Double(String s)		 Double d = new Double(1.0);
Double d2 = new Double("1.0");

 

5-2. Number 클래스

  • 모든 숫자 래퍼 클래스의 조상

 

5-3. 오토박싱 & 언박싱

  오토박싱  
  ---------->  
int                                                  Integer
  <----------  
  언박싱  
  • JDK1.5 이전에는 기본형과 참조형간의 연산이 불가능
  • 기본형의 값을 객체로 자동변환하는 것을 오토박싱, 그 반대는 언박싱
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(10);                // 오토박싱. 10 -> new Integer(10)

int value = list.get(0);     // 언박싱. new Integer(10) -> 10

 

References

https://github.com/castello/javajungsuk_basic

 

GitHub - castello/javajungsuk_basic: 자바의 정석 기초편 관련 자료입니다.

자바의 정석 기초편 관련 자료입니다. Contribute to castello/javajungsuk_basic development by creating an account on GitHub.

728x90
반응형