[JAVA의 정석] Ch 9. java.lang 패키지와 유용한 클래스

1. java.lang 패키지

---

java.lang 패키지는 자바 프로그래밍에서 가장 기본이 되는 클래스들을 포함하고 있다. 그렇기에 java.lang 패키지의 클래스들은 import 문 없이도 사용할 수 있게 되어 있다.

 

1) Object 클래스

Object 클래스는 모든 클래스의 최고 조상이기 때문에 Object 클래스의 멤버들은 모든 클래스에서 바로 사용 가능하다.

Object 클래스는 멤버 변수는 없고 오직 11개의 메서드만 가지고 있다. 

Object 클래스의 메서드	설명
protected Object clone()	객체 자신의 복사본을 반환한다
public boolean equals(Object obj)	객체 자신과 객체 obj가 같은 객체인지 알려준다 (같으면 true)
protected void finalize()	객체가 소멸될 때 가비지 컬렉터에 의해 자동적으로 호출된다. 이 때 수행되어야하는 코드가 있을 떄 오버라이딩한다. (거의 사용 안 함)
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)동안 기다리게 한다.

 

equals(Object obj)

매개변수로 객체의 참조 변수를 받아서 비교하여 그 결과를 boolean 값으로 알려주는 메서드이다.

아래의 코드는 equals() 메서드의 실제 내용이다. 보면 알 수 있듯이 두 객체의 같고 다름을 참조 변수의 값으로 판단하기 때문에 서로 다른 두 객체를 equals() 메서드로 비교하면 항상 false를 결과로 얻게 된다. 

public boolean equals(Object obj){
    return this == obj;
}

 

따라서 Object 클래스로부터 상속받은 equals 메서드는 결국 두 개의 참조 변수가 같은 객체를 참조하고 있는지, 즉 두 참조 변수에 저장된 값(주소값)이 같은지를 판단하는 기능밖에 할 수 없다. 만일 equals 메서드로 객체가 같은 값을 가지고 있는지 확인하고 싶으면 오버라이딩하여 객체에 저장된 내용을 비교하도록 변경하면 된다.

 

 

hashCode()

 이 메서드는 해싱 기법에 사용되는 해시 함수를 구현한 것이다. 해싱은 데이터 관리 기법 중의 하나로 다량의 데이터를 저장하고 검색하는 데 유용하다. 해시 함수는 찾고자 하는 값을 입력하면, 그 값이 저장된 위치를 알려주는 해시 코드를 반환한다. 

 Object 클래스에 정의된 hashCode 메서드는 객체의 주소값으로 해시 코드를 만들어 반환한다. 

 

 String 클래스는 문자열의 내용이 같으면, 동일한 해시 코드를 반환하도록 hashCode()가 오버라이딩되어 있다. 반면에 System.identityHashCode(Object x)는 Object 클래스의 hashCode 메서드처럼 객체의 주소값으로 해시 코드를 생성하기 때문에 모든 객체에 대해 항상 다른 해시코드 값을 반환할 것을 보장한다.

String str1 = new String("abc");
String str2 = new String("abc");

System.out.println(str1.hashCode());                 // 96354
System.out.println(str2.hashCode());                 // 96354
System.out.println(System.identityHashCode(str1));   // 27193795
System.out.println(System.identityHashCode(str2));   // 1249762

 

 

toString()

이 메서드는 인스턴스에 대한 정보를 문자열로 제공할 목적으로 정의한 것이다. 

클래스를 작성할 때, toString()을 오버로딩하지 않는다면 아래와 같은 내용이 그대로 사용될 것이다. 즉, toString()을 호출하면 클래스이름에 16진수의 해시코드를 얻게 될 것이다.

