java.util.Objects 소스 판독

소개:

Objects는 jdk에서 1.7가지 새로운 도구 클래스, 이 클래스는 실용적인 정적 방법으로 구성되어 있으며 이런 방법은 우리가 평소에 개발하는 데 편리할 수 있다. 예를 들어 대상 비교, 대상을 얻는hash코드 등이다.

원본 코드 판독:

1. 유형 및 구조 방법

/**
 * This class consists of {@code static} utility methods for operating
 * on objects.  These utilities include {@code null}-safe or {@code
 * null}-tolerant methods for computing the hash code of an object,
 * returning a string for an object, and comparing two objects.
 *
 * @since 1.7
 */
public final class Objects {
    private Objects() {
        throw new AssertionError("No java.util.Objects instances for you!");
    }
    
    ...
    
}

이런 종류는final에 의해 수식된 것이다. 즉, 자류가 있을 수 없고 구조 방법은private에 의해 수식된 것이다. 이것은 이런 종류가 실례화되면 안 된다는 것을 설명한다(이 종류의 방법은 모두 정적 방법이기 때문에 당연히 실례화할 필요가 없다).

2.equals(Object a, Object b)

    /**
     * Returns {@code true} if the arguments are equal to each other
     * and {@code false} otherwise.
     * Consequently, if both arguments are {@code null}, {@code true}
     * is returned and if exactly one argument is {@code null}, {@code
     * false} is returned.  Otherwise, equality is determined by using
     * the {@link Object#equals equals} method of the first
     * argument.
     *
     * @param a an object
     * @param b an object to be compared with {@code a} for equality
     * @return {@code true} if the arguments are equal to each other
     * and {@code false} otherwise
     * @see Object#equals(Object)
     */
    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

이 방법은 두 대상이 같은지 비교하는 데 사용됩니다. 만약 같은true로 되돌아오지 않으면false로 되돌아갑니다.비교를 할 때 먼저 a와 b가 같은 대상인지 아닌지를 판단하거나 두 대상이 모두null(a==b)이라고 판단한다. 만약에true로 돌아가면 이 판단에 주의한다. a==b는 두 가지 상황을 포함한다. 상황1:a와 b는 같은 대상(대상 인용 주소가 동일), 상황2:a와 b는 모두null(a와 b가 모두null일 때 a=b)이다.a가null이 되지 않을 때 a의 equals 방법을 사용하여 비교한 다음에 비교 결과를 되돌려줍니다.

3.deepEquals(Object a, Object b)

   /**
    * Returns {@code true} if the arguments are deeply equal to each other
    * and {@code false} otherwise.
    *
    * Two {@code null} values are deeply equal.  If both arguments are
    * arrays, the algorithm in {@link Arrays#deepEquals(Object[],
    * Object[]) Arrays.deepEquals} is used to determine equality.
    * Otherwise, equality is determined by using the {@link
    * Object#equals equals} method of the first argument.
    *
    * @param a an object
    * @param b an object to be compared with {@code a} for deep equality
    * @return {@code true} if the arguments are deeply equal to each other
    * and {@code false} otherwise
    * @see Arrays#deepEquals(Object[], Object[])
    * @see Objects#equals(Object, Object)
    */
    public static boolean deepEquals(Object a, Object b) {
        if (a == b)
            return true;
        else if (a == null || b == null)
            return false;
        else
            return Arrays.deepEquals0(a, b);
    }

이 방법은 두 대상이'진짜(deeply)'가 같은지 아닌지를 판단하는데 이'진짜'를 어떻게 이해합니까?이렇게 말하자면 equals 방법은 두 대상이 같은지 아닌지를 판단하는 것이지만 내부 원소가 같은 두 개의 서로 다른 수조라면 equals 방법을 통해 판단할 수 없다. 아래의 예를 보자.

    @Test
    public void test1(){
        int[] ary1 = {1,2,3};
        int[] ary2 = {1,2,3};

        boolean res1 = Objects.equals(ary1,ary2);
        boolean res2 = Objects.deepEquals(ary1,ary2);

        System.out.println("res1:" + res1);
        System.out.println("res2:" + res2);
    }

결과 출력:

res1:false
res2:true

