[Java] 표준 API #1 - API 소개, Object(lang), Objects(util)

[API]

- Application Programming Interface

- 자바 어플리케이션 프로그래밍에 있어서 필요한 꾸러미들을 제공해줌

- 라이브러리

- 맥 기준 : /Library/Java/JavaVirtualMachines/jdk1.8.0_101.jdk/Contents/Home/jre/lib/rt.jar 포함

- API 문서 : http://docs.oracle.com/javase/8/docs/api/

[API 패키지]

1) java.lang : 문법 뿌리

- 기본적인 클래스 패키지

- Object : 클래스의 최상위 클래스

- System : jvm, 표준입출력, 가비지컬렉터

- Class : 리플렉션

- String

- StringBuffer, StringBuilder : 문자열 조작

- Math : 수학 관련

- Wrapper : primitive type data 객체 생성 등

2) java.util : 유틸리티 제공, 패키지별로 기능에 따라 나눠놨음 키야, 좋은 유틸리티가 많은듯

- Objects : Object의 메서드에서 사용하면 유틸리티

- Arrays : Array의 메서드에서 사용하면 좋을 유틸리티

- Calendar, Date

- StringTokenizer : 특정 문자 구분된 문자열 뽑아낼 때

- Random

- Comparator : 비교 대상, 비교 로직 구현할 수 있음(interface라 구현해야함)

[API 살펴보기]
- 어떤 메서드인지(어떤 유틸리티인지) 써보기, 외우는 것보다 어떤 기능이 있는지 알면 나중에 활용하기 좋으니

1) java.lang.Object

- 최상위 클래스 : 아무런 관계를 갖지않는 객체타입은 암묵적으로 extends Object

- 모든 클래스가 extends함 : Object method를 그냥 사용, 오버라이딩할 수도(메서드가 어떻게 돌아가는지 파악)

(1) equals

(2) hashCode

(3) toString

(4) clone : clone 오버라이딩 클래스가 Cloneable(인터페이스) 구현해야함(구현할 메서드는 없지만 명시하는 것임)

(5) finalize

package com.jinbro.source.stdapi.object;

import java.util.Date;
import java.util.HashMap;

public class ObjectTest {

    public static void main(String[] args) {
        String str1 = new String("aaa");
        String str2 = new String("aaa");
        /* equals : 객체가 가진 데이터가 동일한지 비교 */
        System.out.println(str1.equals(str2));

        Member m1 = new Member("1234");
        Member m2 = new Member("1234");
        /* hashCode : 객체 식별값 리턴, HashSet/HashMap/HashTable은 hashCode -> equals 차례대로 두 객체 동등비교 */
        System.out.println(m1.hashCode() + ", " + m2.hashCode());

        /* hashCode - String : 오버라이딩(값은 값을 가지면 같은 해쉬코드를 리턴하도록, 원래는 메모리 주소값을 가지고)  */
        System.out.println(str1.hashCode() + ", " + str2.hashCode());

        /* toString - 객체정보(클래스 풀네임@16진수해쉬코드), String, Date는 오버라이딩 */
        System.out.println(m1.toString());
        System.out.println(str1.toString());
        System.out.println(new Date().toString());

        /*
            clone - 얕은 복사를 할 때 사용 - 얕은복사는 reference type가 한쪽이라도 변경되면 복사된 쪽도 변경됨
            clone 오버라이딩 - reference type도 복제되도록(같은 객체주소 저장X)
        */
        Member m3 = m2.getClone();
        System.out.println(m2 == m3); // false, 얕은 복사(필드 - primitive: 값, reference : 주소 복사)
        System.out.println(m3.getId() + ", " + m2.getId());


        /* finalize : 가비지컬렉터가 객체 소멸시키기 전 실행시킴  */
        m1 = null;
        System.gc(); //가비지컬렉터 실행 요청 : 실행 시점을 정확히 알 수 없으므로 finalize보다 별도 메서드 사용하는 것이
    }
}


class Member implements Cloneable {
    private String id;
    private int[] scores;

    public Member(String id){
        this.id = id;
        this.scores = new int[]{1,2,3};
    }

    /***** getter / setter *****/
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public int[] getScores() {
        return scores;
    }
    public void setScores(int[] scores) {
        this.scores = scores;
    }

    /******************/

    public Member getClone(){
        Member cloned = null;
        try{
            cloned = (Member)this.clone(); //return type : Object
        }catch(CloneNotSupportedException e){
            System.out.println(e.getMessage());
        }
        return cloned;
    }



    /* 최상위 Object 클래스 equals를 오버라이딩 */
    @Override
    public boolean equals(Object obj) {

        boolean result = false;

        if(obj instanceof Member){
            Member member = (Member)obj;
            if(this.getId() == member.getId()){
                result = !result;
            }
        }
        return result;
    }

    @Override
    public String toString() {
        return "Member{" +
                "id='" + id + '\'' +
                '}';
    }


