Java.lang 패키지 요약 (Object, String, StringBuffer)

Object 클래스의 메서드

• protected Object clone() : 자기 자신 객체 복제
  • Cloneable 인터페이스 구현한 클래스의 인스턴스만 복제가 가능 
  • 사용하려면 public으로 오버라이딩 해줘야한다.
    • 인스턴스 변수가 참조형이면 객체도 복제되게 오버라이딩 필요
• public boolean equals(Object obj) : 객체 주소 비교
  • String 클래스는 기본적으로 값을 비교하도록 오버라이딩 되어있다.

public boolean equals(Object obj){
    return (this == obj); // 주소 비교
}

// 오버라이딩으로 객체의 값 비교로 바꾸기
class className{
    public boolean equals(Object obj){
        if(obj!=null && obj instanceof 클래스명){
            return id == ((className)obj).id;
        }else{
            return false;
        }
    }
}

• public Class getClass() : 자신의 클래스 정보를 담고 있는 class 인스턴스 반환

class card{
    int x = 1;
}

card c = new card();
        
Class cobj = card.class;
Class getclass = c.getClass();
        
String classname = cobj.getName();
        
System.out.println(cobj); // class card
System.out.println(getclass); // class card
System.out.println(classname); // card

• public int hashCode() : 해시코드 반환 (내부 주소를 정수형으로 변형하여 반환)
  • equals()를 오버라이딩하면 hashCode()도 같이 오버라이딩 해줘야한다.
    • 값을 정수형으로 변형하여 반환
  • String 클래스는 기본적으로 hashCode()도 오버라이딩 되어있다.
• public String toString() : 문자열로 반환
• public void notity() : 기다리는 쓰레드 하나 깨운다.
• public void notifyAll() : 기다리는 쓰레드 모두 깨운다.
• public void wait() : notify() or notifyAll()을 호출 할 때 까지 현재 쓰레드 무한히 대기
• public void wait(long timeout) : notify() or notifyAll()을 호출 할 때 까지 현재 쓰레드를 timeout(천분의 1초) 대기
• public void wait(long timeout, int nanos) : notify() or notifyAll()을 호출 할 때 까지 현재 쓰레드를 timeout(천분의 1초), nanos(10^9분의 1초) 대기

String 클래스

• 한번 정해진 내용은 불변하다.(immutable)
• 문자형 배열(char[])과 그에 관련된 메서드들이 정의되어 있다.

String a = "abc";
String b = "abc";
두 참조변수(a,b)의 주소값은 같다.
String A = new String("abc");
String B = new String("abc");
두 참조변수(A,B)의 주소값은 다르다.
ex) 
a == b :

• equals()와 hashCode()가 자체적으로 값을 기준으로 하게 오버라이딩 되어있다.
• 빈 문자열을 만들어 줄때는 String = ""(빈문자), char = ' '(공백)로 초기화한다.

String 클래스 생성자 및 메서드

• String(String s) : 주어진 문자열(s)를 갖는 String인스턴스를 생성한다.
  • String s = new String("Hello"); >> "Hello"
• String(char[] value) : 주어진 문자형 배열(value)을 문자열로 갖는 String인스턴스를 생성한다.
  
  • char[] value = {'H','I'}
  • String s = new String(value); >> "HI"
• String(StringBuffer buf) : StringBuffer인스턴스가 갖고 있는 문자열의 내용의 String인스턴스를 생성한다.
  • StringBuffer buf = new StringBuffer("Hello");
  • String s = new String(buf); >> "Hello"
• char charAt(int index) : 지정된 위치(index)의 문자를 반환한다.
  • String s = new String("Hello");
  • char c = s.charAt(1);  >> 'e'
• String concat(String str) : 지정된 문자열(str)을 뒤에 붙인다.
  • String str1 = "Hello";
  • String str2 = str1.concat(" World"); >> "Hello World"
• boolean contains(CharSequence s) : 지정된 문자열(s)이 포함되었는지 검사한다.
  • String str1 = "abcdefg";
  • boolean b = str1.contains("bc"); >> true
• boolean endsWith(String str) : 지정된 문자열(str)로 끝나는지 검사한다.
• boolean startsWith(String str) : 지정된 문자열(str)로 시작하는지 검사한다. 
  • String str1 = "Hello.txt";
  • boolean b1 = str1.endsWith("txt"); >> true
  • boolean b2 = str1.startsWith("He"); >> true