이를 통해 알 수 있듯이 수조ary1과ary2 두 수조 내부 요소는 모두 같지만 equals 방법을 통해 판단한 결과는false이다. 그 원인은 바로 equals 방법의 한계성이 결정한 것이다(방법2에서 설명했다).그러나 deepEquals 방법을 통해 정확한 판단 결과를 얻었다. 이것은 deepEquals 방법이 파라미터가 수조로 된 상황을 판단했기 때문이다. 이 판단은 Arrays의 deepEquals0 방법을 호출하여 판단한 것이고 이 deepEquals0 방법은 원소가 수조로 된 상황을 판단했다.
따라서 이'진짜(deeply)'는 이렇게 이해할 수 있다. 원소를 대상으로 할 때 이 두 대상이 같은지 아닌지를 판단하고 원소를 대상으로 수조를 할 때 수조 내부 원소가 일일이 같은지 판단하고 최종 판단 결과를 되돌려준다.

4.hashCode(Object o)

    /**
     * Returns the hash code of a non-{@code null} argument and 0 for
     * a {@code null} argument.
     *
     * @param o an object
     * @return the hash code of a non-{@code null} argument and 0 for
     * a {@code null} argument
     * @see Object#hashCode
     */
    public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }

이 방법은 대상의hash코드를 되돌려줍니다. 파라미터가null이면 0을 되돌려줍니다.

5.hash(Object... values)

   /**
    * Generates a hash code for a sequence of input values. The hash
    * code is generated as if all the input values were placed into an
    * array, and that array were hashed by calling {@link
    * Arrays#hashCode(Object[])}.
    *
    * 
This method is useful for implementing {@link
    * Object#hashCode()} on objects containing multiple fields. For
    * example, if an object that has three fields, {@code x}, {@code
    * y}, and {@code z}, one could write:
    *
    * 

    * @Override public int hashCode() {
    *     return Objects.hash(x, y, z);
    * }
    * 
*
* Warning: When a single object reference is supplied, the returned
* value does not equal the hash code of that object reference. This
* value can be computed by calling {@link #hashCode(Object)}.
*
* @param values the values to be hashed
* @return a hash value of the sequence of input values
* @see Arrays#hashCode(Object[])
* @see List#hashCode
*/
public static int hash(Object... values) {
return Arrays.hashCode(values);
} 
이 방법은 여러 대상의hash코드를 되돌려줍니다.hashCode 방법을 덮어쓸 때 여러 개의 파라미터가 있는hash코드를 생성해야 할 경우 이 방법을 호출할 수 있습니다.주의해야 할 것은 매개 변수가 하나만 있다면, 이 방법을 호출하는 것과hashCode 방법을 호출해서 생성한hash코드는 같지 않습니다.
6.toString(Object o)
  
    /**
     * Returns the result of calling {@code toString} for a non-{@code
     * null} argument and {@code "null"} for a {@code null} argument.
     *
     * @param o an object
     * @return the result of calling {@code toString} for a non-{@code
     * null} argument and {@code "null"} for a {@code null} argument
     * @see Object#toString
     * @see String#valueOf(Object)
     */
    public static String toString(Object o) {
        return String.valueOf(o);
    }
  
이 방법은 대상을 String 문자열로 바꾸고 되돌려줍니다. (내부적으로 String을 호출하는value Of 방법) 대상이 null이면 'null' 을 되돌려줍니다.
7.toString(Object o, String nullDefault)
  
    /**
     * Returns the result of calling {@code toString} on the first
     * argument if the first argument is not {@code null} and returns
     * the second argument otherwise.
     *
     * @param o an object
     * @param nullDefault string to return if the first argument is
     *        {@code null}
     * @return the result of calling {@code toString} on the first
     * argument if it is not {@code null} and the second argument
     * otherwise.
     * @see Objects#toString(Object)
     */
    public static String toString(Object o, String nullDefault) {
        return (o != null) ? o.toString() : nullDefault;
    }
  
이 방법은 equals와 같지만, 매개 변수가null일 때 되돌아오는 매개 변수는 사용자 정의할 수 있습니다.
8.compare(T a, T b, Comparator super T> c)
  
    /**
     * Returns 0 if the arguments are identical and {@code
     * c.compare(a, b)} otherwise.
     * Consequently, if both arguments are {@code null} 0
     * is returned.
     *
     * 
Note that if one of the arguments is {@code null}, a {@code
     * NullPointerException} may or may not be thrown depending on
     * what ordering policy, if any, the {@link Comparator Comparator}
     * chooses to have for {@code null} values.
     *
     * @param  the type of the objects being compared
     * @param a an object
     * @param b an object to be compared with {@code a}
     * @param c the {@code Comparator} to compare the first two arguments
     * @return 0 if the arguments are identical and {@code
     * c.compare(a, b)} otherwise.
     * @see Comparable
     * @see Comparator
     */
    public static  int compare(T a, T b, Comparator super T> c) {
        return (a == b) ? 0 :  c.compare(a, b);
    }
  
