[CH09] java.lang 패키지

본 포스팅은 자바의 정석 교재를 공부하며, 간단히 정리/기록 용도로 작성하였습니다. 혹여, 잘못된 내용이 있다면 지적해주시면 감사하겠습니다.

 

 

---

1. java.lang package

  자바의 기본이 되는 클래스를 포함한 패키지로, java.lang package 에 속하는 class 는 import 문 없이 사용가능하다.

 

1.1 Object 클래스

  1.1.1 public boolean equals(Object obj)

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

   위와 같이 구현된 메서드로 객체가 서로 같은지 아닌지를 판단한다.

class source{
    public static void main(String[] args) {
        Value v1 = new Value(10);
        Value v2 = new Value(10);

        if(v1.equals(v2))
            System.out.println("v1 == v2");
        else
            System.out.println("v1 != v2");
        v2=v1;

        if(v1.equals(v2))
            System.out.println("v1 == v2");
        else
            System.out.println("v1 != v2");
    }
}

class Value{
    int value;
    Value(int value){
        this.value = value;
    }
}

  equals 메서드는 주소값으로 객체를 비교하므로 멤버가 같더라도 주소가 다르면 false 를 반환한다. v2 = v1 를 수행하면 참조변수 v2 는 v1 이 참조하고 잇는 인스턴스의 주소가 저장되는 것이므로 v2 과 v1 의 주소는 같게 되고 이에 따라 true 가 반환되는 것이다. equals 메서드는 두 참조 변수가 같은 객체를 참조하는 지 여부를 파악하는 것인데, 인스턴스의 멤버 변수가 같은지 아닌지를 판단할 수 있도록 사용하기 위해서는 오버라이딩을 하여 구현해주면 된다.

class Value{
    int value;
    Value(int value) {
        this.value = value;
    }

    public boolean equals(Object obj){
        if(obj instanceof Value)
            return value == ((Value)obj).value;
        else return false;
    }
}

  String 클래스의 equals 메서드 역시 Object 클래스의 equals 메서드를 오버라이딩하여 String 인스턴스가 가지는 문자열을 비교하도록 구현되었다.

 

  1.1.2 hashCode()

  hash function 을 구현한 것으로 찾고자 하는 값을 입력하면 hash code 를 반환한다. 32 bit JVM 에서는 서로 다른 객체는 같은 hash code 를 가질 수 없었지만, 64 bit JVM 에서는 8 byte 주소값으로 해쉬코드 (4 byte) 를 만드므로 해쉬 코드가 중복될 수 있다. 클래스의 인스턴스 변수 값을 이용해서 객체의 같고 다름을 판단할 때에는 equals 메서드 외에도 hashCode 메서드도 적절하게 오버라이딩해주어야 한다. 같은 객체이면 hashCode 메서드를 호출했을 때의 hash code 도 같아야 하기 때문이다.

class source{
    public static void main(String[] args) {
        String str1 = new String("abc");
        String str2 = new String("abc");

        System.out.println(str1.equals(str2));

        System.out.println(str1.hashCode());
        System.out.println(str2.hashCode());

        System.out.println(System.identityHashCode(str1));
        System.out.println(System.identityHashCode(str2));
    }
}

  String 클래스에서는 문자열의 내용이 같으면 같은 hashCode 를 반환하도록 오버라이딩 되어있다. 반면 System.identityHashCode(Object x) 는 Object 클래스에서와 같이 객체의 주소값으로 hash Code 를 생성하므로 모든 객체에 대해 항상 다른 해쉬 코드를 반환함을 보장할 수 있다.

 

  1.1.3 toString()

    인스턴스에 대한 정보를 문자열로 제공한다. 

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

위와 같이 구현되어 있다. getClass() 와 hashCode() 는 Object 클래스에 정의된 것으로 인스턴스 생성 없이 호출 가능하다.

class source{
    public static void main(String[] args) {
        Card c1 = new Card();
        Card c2 = new Card();

        System.out.println(c1.toString());
        System.out.println(c2.toString());
    }
}

class Card{
    String kind;
    int number;