public String toString(){
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

 

아래 Card 인스턴스에서 toString()을 호출하면, Object의 toString()이 호출된다. 그 결과 클래스이름과 해시코드가 함께 출력된다. 서로 다른 인스턴스에 대해 toString()을 호출하였으므로 클래스의 이름은 같아도 해시코드 값이 다르다는 것을 확인할 수 있다.

class Card{
    String kind;
    int num;
}

class CardToString{
    public static void main(String[] args){
         Card c1 = new Card();
         Card c2 = new Card();
         
         System.out.println(c1.toString());         // Card@19e0bfd
         System.out.println(c2.toString());         // Card@139a55
    }
}

 

 

clone()

이 메서드는 자신을 복제하여 새로운 인스턴스를 생성하는 일을 한다. 

Object 클래스에 정의된 clone()은 단순히 인스턴스 변수의 값만 복사하기 때문에 참조 타입의 인스턴스 변수가 있는 클래스는 완전한 인스턴스 복제가 이루어지지 않는다. 예를 들어 배열의 경우, 복제된 인스턴스도 같은 배열의 주소를 갖기 때문에 인스턴스의 작업이 원래의 인스턴스에 영향을 미치게 된다. 이런 경우 clone 메서드를 오버라이딩해서 새로운 배열을 생성하고 배열의 내용을 복사하도록 해야 한다. 

 

clone()을 사용하려면, 먼저 복제할 클래스가 Cloneable 인터페이스를 구현해야 하고, clone()을 오버라이딩하면서 접근 제어자를 protected에서 public으로 변경해야 한다. 그래야만 상속 관계가 없는 다른 클래스에서 clone()을 호출할 수 있다.

class Point implements Cloneable{       // Cloneable 인터페이스 구현

    ...
    
    public Object clone(){              // 접근제어자를 public으로 변경
         Object obj = null;
         try{
             obj = super.clone();       // try-catch 내에서 조상 클래스의 clone() 호출
         } catch (CloneNotSupportedException e){
         }
         return obj;
   }
}

 

 

얕은 복사와 깊은 복사

clone()은 단순히 객체에 저장된 값을 그대로 복제할 뿐, 객체가 참조하고 있는 객체까지 복제하지 않는다. 이러한 복사를 얕은 복사라고 한다.

얕은 복사(shallow copy) : 원본을 변경하면 복사본도 영향을 받는 복사
깊은 복사(deep copy) : 원본이 참조하고 있는 객체까지 복제하는 것

public Circle shallowClone(){              // 얕은 복사
     Object obj = null;
     try{
          obj = super.clone();       
     } catch (CloneNotSupportedException e){
     }
     return obj;
}

public Circle deepClone(){              // 깊은 복사
     Object obj = null;
     try{
          obj = super.clone();       
     } catch (CloneNotSupportedException e){
     }
     Circle c = (Circle) obj;
     c.p = new Poine(this.p.x, this.p.y);
     return c;
}

 

 

getClass()

이 메서드는 자신이 속한 클래스의 Class 객체를 반환하는 메서드인데, Class 객체는 이름이 'Class'인 클래스의 객체이다.

public final class Class implements ... {    // Class 클래스

}

 

 파일 형태로 저장되어 있는 클래스를 읽어서 Class 클래스에 정의된 형식으로 변환하는 것이다. 즉, 클래스 파일을 읽어서 사용하기 편한 형태로 저장해 놓은 것이 클래스 객체이다.

 

 

2) String 클래스

변경 불가능한(immutable) 클래스

String 클래스에는 문자열을 저장하기 위해 문자형 배열 참조변수(char[])를 인스턴스 변수로 정의해두었다. 인스턴스 생성 시, 생성자의 매개변수로 입력받는 문자열은 이 인스턴스 변수에 문자형 배열로 저장되는 것이다.

