jdk/src/java.base/share/classes/java/lang/annotation/Annotation.java
changeset 32033 bf24e33c7919
parent 25859 3317bb8137f4
equal deleted inserted replaced
32032:22badc53802f 32033:bf24e33c7919
    48      * returns true if the specified object is an instance of the same
    48      * returns true if the specified object is an instance of the same
    49      * annotation type as this instance, all of whose members are equal
    49      * annotation type as this instance, all of whose members are equal
    50      * to the corresponding member of this annotation, as defined below:
    50      * to the corresponding member of this annotation, as defined below:
    51      * <ul>
    51      * <ul>
    52      *    <li>Two corresponding primitive typed members whose values are
    52      *    <li>Two corresponding primitive typed members whose values are
    53      *    <tt>x</tt> and <tt>y</tt> are considered equal if <tt>x == y</tt>,
    53      *    {@code x} and {@code y} are considered equal if {@code x == y},
    54      *    unless their type is <tt>float</tt> or <tt>double</tt>.
    54      *    unless their type is {@code float} or {@code double}.
    55      *
    55      *
    56      *    <li>Two corresponding <tt>float</tt> members whose values
    56      *    <li>Two corresponding {@code float} members whose values
    57      *    are <tt>x</tt> and <tt>y</tt> are considered equal if
    57      *    are {@code x} and {@code y} are considered equal if
    58      *    <tt>Float.valueOf(x).equals(Float.valueOf(y))</tt>.
    58      *    {@code Float.valueOf(x).equals(Float.valueOf(y))}.
    59      *    (Unlike the <tt>==</tt> operator, NaN is considered equal
    59      *    (Unlike the {@code ==} operator, NaN is considered equal
    60      *    to itself, and <tt>0.0f</tt> unequal to <tt>-0.0f</tt>.)
    60      *    to itself, and {@code 0.0f} unequal to {@code -0.0f}.)
    61      *
    61      *
    62      *    <li>Two corresponding <tt>double</tt> members whose values
    62      *    <li>Two corresponding {@code double} members whose values
    63      *    are <tt>x</tt> and <tt>y</tt> are considered equal if
    63      *    are {@code x} and {@code y} are considered equal if
    64      *    <tt>Double.valueOf(x).equals(Double.valueOf(y))</tt>.
    64      *    {@code Double.valueOf(x).equals(Double.valueOf(y))}.
    65      *    (Unlike the <tt>==</tt> operator, NaN is considered equal
    65      *    (Unlike the {@code ==} operator, NaN is considered equal
    66      *    to itself, and <tt>0.0</tt> unequal to <tt>-0.0</tt>.)
    66      *    to itself, and {@code 0.0} unequal to {@code -0.0}.)
    67      *
    67      *
    68      *    <li>Two corresponding <tt>String</tt>, <tt>Class</tt>, enum, or
    68      *    <li>Two corresponding {@code String}, {@code Class}, enum, or
    69      *    annotation typed members whose values are <tt>x</tt> and <tt>y</tt>
    69      *    annotation typed members whose values are {@code x} and {@code y}
    70      *    are considered equal if <tt>x.equals(y)</tt>.  (Note that this
    70      *    are considered equal if {@code x.equals(y)}.  (Note that this
    71      *    definition is recursive for annotation typed members.)
    71      *    definition is recursive for annotation typed members.)
    72      *
    72      *
    73      *    <li>Two corresponding array typed members <tt>x</tt> and <tt>y</tt>
    73      *    <li>Two corresponding array typed members {@code x} and {@code y}
    74      *    are considered equal if <tt>Arrays.equals(x, y)</tt>, for the
    74      *    are considered equal if {@code Arrays.equals(x, y)}, for the
    75      *    appropriate overloading of {@link java.util.Arrays#equals}.
    75      *    appropriate overloading of {@link java.util.Arrays#equals}.
    76      * </ul>
    76      * </ul>
    77      *
    77      *
    78      * @return true if the specified object represents an annotation
    78      * @return true if the specified object represents an annotation
    79      *     that is logically equivalent to this one, otherwise false
    79      *     that is logically equivalent to this one, otherwise false
    91      * of the member-name as computed by {@link String#hashCode()}) XOR
    91      * of the member-name as computed by {@link String#hashCode()}) XOR
    92      * the hash code of the member-value, as defined below:
    92      * the hash code of the member-value, as defined below:
    93      *
    93      *
    94      * <p>The hash code of a member-value depends on its type:
    94      * <p>The hash code of a member-value depends on its type:
    95      * <ul>
    95      * <ul>
    96      * <li>The hash code of a primitive value <tt><i>v</i></tt> is equal to
    96      * <li>The hash code of a primitive value <i>{@code v}</i> is equal to
    97      *     <tt><i>WrapperType</i>.valueOf(<i>v</i>).hashCode()</tt>, where
    97      *     <code><i>WrapperType</i>.valueOf(<i>v</i>).hashCode()</code>, where
    98      *     <tt><i>WrapperType</i></tt> is the wrapper type corresponding
    98      *     <i>{@code WrapperType}</i> is the wrapper type corresponding
    99      *     to the primitive type of <tt><i>v</i></tt> ({@link Byte},
    99      *     to the primitive type of <i>{@code v}</i> ({@link Byte},
   100      *     {@link Character}, {@link Double}, {@link Float}, {@link Integer},
   100      *     {@link Character}, {@link Double}, {@link Float}, {@link Integer},
   101      *     {@link Long}, {@link Short}, or {@link Boolean}).
   101      *     {@link Long}, {@link Short}, or {@link Boolean}).
   102      *
   102      *
   103      * <li>The hash code of a string, enum, class, or annotation member-value
   103      * <li>The hash code of a string, enum, class, or annotation member-value
   104      I     <tt><i>v</i></tt> is computed as by calling
   104      I     <i>{@code v}</i> is computed as by calling
   105      *     <tt><i>v</i>.hashCode()</tt>.  (In the case of annotation
   105      *     <code><i>v</i>.hashCode()</code>.  (In the case of annotation
   106      *     member values, this is a recursive definition.)
   106      *     member values, this is a recursive definition.)
   107      *
   107      *
   108      * <li>The hash code of an array member-value is computed by calling
   108      * <li>The hash code of an array member-value is computed by calling
   109      *     the appropriate overloading of
   109      *     the appropriate overloading of
   110      *     {@link java.util.Arrays#hashCode(long[]) Arrays.hashCode}
   110      *     {@link java.util.Arrays#hashCode(long[]) Arrays.hashCode}