    Card(){
        this("SPADE", 1);
    }
    Card(String kind, int number){
        this.kind = kind;
        this.number = number;
    }
}

클래스 이름과 16진수의 해쉬코드가 출력된 것을 확인할 수 있다. 서로 다른 인스턴스이므로 다른 해쉬코드를 가지고 있음을 알 수 있다. Card 클래스에서 toString() 메서드를 오버라이딩하여 커스텀마이징할 수 있다.

class source{
    public static void main(String[] args) {
        Card c1 = new Card();
        Card c2 = new Card();

        System.out.println(c1.toString());
        System.out.println(c2.toString());
    }
}

class Card{
    String kind;
    int number;

    Card(){
        this("SPADE", 1);
    }
    Card(String kind, int number){
        this.kind = kind;
        this.number = number;
    }
    public String toString(){
        return "kind : " + kind + ", number : " + number;
    }
}

toString 은 Object 클래스에서 public 으로 만들어졌는데, 이는 조상에 정의된 메서드를 자손에서 오버라이딩할 때 조상에 정의된 접근 범위보다 같거나 넓어야 하기 때문이며, 이에 따라 Object 클래스에서 toString() 이 public 이므로 자손 클래스에서는 toString() 을 public 으로 할 수 밖에 없는 것이다.

 

  1.1.4 clone()

  이는 자신을 복제해서 새로운 인스턴스를 제공한다. 인스턴스 변수의 값만 복사하므로 참조 타입의 인스턴스 변수가 있으면 완전한 복사가 이루어지지 않는다. 예를 들어 배열의 경우 복제된 인스턴스도 같은 배열 주소를 가지게 된다는 것인데, 이러한 경우에 대해서는 오버라이딩하여 새로운 배열을 생성하고 내용을 복사하도록 구현해주면 해결이 가능할 것이다.

class Point implements Cloneable{
    int x, y;
    Point(int x, int y){
        this.x = x;
        this.y = y;
    }
    public String toString(){
        return "x = " + x + " y = " + y;
    }
    public Object clone(){
        Object obj = null;
        try{
            obj = super.clone();
        } catch (CloneNotSupportedException e){
            // ...
        }
        return obj;
    }
}

class source{
    public static void main(String[] args) {
        Point original = new Point(3, 5);
        Point copy = (Point)original.clone();
        System.out.println(original);
        System.out.println(copy);
    }
}

clone() 을 사용하려면 복제할 클래스가 Cloneable 인터페이스를 구현해야만 하며, clone() 을 오버라이딩하면서 protected 접근 제어자를 public 으로 바꾸어 주어야만 상속관계가 없는 다른 클래스에서도 clone() 을 호출할 수 있게 된다. 

 

  1.1.5 공변 반환타입(covariant return type)

  이는 오버라이딩을 할 때 조상 메서드의 반환 타입을 자손 클래스의 타입으로 번경하는 것이다. covariant return type 을 사용하면 조상의 타입이 아니라 실제로 반환되는 자손 객체 타입으로 반환할 수 있기에 형변환을 하지 않아도 되어서 편리하다.

Point copy = (Point)original.clone(); 을 Point copy = original.clone(); 

import java.util.Arrays;

class source{
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] arrClone = arr.clone();
        arrClone[0] = 6;

        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arrClone));
    }
}

위는 clone() 을 이용하여 배열을 복사하는 예제인데, Object 클래스는 protected 로 정의된 clone() 을 이를 상속바는 배열에서는 public 으로 오버라이딩하였기 떄문에 직접 호출이 가능한 것이고 원본과 같은 타입을 반환하므로 형변환을 하지 않아도 된다. 일반적으로는 배열을 복사할 때 System.arraycopy() 를 사용해서 내용을 복사하는데 이와 같이 clone() 으로 간단히 복사할 수도 있다. 배열 외에도 java.util package 의 Vector, ArrayList, LinkedList, HashSet, TreeSet, HashMap, TreeMap, Calendar, Date 와 같은 클래스도 clone() 으로 복제가 가능한데, clone() 으로 복제가 가능한 클래스인지 확인하기 위해서는 JAVA API 에서 Cloneable 을 구현하였는지 확인하면 된다.

 

  1.1.6 얕은 복사와 깊은 복사

   clone() 으로 객체를 복사하면 단순히 객체에 저장된 값을 복사하는 것이고 참조하는 객체까지 복제하지 않는다. (Shallow copy()) 이러한 경우에는 원본을 변경할 시 복사본 또한 영향을 받게 된다. 반면에 원본이 참조하고 있는 객체 자체를 복사하는 Deep copy 의 경우에는 원본과 복사본이 서로 다른 객체를 참조하므로 서로 영향을 미치지 않게 된다.