두 대상의 비교 결과를 되돌려줍니다. 만약 두 대상이 완전히 같다면 0을 되돌려줍니다. 그렇지 않으면 전송된 비교기(Comparator)를 호출하여 비교하고 비교 결과를 되돌려줍니다.
9.requireNonNull(T obj)
  
    /**
     * Checks that the specified object reference is not {@code null}. This
     * method is designed primarily for doing parameter validation in methods
     * and constructors, as demonstrated below:
     * 

     * public Foo(Bar bar) {
     *     this.bar = Objects.requireNonNull(bar);
     * }
     * 
*
* @param obj the object reference to check for nullity
* @param  the type of the reference
* @return {@code obj} if not {@code null}
* @throws NullPointerException if {@code obj} is {@code null}
*/
public static  T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
} 
이 방법은 객체가 null인지 여부를 판단합니다. null일 때 NullPointer Exception을 던지거나 그렇지 않으면 객체를 반환합니다.
10.requireNonNull(T obj, String message)
  
    /**
     * Checks that the specified object reference is not {@code null} and
     * throws a customized {@link NullPointerException} if it is. This method
     * is designed primarily for doing parameter validation in methods and
     * constructors with multiple parameters, as demonstrated below:
     * 

     * public Foo(Bar bar, Baz baz) {
     *     this.bar = Objects.requireNonNull(bar, "bar must not be null");
     *     this.baz = Objects.requireNonNull(baz, "baz must not be null");
     * }
     * 
*
* @param obj     the object reference to check for nullity
* @param message detail message to be used in the event that a {@code
*                NullPointerException} is thrown
* @param  the type of the reference
* @return {@code obj} if not {@code null}
* @throws NullPointerException if {@code obj} is {@code null}
*/
public static  T requireNonNull(T obj, String message) {
if (obj == null)
throw new NullPointerException(message);
return obj;
} 
이 메서드는 9과 같습니다. NullPointer Exception 을 던질 때 사용자 정의 문자열을 입력할 수 있습니다.
11.isNull(Object obj)
  
    /**
     * Returns {@code true} if the provided reference is {@code null} otherwise
     * returns {@code false}.
     *
     * @apiNote This method exists to be used as a
     * {@link java.util.function.Predicate}, {@code filter(Objects::isNull)}
     *
     * @param obj a reference to be checked against {@code null}
     * @return {@code true} if the provided reference is {@code null} otherwise
     * {@code false}
     *
     * @see java.util.function.Predicate
     * @since 1.8
     */
    public static boolean isNull(Object obj) {
        return obj == null;
    }
  
대상 ==null의 결과를 되돌려줍니다.
12.nonNull(Object obj)
  
    /**
     * Returns {@code true} if the provided reference is non-{@code null}
     * otherwise returns {@code false}.
     *
     * @apiNote This method exists to be used as a
     * {@link java.util.function.Predicate}, {@code filter(Objects::nonNull)}
     *
     * @param obj a reference to be checked against {@code null}
     * @return {@code true} if the provided reference is non-{@code null}
     * otherwise {@code false}
     *
     * @see java.util.function.Predicate
     * @since 1.8
     */
    public static boolean nonNull(Object obj) {
        return obj != null;
    }
  
객체 반환!=null의 결과입니다.
13.requireNonNull(T obj, Supplier messageSupplier)
  
    /**
     * Checks that the specified object reference is not {@code null} and
     * throws a customized {@link NullPointerException} if it is.
     *
     * 
Unlike the method {@link #requireNonNull(Object, String)},
     * this method allows creation of the message to be deferred until
     * after the null check is made. While this may confer a
     * performance advantage in the non-null case, when deciding to
     * call this method care should be taken that the costs of
     * creating the message supplier are less than the cost of just
     * creating the string message directly.
     *
     * @param obj     the object reference to check for nullity
     * @param messageSupplier supplier of the detail message to be
     * used in the event that a {@code NullPointerException} is thrown
     * @param  the type of the reference
     * @return {@code obj} if not {@code null}
     * @throws NullPointerException if {@code obj} is {@code null}
     * @since 1.8
     */
    public static  T requireNonNull(T obj, Supplier messageSupplier) {
        if (obj == null)
            throw new NullPointerException(messageSupplier.get());
        return obj;
    }
  
이 방법은 들어오는 매개 변수를 판단하고 들어오는 매개 변수가null일 때 NullPointer Exception을 던지고 사용자 정의 문자열을 전송합니다. (이 방법은 결과를 가져오는 클래스 Supplier를 통해 문자열을 제공합니다.)