/* * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.util; /** * 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!");    }     /**     * 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));    }    /**    * 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);    }     /**     * 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;    }    /**    * 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[])}.    *    * <p>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:    *    * <blockquote><pre>    * &#064;Override public int hashCode() {    *     return Objects.hash(x, y, z);    * }    * </pre></blockquote>    *    * <b>Warning: When a single object reference is supplied, the returned    * value does not equal the hash code of that object reference.</b> 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);    }     /**     * 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);    }     /**     * 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;    }     /**     * Returns 0 if the arguments are identical and {@code     * c.compare(a, b)} otherwise.     * Consequently, if both arguments are {@code null} 0     * is returned.     *     * <p>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 <T> 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 <T> int compare(T a, T b, Comparator<? super T> c) {        return (a == b) ? 0 :  c.compare(a, b);    }     /**     * 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:     * <blockquote><pre>     * public Foo(Bar bar) {     *     this.bar = Objects.requireNonNull(bar);     * }     * </pre></blockquote>     *     * @param obj the object reference to check for nullity     * @param <T> the type of the reference     * @return {@code obj} if not {@code null}     * @throws NullPointerException if {@code obj} is {@code null}     */    public static <T> T requireNonNull(T obj) {        if (obj == null)            throw new NullPointerException();        return obj;    }     /**     * 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:     * <blockquote><pre>     * 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");     * }     * </pre></blockquote>     *     * @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 <T> the type of the reference     * @return {@code obj} if not {@code null}     * @throws NullPointerException if {@code obj} is {@code null}     */    public static <T> T requireNonNull(T obj, String message) {        if (obj == null)            throw new NullPointerException(message);        return obj;    }}