class Circle implements Cloneable{
    Point p;
    double r;

    Circle(Point p, double r){
        this.p = p;
        this.r = r;
    }
    public Circle shallowCopy(){
        Object obj = null;
        try{
            obj = super.clone();
        } catch(CloneNotSupportedException e){ }
        return (Circle)obj;
    }

    public Circle deepCopy(){
        Object obj = null;
        try{
            obj = super.clone();
        } catch (CloneNotSupportedException e){ }
        Circle c = (Circle)obj;
        c.p = new Point(this.p.x, this.p.y);
        return c;
    }
    public String toString() {
        return "[p = " + p + ", r = " + r + "]";
    }
}

class Point{
    int x,y;
    Point(int x, int y){
        this.x = x;
        this.y = y;
    }
    public String toString(){
        return "(" + x + ", " + y + ")";
    }
}
class source{
    public static void main(String[] args) {
        Circle c1 = new Circle(new Point(1, 1), 2.0);
        Circle c2 = c1.shallowCopy();
        Circle c3 = c1.deepCopy();

        System.out.println("c1 = " + c1);
        System.out.println("c2 = " + c2);
        System.out.println("c3 = " + c3);

        c1.p.x = 9;
        c1.p.y = 9;

        System.out.println("===============");
        System.out.println("c1 = " + c1);
        System.out.println("c2 = " + c2);
        System.out.println("c3 = " + c3);

    }
}

c2 는 c1 에 대하여 shallow copy 로 생성한 객체이므로 c1 의 변경에 대한 영향을 받고, c3 는 c1 에 대하여 deep copy 로 생성한 객체이므로 c1 의 변경에 대한 영향을 받지 않는 독립적인 객체임을 알 수 있다. 

 

 

  1.1.7 getClass()

    자기 자신이 속한 Class 객체를 반환한다. Class 객체는 이름이 Class 인 클래스의 객체으로 아래와 같이 정의되어 있다.

public final class Class implements ... { ... }

이 Class 객체는 클래스의 모든 정보를 담고 있으며 클래스 당 하나만 존재하고 ClassLoader 에 의해 메모리에 클래스 파일이 올라가게 될 때 자동으로 생성된다. ClassLoader 는 실행 시 필요한 클래스를 메모리에 동적으로 올리는 역할을 한다. 생성된 클래스 객체가 메모리에 있는지 확인하고, 있으면 객체의 참조를 반환, 없으면 classpath 에 따라서 클래스 파일을 서치한다. 이때 클래스 파일을 찾지 못하는 경우에는 ClassNotFoundException 이 발생한다.

 

  1.1.8 Class 객체를 얻는 방법

   클래스 정보를 얻으려면 Class 객체에 대한 참조를 먼저 얻어와야 한다.

 

Class cObj = new Card().getClass();

// 생성된 객체로 부터 얻는 방법

Class cObj = Card.class;

// 클래스 리터럴(*.class)으로 부터 얻는 방법

Class cObj = Class.forName("Card");

// 클래스 이름으로부터 얻는 방법

 

 forName() 은 특정 클래스 파일을 메모리에 올릴 때 주로 사용한다. Class 객체를 이용해서 클래스에 대한 모든 정보를 얻을 수 있으므로 Class 객체를 통해 객체를 생성하고 메서드를 호출하는 등 보다 동적인 코드 작성이 가능해진다.

 

  1.2 String Class

  자바에서는 문자열을 String 클래스를 이용해서 다룬다.

 

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

   String 클래스에서는 문자열을 저장하기 위한 문자형 배열 참조변수 value 를 인스턴스 변수로 정의하였다. 

 

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

 