public final class String implements java.io.Serializable, Comparable{
      private char[] value;
      ...

 

- 한 번 생성된 String 인스턴스가 갖고 있는 문자열은 읽어올 수만 있고, 변경할 수는 없다.

- 덧셈 연산자 '+'를 사용해서 문자열을 결합하는 것은 연산 시마다 새로운 문자열을 가진 String 인스턴스가 생성되어 메모리 공간을 차지하게 되므로 가능한 한 결합횟수를 줄이는 것이 좋다

 

 

문자열의 비교

문자열을 만들 때는 문자열 리터럴을 사용하는 방법과 String 클래스의 생성자를 사용해서 만드는 방법이 있다.

 

String 클래스의 생성자를 이용한 경우에는 new 연산자에 의해서 메모리 할당이 이루어지기 때문에 항상 새로운 String 인스턴스가 생성된다. 그러나 문자열 리터럴은 이미 존재하는 것을 재사용하는 것이다. 따라서 아래 코드의 str1과 str2는 같은 객체를 참조하지만, str3과 str4는 서로 다른 주소를 가진 다른 객체이다.

String str1 = "abc";                    // 문자열 리터럴
String str2 = "abc";                    // 문자열 리터럴
String str3 = new String("abc");        
String str4 = new String("abc");

 

- 두 문자열의 내용을 비교하기 때문에 equals()를 사용했을 때는 str3과 str4는 true를 결과값을 얻는다. 하지만 String 인스턴스의 주소를 등가 비교 연산자 '=='로 비교했을 때는 false가 나온다.

 

 

빈 문자열

'String s = "";'와 같은 문장이 있을 때, 참조 변수 s가 참조하고 있는 String 인스턴스는 내부에 'new char[0]'과 같이 길이가 0인 char형 배열을 저장하고 있는 것이다. 

 

(주의)
String s = ""; 와 같은 표현이 가능하다고 해서 char c = '';와 같은 표현도 가능한 것은 아니다. char형 변수에는 반드시 하나의 문자를 지정해야 한다.
String은 참조형 타입의 기본값인 null보다는 빈 문자열로, char형은 기본값이 '/u0000' 대신에 공백으로 초기화하는 것이 보통이다.

 

 

String 클래스의 생성자와 메서드

메서드 / 설명	예제	결과
String(String s)	String s = new String("Hello");	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 idx)	String s = "Hello"; char c = s.charAt(2);	c = 'l'
지정된 위치(idx)에 있는 문자를 알려준다 (idx는 0부터 시작)
int compareTo(String str)	int i = "bbb",compareTo("aaa"); int i2 = "bbb",compareTo("bbb"); int i3 = "bbb",compareTo("ccc");	i = -1 i2 = 0 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");	b = true
문자열과 String 인스턴스의 문자열을 대소문자 구분없이 비교한다
int indexOf(String str)	String s = "Hello"; int idx1 = s.indexOf('o'); int idx2 = s.indexOf('k');	idx1 = 4 idx2 = -1
주어진 문자열이 존재하는지 확인하여 그 위치(index)를 알려준다. 없으면 -1을 반환한다
String intern()	String s = new String("abc"); String s2 = new String("abc"); boolean b = (s.intern() == s2.intern()	b = true
문자열의 상수풀에 등록한다 이미 상수풀에 같은 내용의 문자열이 있을 경우 그 문자열의 주소값을 반환한다
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 replace(char old, char new)	String s = "Hello"; String s1 = s.replace('H', 'C');	s1 = "Cello"
문자열 중의 문자(old)를 새로운 문자(new)로 바꾼 문자열을 반환한다
String replace(CharSequence old, CharSequence new)	String s = "Hellollo"; String s1 = s.replace("ll", "LL")	s1 = "HeLLoLLo"
문자열 중의 문자열(old)를 새로운 문자열(new)로 모두 바꾼 문자열을 반환한다
String replaceAll(String regex, String replacement)	String ab = "AABBAABB"; String r = ab.replaceFirst("BB", "bb");	r = "AAbbAAbb"
문자열 중에서 지정된 문자열(regex)과 일치하는 것을 새로운 문자열(replacement)로 모두 변경한다
String replaceFirst(String regex, String replacement)	String ab = "AABBAABB"; String r = ab.replaceFirst("BB", "bb");	r = "AAbbAABB"
문자열 중에서 지정된 문자열(regex)과 일치하는 것 중 첫 번째 것만 새로운 문자열(replacement)로 변경한다
String[] split(String regex)	String anumals = "dog,cat,bear"; String[] arr = animals.split(","2);	arr[0] = "dog"; arr[1] = "cat" arr[2] = "bear"
문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다
String[] split(String regex, int limit)	String anumals = "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"
주어진 시작위치(begin)부터 끝 위치(end) 범위에 포함된 문자열을 얻는다. 이 때, 시작 위치의 문자는 범위에 포함되지만, 끝 위치의 문자는 포함되지 않는다 (begin <= x < end)
String toLowerCase()	String s = "Hello"; String s1 = s.toLowerCase();	s1 = "hello"
String 인스턴스에 저장되어 있는 모든 문자열을 소문자로 변환하여 반환한다
String toString()	String s = "Hello" String s1 = s.toString();	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(true); String i = String.valueOf(true); String l = String.valueOf(true); String f = String.valueOf(true); String d = String.valueOf(true); java.util.Date dd = new java.util.Date(); String date = String.valueOf(dd);	b = "true" c = "a" i = "100" l = "100" f = "10.0" date ="Wed Jan 27 21:46:29 KST 2025"
지정된 값을 문자열로 변환하여 반환한다. 참조 변수의 경우, 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

 

java.util.StringJoiner 클래스를 사용해서 문자열을 결합할 수도 있다.

StringJoiner sj = new StringJoiner(",", "[", "]");
String[] strArr = {"aaa", "bbb", "ccc"};

for(String s : strArr)
      sj.add(s.toUpperCase());
      
System.out.println(sj.toString());   // [AAA,BBB,CCC]

 

 

String.format()

format()은 형식화된 문자열을 만들어 내는 간단한 방법이다. printf()하고 사용법이 완전히 동일하다.

String str = String.format("%d 더하기 %d", 3, 5);

 

 

기본형 값을 String으로 변환

기본형을 문자열로 변경하는 방법은 간단하다. 숫자에 빈 문자열""을 더해주기만 하면 된다. 이외에도 valueOf()를 사용하는 방법도 있다.

int i = 100;
String str1 = i + "";
String str2 = String.valueOf(i);

 

 

String을 기본형 값으로 변환

반대로 String을 기본형으로 변환하는 방법도 간단하다. valueOf()를 쓰거나 parseInt()를 사용하면 된다.

int i = Integer.parseInt("100");
int i2 = Integer.valueOf("100");

 

기본형 -> 문자열	문자열 -> 기본형
String String.valuOf(boolean b) String String.valuOf(char c) String String.valuOf(int i) String String.valuOf(long l) String String.valuOf(float f) String String.valuOf(double d)	boolean Boolean.parseBoolean(String s) byte Byte.parseByte(String s) short Short.parseShort(String s) int Integer.parseInt(String s) long Long.parseLong(String s) float Float.parseFloat(String s) double Double.parseDouble(String s)

 

 

3) StringBuffer 클래스와 StringBuilder 클래스