• boolean equals(Object o) : 매개변수로 받은 문자열(o)과 String인스턴스의 문자열을 비교한다.
  • 매개변수 o가 String이 아니라면 false를 반환한다.
  • String str = "Hello";
  • boolean b1 = str.equals("hello"); >> false
  • boolean b2 = str.equals("Hello"); >> true
• boolean equalsIgnoreCase(String str) : 문자열(str)과 String 인스턴스의 문자열을 대소문자 구분없이 비교한다.
  • String str = "Hello";
  • boolean b1 = str.equalsIgnoreCase("hello"); >> true
  • boolean b2 = str.equalsIgnoreCase("Hello"); >> true
• int indexOf(char ch) : 지정된 문자(ch)가 문자열에 존재하는지 확인하여 위치를 반환한다.
• int indexOf(String str) : 지정된 문자열(str)이 문자열에 존재하는지 확인하여 첫번째 문자위치를 반환한다.
• int lastIndexOf(char ch) : 지정된 문자(ch)를 문자열의 역방향으로 찾아서 위치를 반환한다.
  • String str1 = "Hello";
  • String str2 = "java.lang.Object";
  • int index1 = str.indexOf('e'); >> 1
  • int index2 = str.indexOf('g'); >> -1
  • int index3 = str.indexOf("lo"); >> 3
  • int index4 = str2.lastIndexOf('.'); >> 9
  • int index5 = str2.lastIndexOf('g'); >> -1
• String intern() : 문자열 constant pool에 등록하고 이미 constant pool에 같은 내용의 문자열이 있다면 그 문자열의 주소값을 반환한다.
  • String str1 = new String("abc");
  • String str2 = new String("abc");
  • boolean b1 = (str1 == str2); >> false
  • boolean b2 = str1.equals(str2); >> true
  • String internTest = str1.intern(); >> "abc"
• int length() : 문자열의 길이를 반환한다.
  • String str = "Hello";
  • int length = str.length(); >> 5
• String replace(char old, char new) : 문자열 중 지정된 문자(old)를 찾아서 문자(new)로 바꿔서 문자열을 반환한다.
• String replace(String old, String new) : 문자열 중 지정된 문자열(old)를 찾아서 문자열(new)로 바꿔서 문자열을 반환한다.
  
  • String str1 = "Hello";
  • String str2 = str1.replace('H','h'); >> "hello"
  • String str3 = str1.replace("lo","LO"); >> "helLO"
• String replaceAll(CharSequence old, String new) : 문자열 중 지정된 문자열(old)를 찾아서 문자열(new)로 바꿔서 문자열을 반환한다.
  • replaceAll은 replace와 다르게 정규표현식을 사용할 수 있다.
  • String str1 = "AABBCCBB";
  • String str2 = str1.replaceAll("BB", "oo"); >> "AAooCCoo"
  • String str3 = str1.replaceAll("[ABC]","!"); >> "!!!!!!!!"
    • [ABC] = "A" or "B" or "C"라면 "!"로 바꿔라
• String replaceFirst(String old, String new) : 문자열 중 지정된 문자열중 첫번째로 찾은 문자열(old)만 문자열(new)로 바꿔서 문자열을 반환한다.
  • String str1 = "AABBCCBB";
  • String str2 = str1.replaceFirst("BB", "oo"); >> "AAooCCBB"
• String[] split(String regex) : 문자열을 지정된 분리자(regex)로 나눠서 문자열 배열에 담아 반환한다.
  • String animals = "dog,cat,bear";
  • String[] arr = animals.split(","); >> arr[0] = "dog", arr[1] = "cat", arr[2]="bear"
• String substring(int begin) : 주어진 시작위치(begin)부터 끝까지 문자열을 반환한다.
• String substring(int begin, int end) : 주어진 시작위치(begin)부터 끝위치(end) 전까지 문자열을 반환한다.
  • String str1 = "java.lang.Object";
  • String str2 = str1.substring(10); >> "Obejct"
  • String str3 = str1.substring(5, 9); >> "lang"
• String toLowerCase() : String 인스턴스에 저장되있는 문자열을 소문자로 변환하여 반환한다.
• String toUpperCase() : Stirng 인스턴스에 저장되있는 문자열을 대문자로 변환하여 반환한다.
  • String str1 = "Hello Im JANG";
  • String str2 = str1.toLowerCase(); >> "hello im jang"
  • String str3 = str1.toUpperCase(); >> "HELLO IM JANG"