일단 생성된 String 인스턴스의 value 는 read only 이며 변경할 수 없다. 예를 들어 String 객체 2개를 + 연산자를 이용하여 문자열을 결합하는 경우, 인스턴스 내의 문자열이 바뀌는 것이 아닌 새로운 문자열이 담긴 String 인스턴스가 생성되는 원리인데, 이 떄문에 예상치 못하게 메모리 공간을 차지하게 되므로 결합횟수를 최대한 줄이는 것이 효율적이다. 문자열 간 결합, 추출과 같이 문자열을 자주 다루어야 할 경우에는 String 클래스 외에 StringBuffer 클래스를 사용하는 것이 좋은데, StringBuffer 클래스는 문자열 변경이 가능해서 하나의 인스턴스 만으로도 문자열을 충분히 다룰 수 있다.

 

  1.2.2 문자열의 비교

   문자열을 만드는 것은 문자열 리터럴을 지정하는 것과 String 클래스의 생성자를 이용하는 방법이 있다. 

 

String str1 = "abc"; // 문자열 리터럴 "abc" 의 주소가 str1 에 저장됨.

String str2 = new String("abc"); // 새로운 String 인스턴스를 생성함.

 

생성자를 이용하는 경우 new operator 에 의해 메모리 할당이 이루어져서 새로운 String 인스턴스가 생성되는 것이고, 문자열 리터럴은 이미 존재하는 것을 재사용하는 것이다. 

class source{
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        System.out.println("String str1 = \"abc\";");
        System.out.println("String str2 = \"abc\";");

        System.out.println("str1 == str2 ? " + (str1 == str2));
        System.out.println("str1.equals(str2) ? " + str1.equals(str2));

        String str3 = new String("\"abc\"");
        String str4 = new String("\"abc\"");

        System.out.println("str3 == str4 ? " + (str3 == str4));
        System.out.println("str3.equals(str4) ? " + str3.equals(str4));
    }
}

String 클래스에서 오버라이딩 된 equals 메서드를 이용하여 비교한 경우 문자열에 저장된 내용을 비교하므로 모두 true 를 얻을 수 있지만, == 를 이용하여 비교했을 대에는 String 인스턴스의 경우 주소를 비교하므로 결과가 false 로 나오는 것이다.

 

  1.2.3 문자열 리터럴

   소스 파일 내의 모든 문자열 리터럴은 컴파일 할 때 클래스 파일에 저장되는데, 같은 내용의 문자열은 단 한번만 저장된다. 문자열 리터럴도 String 인스턴스이고 생성되면 변경할 수 없기 때문에 하나의 인스턴스를 공유하면 되기 때문이다. 클래스 파일에는 모든 리터럴 목록들이 있는데, 클래스 파일이 클래스 로더에 의해 메모리에 올라가게 되면 해당 리터럴들이 JVM 내의 Constant pool 에 저장된다.

 

  1.2.4 빈 문자열(empty string)

    길이가 0 인 문자열을 말하며, C 에서는 문자열의 끝에 null 문자가 붙지만 자바에서는 그렇지 않는다. 대신 문자열의 길이 정보를 따로 저장한다.

 

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

  https://docs.oracle.com/javase/7/docs/api/java/lang/String.html

String (Java Platform SE 7 )

 

  1.2.6 join() 과 StringJoiner

    join() 은 여러 문자열 사이사이에 구분자를 넣어 결합하는 split() 과 반대의 작업을 한다. java.util.StringJoiner 클래스를 이용하는 방법도 있다.

import java.util.StringJoiner;