String 클래스는 인스턴스를 생성할 때 지정된 문자열을 변경할 수 없지만, StringBuffer 클래스는 변경이 가능하다. 내부적으로 문자열 편집을 위한 버퍼를 가지고 있으며, StringBuffer 인스턴스를 생성할 때 그 크기를 지정할 수 있다. 이 때, 편집할 문자열의 길이를 고려하여 버퍼의 길이를 충분히 잡아주는 것이 좋다.

 

아래의 코드를 보면 알 수 있듯이, StringBuffer 클래스는 String 클래스와 같이 문자열을 저장하기 위한 char형 배열의 참조 변수를 인스턴스 변수로 선언해 놓고 있다.

public final class StringBuffer implements java.io.Serializable{
     private char[] value;
     ...
}

 

 

StringBuffer의 생성자

 StringBuffer 클래스의 인스턴스를 생성할 때, 적절한 길이의 char형 배열이 생성되고, 이 배열은 문자열을 저장하고 편집하기 위한 공간(buffer)로 사용된다. 

 

 StringBuffer 인스턴스를 생성할 때는 생성자 StringBuffer(int length)를 사용해서 StringBuffer 인스턴스에 저장될 문자열의 길이를 고려하여 충분히 여유있는 크기로 지정하는 것이 좋다. StringBuffer 인스턴스를 생성할 때 ,버퍼의 크기를 지정해주지 않으면 16개의 문자를 저장할 수 있는 크기의 버퍼를 생성한다

 