    /* clone 오버라이딩 : deep copy, reference 필드값 복제
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Member cloned = (Member)super.clone(); //primitive 값 복사는 그대로
        cloned.scores = Arrays.copyOf(this.scores, this.scores.length);

        return cloned;
    } */

    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.id + "라는 id값을 가진 객체가 소멸됩니다");
    }
}

/* HashMap Key 사용 : hashCode, equals 오버라이딩(같은 해쉬코드, 같은 데이터를 가지고 있으면 같은 객체) */
class KeyExample{
    public static void main(String[] args) {
        HashMap<Key, String> hashMap = new HashMap<Key, String>();
        hashMap.put(new Key(1), "안녕");
        hashMap.put(new Key(1), "안녕");

        System.out.println(hashMap.get(new Key(1)));

        System.out.println(new Key(1).hashCode()); // 1이 해쉬코드
    }
}

class Key{

    private int key;

    public Key(int num){
        key = num;
    }

    public int getKey() {
        return key;
    }

    //new Key(1)은 각각 따로이지만 같은 hashCode를 반환하도록하여 동일 취급하도록 함
    @Override
    public int hashCode() {
        return key;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Key){
            Key comparekey = (Key)obj;

            if(this.getKey() == comparekey.getKey()){
                return true;
            }
        }
        return false;
    }
}

2) java.util.Objects

- Object 메서드에서 사용하면 좋을 유틸리티, 오버라이딩 말고도 사용해도 상관은 없음

(1) compare

(2) equals, deepEquals

(3) hash

(4) isNull, nonNull, requireNonNone

(5) toString

package com.jinbro.source.stdapi.object;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;

public class ObjectsTest {
    public static void main(String[] args) {
        Student s1 = new Student("jinbro", 1);
        Student s2 = new Student("jinhyung", 2);

        /* compare : 두 객체 비교, 비교 기준 java.util.Comparator<T> - interface method 구현해야함(비교 대상, 기준) */
        int result = Objects.compare(s1, s2, new StudentNumCompare());
        System.out.println(result);


        /* equals : Object.equals와 같음, 객체타입이 오버라이딩했다면 equals의 결과, 두 객체 모두 null일 때 true를 반환함;;;  */
        System.out.println(Objects.equals(s1, s2));
        System.out.println(Objects.equals(new String("123"), new String("123")));

        /* deepEquals : Array를 제외하고는 Objects.equals와 같고 Array는 Arrays.deepEquals(배열 유틸리티) */
        int[] arr1 = new int[]{1,2,3};
        int[] arr2 = new int[]{1,2,3};
        System.out.println(Objects.equals(arr1, arr2));
        System.out.println(Objects.deepEquals(arr1, arr2));

        /* hash : 파라미터를 가지고 해쉬코드를 생성함, 내부적으로 Arrays.hashCode 사용(Object.hashCode()사용) */
        int code1 = Objects.hash(new String("123"), new Integer(1));
        int code2 = Objects.hash(new String("123"), new Integer(1));
        System.out.println(code1 + ", " + code2); // 1510352 같은 해쉬코드 출력

        /* hash : Object의 hashCode() 오버라이딩할 때 사용 */
        System.out.println(s1.hashCode() + ", " + s2.hashCode());

        /* isNull : 객체 null 여부(객체 == null)이 래핑된 메서드*/
        System.out.println(Objects.isNull(null));

        /* nonNull : 객체 !null 여부(객체 != null)이 래핑된 메서드*/
        System.out.println(Objects.nonNull(null));

        /* requireNonNull
            1) 객체 null일 때 NullPointerException 예외발생시킴
            2) 예외 message 전달도 가능 : String 전달 혹은 Supplier 인터페이스 익명구현 get()메서드(람다식)
               => java.util.function : 자바8에서 추가된 인터페이스(abstract 메서드 1개) 패키지
            3) null이 아니면 객체 반환  */

        String str1 = null;
        try{
            //String str2 = Objects.requireNonNull(str1);
            String str2 = Objects.requireNonNull(str1, ()->"???");
            //람다식(1.8) : Supplier 인터페이스 익명구현(익명구현이 뭔지, 왜하는지에 대한 포스팅할 것)
        } catch(NullPointerException e){
            System.out.println(e.getMessage());
        }

        /* toString : 객체 정보 출력, 두번쨰는 객체가 null일 경우 출력될 메세지  */
        System.out.println(Objects.toString(null, "아무것도 없잖아?"));

    }
}

class Student {
    private String name;
    private int num;

    public Student(String name, int num) {
        this.name = name;
        this.num = num;
    }

    /*** getter / setter ***/
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    /***********************/

    /* Objects.hash() 사용하지않고 바로 Arrays.hashCode() 사용 */
    @Override
    public int hashCode() {

        //Objects.hash(name, num)
        return Arrays.hashCode(new Object[]{name, num});
    }
}

class StudentNumCompare implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        if(o1.getNum() > o2.getNum()){
            return 1;
        } else if(o1.getNum() < o2.getNum()) {
            return -1;
        }
        return 0;
    }
}