class source{
    public static void main(String[] args) {
        String animals = "dog,cat,bear";
        String[] arr = animals.split(",");

        System.out.println(String.join("-", arr));

        StringJoiner sj = new StringJoiner("/", "[", "]");
        for(String s : arr)
            sj.add(s);
        System.out.println(sj.toString());
    }
}

  1.2.7 유니코드의 보충문자

    String 클래스의 메서드를 보면 매개변수 타입이 int 인 것도 존재하는데, 이는 확장된 유니코드를 다루기 위함이다.  유니코드는 16bit(2byte) 문자 체계였는데, 현재 20bit 로 확장되었다. 그러므로 하나의 문자를 char 으로 다루지 못하고 int 로 다루게 된 것인데, 확장에 의해 새롭게 추가된 문자들을 supplementary characters 라고 한다. String 메서드의 매개변수가 int 인 경우에는 보통 supplementary characters 을 지원하고, char 인 경우에는 그렇지 않는다는 정도만 기억해두자.

 

  1.2.8 문자 인코딩 변환

    getBytes(String charsetName) 을 사용하면 문자열의 인코딩을 변환할 수 있다. Java 에서는 UTF-16 을 사용하는데 문자열 리터럴에 포함되는 문자들은 OS 인코딩을 사용한다. 한글의 경우 CP949 를 사용하고 UTF-8 로 변경하기 위해서는 아래와 같이 해주면 된다.

 

byte[] utf8_str = "가".getBytes("UTF-8");

String str = new String(utf8_str, "UTF_8");

 

서로 다른 문자 인코딩을 사용하는데 데이터를 주고받기 위해서는 인코딩을 잘 해주지 않으면, 글자가 깨지게 된다.

 

  1.2.9 String.format()

    format() 은 formating 된 문자열을 만드는 메서드로, printf() 와 사용법이 동일하다.

 

  1.2.10 기본형 값을 String 으로 변환

    기본형을 문자열로 바꾸기 위해서는 빈 문자열을 더함으로써 간단히 구현할 수 있다. 이는 참조 변수가 가리키는 인스턴스의 toString() 을 호출하게 하며, 이로부터 String 으로 변환되어 반환하는 것이다. 이 방법 외에 valueOf() 를 사용하는 방법도 있는데, 빈 문자열을 더하는 것 보다 성능이 좋다. 

 

int i = 100;

String str1 = i + "";

String str2 = String.valueOf(i);

 

 

  1.2.11 String 을 기본형 값으로 변환

   그렇다면 String 을 기본형으로 변환하기 위해서는 어떻게 할까? 이는 valueOf() 를 이용하거나 parseInt() 를 사용하면 된다.

 

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

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

 

사실 valueOf() 의 반환 타입은 int 가 아닌 integer 인데, 이는 auto-boxing 에 의해 자동 변환된 것이다. parseInt() 메서드는 valueOf() 와 반환 타입만 다르지 같다.

 

public static Integer valueOf(String s) throws NumberFormatException{

return Integer.valueOf(parseInt(s, 10));

}

 

class source{
    public static void main(String[] args) {
        int iVal = 100;
        String strVal = String.valueOf(iVal);

        double dVal = 200.0;
        String strVal2 = dVal + "";

        double sum = Integer.parseInt("+" + strVal) + Double.parseDouble(strVal2);
        double sum2 = Integer.valueOf(strVal) + Double.valueOf(strVal2);

        System.out.println(String.join("", strVal, "+", strVal2, "=") + sum);
        System.out.println(strVal+"+"+strVal2+"="+sum2);

    }
}

parseInt() 와 parseFloat() 같은 메서드는 문자열에 공백 혹은 문자가 있는 경우에 NumberFormatException 을 발생시키므로, 습관적으로 trim() 을 사용하여 양끝의 공백을 제거하여 formating 하는 것이 좋다. 유의해야 할 것은 부호를 의미하는 '+' 나 소수점을 의미하는 '.' 그리고 float 형 값을 의미하는 f 와 같은 자료형 접미사는 허용된다. 

 

class source{
    public static void main(String[] args) {
        String fullName = "Hello.java";
        int index = fullName.indexOf('.');
        String fileName = fullName.substring(0, index);
        // fullName.substring(index+1, fullName.length());
        String ext = fullName.substring(index+1);

        System.out.println("name : " + fileName);
        System.out.println("ext : " + ext);
    }
}

 

  1.3 StringBuffer 클래스와 String Builder 클래스

    StringBuffer 는 내부에 문자열을 편집할 수 있는 buffer 가 있어서 생성 시 지정된 문자열을 변경할 수 있다. StringBuffer 을 생성할 때, 버퍼의 길이를 지정할 수 있는데 너무 작게 하면 버퍼의 길이를 늘려주는 작업이 더 자주 발생할 수 있으므로 효율성이 떨어짐에 유의해야한다. 

 