StringBuffer 인스턴스로 문자열을 다루는 작업을 할 때, 버퍼의 크기가 작업하려는 문자열의 길이보다 작을 때는 내부적으로 버퍼의 크기를 증가시키는 작업이 수행된다. 배열의 길이는 변경될 수 없으므로 새로운 길이의 배열을 생성한 후에 이전 배열의 값을 복사한다.

 

 

StringBuffer의 변경

String과 달리 StringBuffer는 내용을 변경할 수 있다.

append()는 반환타입이 StringBuffer인데, 자신의 주소를 반환한다. 그래서 하나의 StringBuffer 인스턴스에 대해 아래와 같이 연속적으로 append()를 호출하는 것이 가능하다.

StringBuffer sb = new StringBuffer("abc");
sb.append("1234").append("zz");

 

 

StringBuffer의 비교

String 클래스에서는 equals 메서드를 오버라이딩해서 문자열의 내용을 비교하도록 구현되어 있지만, StringBuffer 클래스는 equals 메서드를 오버라이딩하지 않아서  StringBuffer 클래스의 equals 메서드를 사용해도 등가 비교 연산자(==)로 비교한 것과 같은 결과를 얻는다

StringBuffer sb = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");

System.out.println(sb == sb2);        // false
System.out.println(sb.equals(sb2);    // false

 

반면에 toString()은 오버라이딩되어 있어서 StringBuffer 인스턴스에 toString()을 호출하면, 담고 있는 문자열을 String으로 반환한다. 그래서 StringBuffer 인스턴스에 담긴 문자열을 비교하기 위해서는 StringBuffer 인스턴스에 toString()을 호출해서 String 인스턴스를 얻은 다음, 여기에 equals 메서드를 사용해서 비교해야 한다

String s = sb.toString();
String s2 = sb2.toString();

System.out.println(s.equals(s2));    // true

 

 

StringBuffer 클래스의 생성자와 메서드

StringBuffer 클래스 역시 문자열을 다루기 위한 것이기에 String 클래스와 유사한 것이 많다. 그리고 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("abc");	sb = "abc"
지정된 문자열 값(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 = "abc" sb2 = "abctrue"
매개 변수로 입력된 값을 문자열로 변환하여 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("0123456"); StringBuffer sb2 = sb.delete(3,6);	sb = "0126" sb2 = "0126"
시작 위치(start)부터 끝 위치(end) 사이에 있는 문자를 제거한다. 단 끝 위치의 문자는 제외
StringBuffer deleteCharAt(int index)	StringBuffer sb = new StringBuffer("01233456"); sb.deleteCharAt(3);	sb = "012456"
지정된 위치(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 o) StringBuffer insert(int pos, String str)	StringBuffer sb = new StringBuffer("0123456"); sb.insert(4. '.');	sb = "0123.456"
두 번째 매개변수로 받은 값을 문자열로 변환하여 지정된 위치(pos)에 추가한다. pos는 0부터 시작
int length()	StringBuffer sb = new StringBuffer("0123456"); int length = sb.length();	length = 7
StringBuffer 인스턴스에 저장되어 있는 문자열의 길이를 반환한다
StringBuffer replace(int start, int end, String str)	StringBuffer sb = new StringBuffer("0123456"); sb.replace(3, 6, "AB")	sb = "012AB6"
지정된 범위 (start ~ end)의 문자들을 주어진 문자열로 바꾼다. end 위치의 문자는 범위에 포함되지 않음 (start <= x < end)
StringBuffer reverse()	StringBuffer sb = new StringBuffer("0123456"); sb.reverse();	sb = "6543210"
StringBuffer 인스턴스에 저장되어 있는 문자열의 순서를 거꾸로 나열한다
void setCharAt(int index, char ch)	StringBuffer sb = new  StringBuffer("0123456"); sb..setCharAt(5, 'o');	sb = "01234o6"
지정된 위치의 문자를 주어진 문자(ch)로 바꾼다
void setLength(int new Length)	StringBuffer sb = new  StringBuffer("0123456"); sb.setLength(5); StringBuffer sb2 = new StringBuffer("0123456"); sb2.setLengt(10);	sb = "0123456" sb2 = "0123456    "
지정된 길이로 문자열의 길이를 변경한다. 길이를 늘리는 경우에 나머지 빈 공간을 널문자 '\u0000'로 채운다.
String toString()	StringBuffer sb = new StringBuffer("0123456"); String str = sb.toString();	str = "0123456"
StringBuffer 인스턴스의 문자열을 String으로 반환
String substring(int start) String substring(int start, int end)	StringBuffer sb = new StringBuffer("0123456"); String str = sb.substring(3); String str2 = sb.substring(3,5);	str = "3456" str2 = "34"
지정된 범위 내의 문자열을 String으로 뽑아서 반환한다. 시작 위치(start)만 지정하면 시작위치부터 문자열 끝까지 뽑아서 반환한다

 

 

StringBuilder란?

StringBuffer는 멀티쓰레드에 안전하도록 동기화되어 있다. 멀티 쓰레드로 작성된 프로그램이 아닌 경우, StringBuffer의 동기화는 불필요하게 성능만 떨어뜨리게 된다.  

 그래서 StringBuffer에서 쓰레드의 동기화만 뺀 StringBuilder가 새로 추가되었다. StringBuilder는 StringBuffer와 완전히 똑같은 기능으로 작성되어 있어서, 소스코드에서 StringBuffer 대신 StringBuilder를 사용하도록 바꾸기만 하면 된다.

 

 

4) Math 클래스

Math 클래스는 기본적인 수학 계산에 유용한 메서드로 구성되어 있다. 

Math 클래스의 생성자는 접근 제어자가 private이기 때문에 다른 클래스에서 Math 인스턴스를 생성할 수 없게 되어 있다. 그 이유는 클래스 내에 인스턴스 변수가 없어서 인스턴스를 생성할 필요가 없기 때문이다. Math 클래스의 메서드는 모두 static이면, 자연로그의 밑과 원주율 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,01)	d = 11.0
주어진 값을 올림하여 반환한다
static double floor(double a)	double d = Math.floor(10.01)	d = 10.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.5001)	d = 9.5001
주어진 두 값을 비교하여 큰 쪽을 반환한다
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.5001)	d = 9.5
주어진 두 값을 비교하여 작은 쪽을 반환한다
static double random()	int i = (int)(Math.random() * 10) + 1	1 <= i < 11
0.0 ~ 0.1 범위의 임의의 double값을 반환한다 (1.0은 범위에 포함되지 않는다)
static double rint(double a)	double d = Math.rint(1.2); double d2 = Math.rint(3.5);	d = 1.0 d2 = 4.0
주어진 double 값과 가장 가까운 정수값을 double형으로 반환한다. 단, 두 정수의 정가운데 있는 값(1.5, 2.5 등)은 짝수를 반환
static long round(double a) static long round(float a)	long l = Math.round(1.2);	l = 1
소수점 첫째자리에서 반올림한 정수값(long)을 반환한다. 매개 변수의 값이 음수인 경우, round()와 rint()의 결과가 다르다는 것에 주의하자

 

 