• String trim() : 문자열의 양 끝에 있는 공백을 제거해서 반환한다.
  • String str1 = "      Hello Im Jang  ";
  • String str2 = str1.trim(); >> "Hello Im jang"
• static String.valueOf(Type value) : 지정된 값(Type value)을 문자열로 변환하여 반환한다.
  • 참조 변수의 경우 toString()을 호출한 결과를 반환한다.
  • toString()과 가장 큰 차이점은 null을 처리여부 입니다.
  • String b = String.valueOf(true); >> "true" / 기본형을 문자열로
  • String c = String.valueOf('a'); >> "a" / 기본형을 문자열로
  • String i = String.valueOf(100); >> "100" / 기본형을 문자열로
  • String l = String.valueOf(100L); >> "100" / 기본형을 문자열로
  • String f = String.valueOf(10f); >> "10.0" / 기본형을 문자열로
  • String d = String.valueOf(10.0); >> "10.0" / 기본형을 문자열로
  • java.util.Date o = new java.util.Data();
    • String data = String.valueOf(o); >> "Wed Aug 10 05:55:30 GMT 2022"
    • == String data = o.toString();

Object obj = null;
System.out.println(String.valueOf(obj)); // "null"
System.out.println(obj.toString()); // NullPointerException Error 발생

• 문자열을 기본형으로 바꾸는 방법
  • Boolean.getBoolean(String s); >> 그냥 사용시 false가 나온다.
    • Boolean.valueOf(String s); >> 문자열을 그대로 boolean으로 바꾼다.
  • Byte.parseByte(String s);
    • Byte.valueOf(String s);
  • short.parseShort(String s);
    • Short.valueOf(String s);
  • Integer.parseInt(String s);
    • Integer.valueOf(String s); >> JDK 1.5 부터 가능
  • Long.parseLong(String s);
    • Long.valueOf(String s);
  • Float.parseFloat(String s);
    • Float.valueOf(String s);
  • Double.parseDouble(String s);
    • Double.valueOf(String s);

StringBuffer 클래스 특징 및 메서드

• String 클래스와 다른 점은 내용을 수정할 수 있다는 점과 equals()가 오버라이딩 되어 있지 않다는 것이다.
• 인스턴스를 생성할 때 버퍼(배열)의 크기를 충분히 지정해주는 게 좋다.
  • 버퍼가 작으면 성능이 저하된다.

메서드

• StringBuffer() : 16문자를 담을 수 있는 버퍼를 가진 StringBuffer 인스턴스가 생성된다.
• StringBuffer(int length) : 지정된 개수(length)만큼 문자를 담을 수 있는 StringBuffer인스턴스가 생성된다.
• StringBuffer(String str) : 지정된 문자열(str)을 갖는 StringBuffer인스턴스를 생성한다.
  
  • StringBuffer sb = new StringBuffer(); >> ""
  • StringBuffer sb = new StringBuffer(10); >> "" (배열 공간 10)
  • StringBuffer sb = new StringBuffer("Hello"); >> "Hello"
• StringBuffer append(Type value) : 매개변수에 입력된 값을 문자열로 변환하여 StringBuffer인스턴스에 저장하고 있는 문자열 뒤에 덧붙인다.
  • Type = boolean, char[], char, float, long, String, double, int, Object
  • StringBuffer sb1 = new StringBuffer("abc"); >> "abc"
  • StringBuffer sb2 = sb1.append(true); >> "abctrue"
  • sb1.append('d').append(10.0f); >> "abctrued10.0"
  • StringBufer sb3 = sb1.append("ABC").append(123); >> "abctrued10.0ABC123"
  • sb1 = "abctrued10.0ABC123"
  • sb2 = "abctrued10.0ABC123"
  • sb3 = "abctrued10.0ABC123"
• int capacity() : StringBuffer인스턴스의 버퍼크기를 반환한다.
• int length() : StringBuffer인스턴스에 저장된 문자열의 길이를 반환한다.
  • StringBuffer sb = new StringBuffer(100);
  • sb.append("abcd");
  • int BufferSize = sb.capacity(); >> 100
  • int StringSize = sb.length(); >> 4;