public final class StringBuffer implements java.io.Serializable {

private char[] value;

// ...

}

 

  1.3.1 StringBuffer 의 생성자

  StringBuffer 을 생성할 때, 길이를 여유 있게 지정해야 한다. 만약 별도로 버퍼의 크기를 지정해주지 않으면 16개의 문자를 저장할 수 있는 크기의 버퍼를 생성한다.

 

public StringBuffer(int length){

value = new char[length];

shared = false;

}

public StringBuffer() {

this(16);

}

public StringBuffer(String str) {

this(str.length() + 16);

append(str);

}

 

  1.3.2 StringBuffer 의 변경

    StringBuffe 는 String 과는 달리 내용을 변경할 수 있다. StringBuffer sb = new StringBuffer("abc"); 로 StringBuffer 을 생성하였다고 가정해보자. 그리고 sb.append("aa"); 를 수행한다면 sb 의 내용 뒤에 "aa" 가 추가되는데, 기존에 가지고 있던 자신의 주소를 반환한다. 그래서 sb.append("aa").append("cc"); 와 같이도 할 수 있다.

 

  1.3.3 StringBuffer 의 비교

   StringBuffer 클래스에서는 equals 메서드를 별도로 오버라이딩 하지 않아서, String 클래스에서 == 등가 비교 연산자를 사용한 것과 같은 결과가 나타난다. 그래서 원활하게 비교하기 위해서는 toString() 을 호출한 다음에 equals() 메서드를 사용하는 것이 좋다.

 

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

https://www.geeksforgeeks.org/stringbuffer-class-in-java/

StringBuffer class in Java - GeeksforGeeks

 

  1.3.5 StringBuilder 란?

   StringBuffer 는 멀티쓰레드에 안전하도록 동기화되어있는데, 이는 StringBuffer 의 성능을 떨어뜨리는 요인이 된다. 멀티 쓰레딩이 필요없는 프로그램의 경우 StringBuffer 는 불필요한 동기화로 인해 성능이 저하된다. 그래서 쓰레드를 동기화하는 기능만 제외한 StringBuilder 가 추가된 것으로, StringBuffer 와 완전히 동일하다.

 

  1.4 래퍼(wrapper) 클래스

    OOP 에서는 모든 것은 다 Object 로 다루어져야 하지만 자바에서는 8개의 기본형을 Object 로 다루지 않는 대신 높은 성능을 얻었다. (완전한 객체지향 언어가 아니라는 것이다.) 하지만 기본형 변수 또한 객체로 다루어야 하는 경우가 발생하며 이때 사용하는 것이 wrapper class 이다. 

 

public final class Integer extends Number implements Comparable { 

...

private int value;

...

}

 

  wrapper Class 는 모두 equals() 메서드가 오버라이딩 되어 있어 편리하다. 오토박싱이 된다고 할 지라도 Integer 객체에 비교 연산자를 사용할 수 없는데, 이러한 경우에는 compareTo() 를 사용하면 된다. 또한 toString() 도 오버라이딩되어서 객체가 가지고 있는 값을 문자열으로 변환하여 반환한다.

 

  1.5 오토박싱 & 언박싱 (autoboxing & unboxing)

   JDK1.5 이전에서는 기본형과 참조형의 연산이 불가능하여 wrapper 클래스로 기본형을 객체로 만든 다음 연산을 했어야만 했다. 하지만 현재는 가능하며, 컴파일러에 의해 기본형 값을 wrapper class 의 객체로 자동으로 변환해주는 것을 autoboxing 이라고 하고, 반대의 작업은 unboxing 이라고 한다.

---

References

http://www.yes24.com/Product/Goods/24259565

Java의 정석 - YES24