5) 래퍼(wrapper) 클래스

자바에서는 8개의 기본형을 객체로 다루지 않는데, 이것이 바로 자바가 완전한 객체 지향 언어가 아니라는 얘기를 듣는 이유다. 때로는 기본형 변수도 어쩔 수 없이 객체로 다뤄야 하는 경우가 있다. 이 떄 사용되는 것이 래퍼 클래스이다. 8개의 기본형을 대표하는 8개의 래퍼 클래스가 있는데, 이 클래스들을 이용하면 기본형 값을 객체로 다룰 수 있다. 

기본형	래퍼 클래스	생성자
boolean	Boolean	Boolean (boolean value) Boolean (String s)
char	Character	Character (char value)
byte	Byte	Byte (byte value) Byte (String s)
short	Short	Short (short value) Short (String s)
int	Integer	Integer (int value) Integer (String s)
long	Long	Long (long value) Long (String s)
float	Float	Float (double value) Float (float value) Float (String s)
double	Double	Double (double value) Double (String s)

 

 

2. 유용한 클래스

---

1) java.util.Objects 클래스

Object 클래스의 보조 클래스로, 모든 메서드가 static이다.

• isNull() : 해당 객체가 null인지 유무를 리턴한다
• requireNonNull() : 해당 객체가 null이 아니어야 하는 경우에 사용
  - 해당 객체가 null이라면 NullPointException이 발생한다.
  - 두 번째 매개변수로 예외 메시지 지정이 가능하다