• char charAt(int index) : 지정된 위치(index)에 있는 문자를 반환한다.
  • StringBuffer sb = new StringBuffer("abc");
  • char c = sb.charAt(2); >> 'c'
• StringBuffer delete(int start, int end) : 시작위치(start)부터 끝위치(end)전까지의 문자를 제거한 후 문자열 반환
  • StringBuffer sb = new StringBuffer("0123456");
  • String sb2 = sb.delete(3,6); >> "0126"
• StringBuffer deleteCharAt(int index) : 지정된 위치(index)의 문자를 제거한다.
  • StringBuffer sb = new StringBuffer("abc");
  • String sb2 = sb.deleteCharAt(2); >> "ab"
• StringBuffer insert(int pos, Type value) : 두번째 매개변수에 입력된 값을 문자열로 변환하여 지정된 위치(pos)에 추가한다.
  • Type = boolean, char, char[], int, float, long, double, String, Object 
  • StringBuffer sb = new StringBuffer("abc");
  • sb.insert(2, '!'); >> "ab!c"
• StringBuffer replace(int start, int end, String str) : 지정된 범위(start <= x < end)의 문자를 주어진 문자열(str)로 바꿔서 반환한다.
  • StringBuffer sb = new StringBuffer("abcd");
  • sb.replace(1,3,"BC"); >> "aBCd"
• StringBuffer reverse() : StringBuffer인스턴스에 저장되어 있는 문자열의 순서를 거꾸로 나열한다.
  • StringBuffer sb = new StringBuffer("123456");
  • sb.reverse(); >> "654321"
• void setCharAt(int index, char ch) : 지정된 위치(index)에 있는 문자를 주어진 문자(ch)로 바꾼다.
  • StringBuffer sb = new StringBuffer("abc");
  • sb.setCharAt(1, 'Z'); >> "aZc"
• String toString() : StringBuffer인스턴스를 String으로 변환 하여 반환한다.
  • StringBuffer sb = new StringBuffer("abc");
  • String str = sb.toString();
• String substring(int start) : 지정된 위치(start)부터 문자열 끝까지 반환한다.
• String substring(int start, int end) : 지정된 범위(start <= x < end)만큼의 문자열을 반환한다.
  • StringBuffer sb = new StringBuffer("abcd");
  • String str1 = sb.substring(1); >> "bcd"
  • String str2 = sb.substring(1,3); >> "bc"

Math 메서드

• static int abs(int f);
• static long abs(long f);
• static float abs(float f);
• static double abs(double f);
  • 주어진 값의 절대값을 반환한다.
  • int i = Math.abs(10); >> 10 
  • int i = Math.abs(-11); >> 11
  • double d = Math.abs(-12.0) >> 12.0 
• static double ceil(double d) : 입력된 실수(d)의 소수점 첫번째 자리에서 올림하여 반환
• static double floor(double d) : 입력된 실수(d)의 소수점을 버린 후 반환한다.
  • double d1 = Math.ceil(10.1); >> 11.0
  • double d2 = Math.ceil(-8.2); >> -8.0
  • double d4 = Math.ceil(123.456789); >> 123.0
• static Type max(Type a, Type b) : 입력된 두 값(a,b)를 비교해서 큰 값을 반환한다.
• static Type min(Type a, Type b) : 입력된 두 값(a,b)를 비교해서 작은 값을 반환한다.
  • Type = int, float, long, double
  • int  i = int max(10,5); >> 10
  • double d = double min(9.5, 9.50001); >> 9.5
• static double random() : 0.0 <= x < 1.0 범위에서 무작위로 실수 하나를 반환한다.
  • double d = Math.random(); >> 0.0 <= x < 1.0
  • int i = (int)(Math.random()*10)+1; >> 1 <= x < 10
• static double rint(double a) : 주어진 값(a)와 가까운 정수를 반환한다.
  • 단, 1.5, 2.5 처럼 가운데 숫자는 가까운 짝수를 반환한다.
  • double d1 = Math.rint(1.5); >> 2
  • double d2 = Math.rint(-5.11); >> -5
• static long round(Type value) : 소수점 첫번째자리에서 반올림한 정수값을 반환한다.
  
  • Type = double, float
  • long l1 = Math.round(-5.11); >> -5
  • long l2 = Math.round(5.55); >> 6
  • double d1 = 90.7522;
  • double d2 = Math.round(d1*100)/100.0; >> 90.76