• compare() : 두 비교 대상이 같으면 0, 크면 양수, 작으면 음수를 반환한다
• Objects의 equals() : null 검사를 하지 않아도 된다
• deepEquals() : 객체를 재귀적으로 비교하므로 다차원의 배열 비교도 가능하다
• hashCode() : 내부적으로 null 검사를 한 후, Object 클래스의 hashCode()를 호출한다
  - null일 때 0을 반환한다

 

 

2) java.util.Random 클래스

Math.random()은 내부적으로 Random 클래스의 인스턴스를 생성해서 사용한다. Math.random()과는 다르게 Random은 종자값(seed)를 설정 가능하다

 

Random 클래스의 생성자와 메서드

메서드	설명
Random()	현재 시간(System.currentTimeMillis())을 종자값으로 이용하는 Random 인스턴스를 생성한다
Random(long seed)	매개 변수 seed를 종자값으로 하는 Random 인스턴스를 생성한다
boolean nextBoolean()	boolean 타입의 난수를 반환한다
void nextBytes(byte[] bytes)	bytes 배열에 byte 타입의 난수를 채워서 반환한다
double nextDouble()	double 타입의 난수를 반환한다 (0.0 <= x < 1.0)
float nextFloat()	float 타입의 난수를 반환한다 (0.0 <= x < 1.0)
double nextGaussian()	평균은 0.0이고 표준편차는 1.0인 가우시안 분포에 따른 double 형의 난수를 반환한다
int nextInt()	int 타입의 난수를 반환한다
int nextInt(int n)	0 ~n 의 범위에 있는 int 값을 반환한다
long nextLong()	long 타입의 난수를 반환한다
void setSeed(long seed)	종자값을 주어진 값(seed)로 변경한다

 

 

3) java.util.Scanner 클래스

Scanner는 화면, 파일, 문자열과 같은 입력 소스로부터 문자 데이터를 읽어오는데 도움을 줄 목적으로 생성되었다.

입력 받을 값에 따라 nextLine(), nextInt(), nextLong() 등 다양하게 존재한다

 

 

4) java.util.StringTokenizer 클래스

StringTokenizer는 긴 문자열을 지정된 구분자(delimeter)를 기준으로 토큰이라는 여러 개의 문자열로 잘라내는 데 사용된다.

StringTokenizer는 단 하나의 문자의 구분자만 사용할 수 있기 때문에 , "=-*/-" 전체가 하나의 구분자가 아니라 각각의 문자가 모두 구분자임을 주의해야 한다.

 

StringTokenizer의 생성자와 메서드

생성자 / 메서드	설명
StringTokenizer(String str, String delim)	문자열(str)을 지정된 구분자(delim)로 나누는 StringTokenizer를 생성한다 (구분자는 토큰으로 간주되지 않음)
StringTokenizer(String str, String delim, boolean returnDelims)	문자열(str)을 지정된 구분자(delim)로 나누는 StringTokenizer를 생성한다 (returnDelims의 값을 true로 하면 구분자도 토큰으로 간주된다.)
int countTokens()	전체 토큰의 수를 반환한다
boolean hasMoreTokens()	토큰이 남아있는지 알려준다
String nextToken()	다음 토큰을 반환한다