<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">/*
 * @(#)Long.java	1.52 00/02/02
 *
 * Copyright 1994-2000 Sun Microsystems, Inc. All Rights Reserved.
 * 
 * This software is the proprietary information of Sun Microsystems, Inc.  
 * Use is subject to license terms.
 * 
 */

package java.lang;

/**
 * The Long class wraps a value of the primitive type &lt;code&gt;long&lt;/code&gt;
 * in an object. An object of type &lt;code&gt;Long&lt;/code&gt; contains a single
 * field whose type is &lt;code&gt;long&lt;/code&gt;.
 * &lt;p&gt;
 * In addition, this class provides several methods for converting a
 * &lt;code&gt;long&lt;/code&gt; to a &lt;code&gt;String&lt;/code&gt; and a
 * &lt;code&gt;String&lt;/code&gt; to a &lt;code&gt;long&lt;/code&gt;, as well as other
 * constants and methods useful when dealing with a
 * &lt;code&gt;long&lt;/code&gt;.
 *
 * @author  Lee Boynton
 * @author  Arthur van Hoff
 * @version 1.52, 02/02/00
 * @since   JDK1.0
 */
public final class Long extends Number implements Comparable {
    /**
     * The smallest value of type &lt;code&gt;long&lt;/code&gt;.
     */
    public static final long MIN_VALUE = 0x8000000000000000L;

    /**
     * The largest value of type &lt;code&gt;long&lt;/code&gt;.
     */
    public static final long MAX_VALUE = 0x7fffffffffffffffL;

    /**
     * The Class object representing the primitive type long.
     *
     * @since   JDK1.1
     */
    public static final Class	TYPE = Class.getPrimitiveClass("long");

    /**
     * Creates a string representation of the first argument in the
     * radix specified by the second argument.
     * &lt;p&gt;
     * If the radix is smaller than &lt;code&gt;Character.MIN_RADIX&lt;/code&gt; or
     * larger than &lt;code&gt;Character.MAX_RADIX&lt;/code&gt;, then the radix
     * &lt;code&gt;10&lt;/code&gt; is used instead.
     * &lt;p&gt;
     * If the first argument is negative, the first element of the 
     * result is the ASCII minus sign &lt;code&gt;'-'&lt;/code&gt; 
     * (&lt;code&gt;'&amp;#92;u002d'&lt;/code&gt;. If the first argument is not negative, 
     * no sign character appears in the result. 
     * &lt;p&gt;
     * The remaining characters of the result represent the magnitude of 
     * the first argument. If the magnitude is zero, it is represented by 
     * a single zero character &lt;code&gt;'0'&lt;/code&gt; 
     * (&lt;code&gt;'&amp;#92;u0030'&lt;/code&gt;); otherwise, the first character of the
     * representation of the magnitude will not be the zero character.
     * The following ASCII characters are used as digits: 
     * &lt;blockquote&gt;&lt;pre&gt;
     *   0123456789abcdefghijklmnopqrstuvwxyz
     * &lt;/pre&gt;&lt;/blockquote&gt;
     * These are &lt;tt&gt;'&amp;#92;u0030'&lt;/tt&gt; through &lt;tt&gt;'&amp;#92;u0039'&lt;/tt&gt; 
     * and &lt;tt&gt;'&amp;#92;u0061'&lt;/tt&gt; through &lt;tt&gt;'&amp;#92;u007a'&lt;/tt&gt;. If the 
     * radix is &lt;var&gt;N&lt;/var&gt;, then the first &lt;var&gt;N&lt;/var&gt; of these 
     * characters are used as radix-&lt;var&gt;N&lt;/var&gt; digits in the order 
     * shown. Thus, the digits for hexadecimal (radix 16) are 
     * &lt;tt&gt;0123456789abcdef&lt;/tt&gt;. If uppercase letters
     * are desired, the {@link java.lang.String#toUpperCase()} method 
     * may be called on the result: 
     * &lt;blockquote&gt;&lt;pre&gt;
     * Long.toString(n, 16).toUpperCase()
     * &lt;/pre&gt;&lt;/blockquote&gt;
     * 
     * @param   i       a long.
     * @param   radix   the radix.
     * @return  a string representation of the argument in the specified radix.
     * @see     java.lang.Character#MAX_RADIX
     * @see     java.lang.Character#MIN_RADIX
     */
    public static String toString(long i, int radix) {
        if (radix &lt; Character.MIN_RADIX || radix &gt; Character.MAX_RADIX)
	    radix = 10;

	char[] buf = new char[65];
	int charPos = 64;
	boolean negative = (i &lt; 0);

	if (!negative) {
	    i = -i;
	}

	while (i &lt;= -radix) {
	    buf[charPos--] = Integer.digits[(int)(-(i % radix))];
	    i = i / radix;
	}
	buf[charPos] = Integer.digits[(int)(-i)];

	if (negative) {
	    buf[--charPos] = '-';
	}

	return new String(buf, charPos, (65 - charPos));
    }

    /**
     * Creates a string representation of the long argument as an
     * unsigned integer in base&amp;nbsp;16.
     * &lt;p&gt;
     * The unsigned long value is the argument plus 2&lt;sup&gt;64&lt;/sup&gt; if 
     * the argument is negative; otherwise, it is equal to the argument. 
     * &lt;p&gt;
     * If the unsigned magnitude is zero, it is represented by a single 
     * zero character &lt;tt&gt;'0'&lt;/tt&gt; (&lt;tt&gt;'&amp;#92;u0030'&lt;/tt&gt;); otherwise, 
     * the first character of the representation of the unsigned magnitude 
     * will not be the zero character. The following characters are used 
     * as hexadecimal digits:
     * &lt;blockquote&gt;&lt;pre&gt;
     * 0123456789abcdef
     * &lt;/pre&gt;&lt;/blockquote&gt;
     * These are the characters &lt;tt&gt;'&amp;#92;u0030'&lt;/tt&gt; through 
     * &lt;tt&gt;'&amp;#92;u0039'&lt;/tt&gt; and '&amp;#92;u0061' through &lt;tt&gt;'&amp;#92;u0066'&lt;/tt&gt;. 
     * If uppercase letters are desired, the 
     * {@link java.lang.String#toUpperCase()} method may be called on 
     * the result: 
     * &lt;blockquote&gt;&lt;pre&gt;
     * Long.toHexString(n).toUpperCase()
     * &lt;/pre&gt;&lt;/blockquote&gt;
     *
     * @param   i   a &lt;code&gt;long&lt;/code&gt;.
     * @return  the string representation of the unsigned long value
     *          represented by the argument in hexadecimal (base&amp;nbsp;16).
     * @since   JDK 1.0.2
     */
    public static String toHexString(long i) {
	return toUnsignedString(i, 4);
    }

    /**
     * Creates a string representation of the long argument as an
     * unsigned integer in base&amp;nbsp;8.
     * &lt;p&gt;
     * The unsigned long value is the argument plus 2&lt;sup&gt;64&lt;/sup&gt; if 
     * the argument is negative; otherwise, it is equal to the argument. 
     * &lt;p&gt;
     * If the unsigned magnitude is zero, it is represented by a single zero
     * character &lt;tt&gt;'0'&lt;/tt&gt; (&lt;tt&gt;'&amp;#92;u0030'&lt;/tt&gt;); otherwise, the 
     * first character of the representation of the unsigned magnitude 
     * will not be the zero character. The following characters are used 
     * as octal digits:
     * &lt;blockquote&gt;&lt;pre&gt;
     * 01234567
     * &lt;/pre&gt;&lt;/blockquote&gt;
     * These are the characters &lt;tt&gt;'&amp;#92;u0030'&lt;/tt&gt; through 
     * &lt;tt&gt;'&amp;#92;u0037'&lt;/tt&gt;. 
     *
     * @param   i   a &lt;code&gt;long&lt;/code&gt;.
     * @return  the string representation of the unsigned long value
     *          represented by the argument in octal (base&amp;nbsp;8).
     * @since   JDK 1.0.2
     */
    public static String toOctalString(long i) {
	return toUnsignedString(i, 3);
    }

    /**
     * Creates a string representation of the long argument as an
     * unsigned integer in base&amp;nbsp;2.
     * &lt;p&gt;
     * The unsigned long value is the argument plus 2&lt;sup&gt;64&lt;/sup&gt; if 
     * the argument is negative; otherwise, it is equal to the argument. 
     * &lt;p&gt;
     * If the unsigned magnitude is zero, it is represented by a single zero
     * character &lt;tt&gt;'0'&lt;/tt&gt; (&lt;tt&gt;'&amp;392;u0030'&lt;/tt&gt;); otherwise, the 
     * first character of the representation of the unsigned magnitude 
     * will not be the zero character. The characters &lt;tt&gt;'0'&lt;/tt&gt; 
     * (&lt;tt&gt;'&amp;#92;u0030'&lt;/tt&gt;) and &lt;tt&gt;'1'&lt;/tt&gt; (&lt;tt&gt;'&amp;#92;u0031'&lt;/tt&gt;) 
     * are used as binary digits. 
     *
     * @param   i   a long.
     * @return  the string representation of the unsigned long value
     *          represented by the argument in binary (base&amp;nbsp;2).
     * @since   JDK 1.0.2
     */
    public static String toBinaryString(long i) {
	return toUnsignedString(i, 1);
    }

    /**
     * Convert the integer to an unsigned number.
     */
    private static String toUnsignedString(long i, int shift) {
	char[] buf = new char[64];
	int charPos = 64;
	int radix = 1 &lt;&lt; shift;
	long mask = radix - 1;
	do {
	    buf[--charPos] = Integer.digits[(int)(i &amp; mask)];
	    i &gt;&gt;&gt;= shift;
	} while (i != 0);
	return new String(buf, charPos, (64 - charPos));
    }

    /**
     * Returns a new String object representing the specified integer. 
     * The argument is converted to signed decimal representation and 
     * returned as a string, exactly as if the argument and the radix 
     * 10 were given as arguments to the 
     * {@link #toString(long, int)} method that takes two arguments.
     *
     * @param   i   a &lt;code&gt;long&lt;/code&gt; to be converted.
     * @return  a string representation of the argument in base&amp;nbsp;10.
     */
    public static String toString(long i) {
	return toString(i, 10);
    }

    /**
     * Parses the string argument as a signed &lt;code&gt;long&lt;/code&gt; in the 
     * radix specified by the second argument. The characters in the 
     * string must all be digits of the specified radix (as determined by 
     * whether &lt;code&gt;Character.digit&lt;/code&gt; returns a 
     * nonnegative value), except that the first character may be an 
     * ASCII minus sign &lt;code&gt;'-'&lt;/code&gt; (&lt;tt&gt;'&amp;#92;u002d'&lt;/tt&gt; to indicate 
     * a negative value. The resulting &lt;code&gt;long&lt;/code&gt; value is returned. 
     * &lt;p&gt;
     * Note that neither &lt;tt&gt;L&lt;/tt&gt; nor &lt;tt&gt;l&lt;/tt&gt; is permitted to appear at 
     * the end of the string as a type indicator, as would be permitted in 
     * Java programming language source code - except that either &lt;tt&gt;L&lt;/tt&gt; 
     * or &lt;tt&gt;l&lt;/tt&gt; may appear as a digit for a radix greater than 22.
     * &lt;p&gt;
     * An exception of type &lt;tt&gt;NumberFormatException&lt;/tt&gt; is thrown if any of
     * the following situations occurs:
     * &lt;ul&gt;
     * &lt;li&gt;The first argument is &lt;tt&gt;null&lt;/tt&gt; or is a string of length zero. 
     * &lt;li&gt;The &lt;tt&gt;radix&lt;/tt&gt; is either smaller than 
     *     {@link java.lang.Character#MIN_RADIX} or larger than 
     *     {@link java.lang.Character#MAX_RADIX}. 
     * &lt;li&gt;The first character of the string is not a digit of the
     *     specified &lt;tt&gt;radix&lt;/tt&gt; and is not a minus sign &lt;tt&gt;'-'&lt;/tt&gt; 
     *     (&lt;tt&gt;'&amp;#92;u002d'&lt;/tt&gt;). 
     * &lt;li&gt;The first character of the string is a minus sign and the
     *     string is of length 1. 
     * &lt;li&gt;Any character of the string after the first is not a digit of
     *     the specified &lt;tt&gt;radix&lt;/tt&gt;. 
     * &lt;li&gt;The integer value represented by the string cannot be
     *     represented as a value of type &lt;tt&gt;long&lt;/tt&gt;. 
     * &lt;/ul&gt;&lt;p&gt;
     * Examples:
     * &lt;blockquote&gt;&lt;pre&gt;
     * parseLong("0", 10) returns 0L
     * parseLong("473", 10) returns 473L
     * parseLong("-0", 10) returns 0L
     * parseLong("-FF", 16) returns -255L
     * parseLong("1100110", 2) returns 102L
     * parseLong("99", 8) throws a NumberFormatException
     * parseLong("Hazelnut", 10) throws a NumberFormatException
     * parseLong("Hazelnut", 36) returns 1356099454469L
     * &lt;/pre&gt;&lt;/blockquote&gt;
     * 
     * @param      s       the &lt;code&gt;String&lt;/code&gt; containing the
     *                     &lt;code&gt;long&lt;/code&gt;.
     * @param      radix   the radix to be used.
     * @return     the &lt;code&gt;long&lt;/code&gt; represented by the string argument in
     *             the specified radix.
     * @exception  NumberFormatException  if the string does not contain a
     *               parsable integer.
     */
    public static long parseLong(String s, int radix)
              throws NumberFormatException
    {
        if (s == null) {
            throw new NumberFormatException("null");
        }

	if (radix &lt; Character.MIN_RADIX) {
	    throw new NumberFormatException("radix " + radix +
					    " less than Character.MIN_RADIX");
	}
	if (radix &gt; Character.MAX_RADIX) {
	    throw new NumberFormatException("radix " + radix +
					    " greater than Character.MAX_RADIX");
	}

	long result = 0;
	boolean negative = false;
	int i = 0, max = s.length();
	long limit;
	long multmin;
	int digit;

	if (max &gt; 0) {
	    if (s.charAt(0) == '-') {
		negative = true;
		limit = Long.MIN_VALUE;
		i++;
	    } else {
		limit = -Long.MAX_VALUE;
	    }
	    multmin = limit / radix;
            if (i &lt; max) {
                digit = Character.digit(s.charAt(i++),radix);
		if (digit &lt; 0) {
		    throw new NumberFormatException(s);
		} else {
		    result = -digit;
		}
	    }
	    while (i &lt; max) {
		// Accumulating negatively avoids surprises near MAX_VALUE
		digit = Character.digit(s.charAt(i++),radix);
		if (digit &lt; 0) {
		    throw new NumberFormatException(s);
		}
		if (result &lt; multmin) {
		    throw new NumberFormatException(s);
		}
		result *= radix;
		if (result &lt; limit + digit) {
		    throw new NumberFormatException(s);
		}
		result -= digit;
	    }
	} else {
	    throw new NumberFormatException(s);
	}
	if (negative) {
	    if (i &gt; 1) {
		return result;
	    } else {	/* Only got "-" */
		throw new NumberFormatException(s);
	    }
	} else {
	    return -result;
	}
    }

    /**
     * Parses the string argument as a signed decimal &lt;code&gt;long&lt;/code&gt;. 
     * The characters in the string must all be decimal digits, except 
     * that the first character may be an ASCII minus sign 
     * &lt;code&gt;'-'&lt;/code&gt; (&lt;code&gt;&amp;#92;u002d'&lt;/code&gt;) to indicate a negative 
     * value. The resulting long value is returned, exactly as if the
     * argument and the radix &lt;tt&gt;10&lt;/tt&gt; were given as arguments to the
     * {@link #parseLong(String, int)} method that takes two arguments. 
     * &lt;p&gt;
     * Note that neither &lt;tt&gt;L&lt;/tt&gt; nor &lt;tt&gt;l&lt;/tt&gt; is permitted to appear 
     * at the end of the string as a type indicator, as would be permitted
     * in Java programming language source code.
     *
     * @param      s   a string.
     * @return     the &lt;code&gt;long&lt;/code&gt; represented by the argument in decimal.
     * @exception  NumberFormatException  if the string does not contain a
     *               parsable &lt;code&gt;long&lt;/code&gt;.
     */
    public static long parseLong(String s) throws NumberFormatException {
	return parseLong(s, 10);
    }

    /**
     * Returns a new long object initialized to the value of the
     * specified String. Throws an exception if the String cannot be
     * parsed as a long.
     * &lt;p&gt;
     * The first argument is interpreted as representing a signed integer
     * in the radix specified by the second argument, exactly as if the
     * arguments were given to the {@link #parseLong(java.lang.String, int)} 
     * method that takes two arguments. The result is a &lt;tt&gt;Long&lt;/tt&gt; object 
     * that represents the integer value specified by the string. 
     * &lt;p&gt;
     * In other words, this method returns a &lt;tt&gt;Long&lt;/tt&gt; object equal 
     * to the value of:
     * &lt;blockquote&gt;&lt;pre&gt;
     * new Long(Long.parseLong(s, radix))
     * &lt;/pre&gt;&lt;/blockquote&gt;
     *
     * @param      s       the &lt;code&gt;String&lt;/code&gt; containing the
     *                     &lt;code&gt;long&lt;/code&gt;.
     * @param      radix   the radix to be used.
     * @return     a newly constructed &lt;code&gt;Long&lt;/code&gt; initialized to the
     *             value represented by the string argument in the specified
     *             radix.
     * @exception  NumberFormatException  If the &lt;code&gt;String&lt;/code&gt; does not
     *               contain a parsable &lt;code&gt;long&lt;/code&gt;.
     */
    public static Long valueOf(String s, int radix) throws NumberFormatException {
	return new Long(parseLong(s, radix));
    }

    /**
     * Returns a new long object initialized to the value of the
     * specified String. Throws an exception if the String cannot be
     * parsed as a long. The radix is assumed to be 10.
     * &lt;p&gt;
     * The argument is interpreted as representing a signed decimal
     * integer, exactly as if the argument were given to the 
     * {@link #parseLong(java.lang.String)} method that takes one argument). 
     * The result is a &lt;code&gt;Long&lt;/code&gt; object that represents the integer 
     * value specified by the string. 
     * &lt;p&gt;
     * In other words, this method returns a &lt;tt&gt;Long&lt;/tt&gt; object equal to 
     * the value of:
     * &lt;blockquote&gt;&lt;pre&gt;
     * new Long(Long.parseLong(s))
     * &lt;/pre&gt;&lt;/blockquote&gt;
     *
     * @param      s   the string to be parsed.
     * @return     a newly constructed &lt;code&gt;Long&lt;/code&gt; initialized to the
     *             value represented by the string argument.
     * @exception  NumberFormatException  If the &lt;code&gt;String&lt;/code&gt; does not
     *               contain a parsable &lt;code&gt;long&lt;/code&gt;.
     */
    public static Long valueOf(String s) throws NumberFormatException
    {
	return new Long(parseLong(s, 10));
    }

    /**
     * Decodes a &lt;code&gt;String&lt;/code&gt; into a &lt;code&gt;Long&lt;/code&gt;.  Accepts
     * decimal, hexadecimal, and octal numbers, in the following formats:
     * &lt;pre&gt;
     *     [-]        decimal constant
     *     [-] 0x     hex constant
     *     [-] #      hex constant
     *     [-] 0      octal constant
     * &lt;/pre&gt;
     *
     * The constant following an (optional) negative sign and/or "radix
     * specifier" is parsed as by the &lt;code&gt;Long.parseLong&lt;/code&gt; method
     * with the specified radix (10, 8 or 16).  This constant must be positive
     * or a NumberFormatException will result.  The result is made negative if
     * first character of the specified &lt;code&gt;String&lt;/code&gt; is the negative
     * sign.  No whitespace characters are permitted in the
     * &lt;code&gt;String&lt;/code&gt;.
     *
     * @param     nm the &lt;code&gt;String&lt;/code&gt; to decode.
     * @return    the &lt;code&gt;Long&lt;/code&gt; represented by the specified string.
     * @exception NumberFormatException  if the &lt;code&gt;String&lt;/code&gt; does not
     *            contain a parsable long.
     * @see java.lang.Long#parseLong(String, int)
     */
    public static Long decode(String nm) throws NumberFormatException {
        int radix = 10;
        int index = 0;
        boolean negative = false;
        Long result;

        // Handle minus sign, if present
        if (nm.startsWith("-")) {
            negative = true;
            index++;
        }

        // Handle radix specifier, if present
	if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
	    index += 2;
            radix = 16;
	}
	else if (nm.startsWith("#", index)) {
	    index ++;
            radix = 16;
	}
	else if (nm.startsWith("0", index) &amp;&amp; nm.length() &gt; 1 + index) {
	    index ++;
            radix = 8;
	}

        if (nm.startsWith("-", index))
            throw new NumberFormatException("Negative sign in wrong position");

        try {
            result = Long.valueOf(nm.substring(index), radix);
            result = negative ? new Long((long)-result.longValue()) : result;
        } catch (NumberFormatException e) {
            // If number is Long.MIN_VALUE, we'll end up here. The next line
            // handles this case, and causes any genuine format error to be
            // rethrown.
            String constant = negative ? new String("-" + nm.substring(index))
                                       : nm.substring(index);
            result = Long.valueOf(constant, radix);
        }
        return result;
    }

    /**
     * The value of the Long.
     *
     * @serial
     */
    private long value;

    /**
     * Constructs a newly allocated &lt;code&gt;Long&lt;/code&gt; object that
     * represents the primitive &lt;code&gt;long&lt;/code&gt; argument.
     *
     * @param   value   the value to be represented by the 
     *          &lt;code&gt;Long&lt;/code&gt; object.
     */
    public Long(long value) {
	this.value = value;
    }

    /**
     * Constructs a newly allocated &lt;code&gt;Long&lt;/code&gt; object that 
     * represents the value represented by the string in decimal form. 
     * The string is converted to an &lt;code&gt;long&lt;/code&gt; value as if by the 
     * {@link #parseLong(java.lang.String, int)} method for radix 10. 
     *
     * @param      s   the string to be converted to a &lt;code&gt;Long&lt;/code&gt;.
     * @exception  NumberFormatException  if the &lt;code&gt;String&lt;/code&gt; does not
     *               contain a parsable long integer.
     * @see        java.lang.Long#valueOf(java.lang.String)
     */
    public Long(String s) throws NumberFormatException {
	this.value = parseLong(s, 10);
    }

    /**
     * Returns the value of this Long as a byte.
     *
     * @since   JDK1.1
     */
    public byte byteValue() {
	return (byte)value;
    }

    /**
     * Returns the value of this Long as a short.
     *
     * @since   JDK1.1
     */
    public short shortValue() {
	return (short)value;
    }

    /**
     * Returns the value of this Long as an int.
     *
     * @return  the &lt;code&gt;long&lt;/code&gt; value represented by this object is
     *          converted to type &lt;code&gt;int&lt;/code&gt; and the result of the
     *          conversion is returned.
     */
    public int intValue() {
	return (int)value;
    }

    /**
     * Returns the value of this Long as a long value.
     *
     * @return  the &lt;code&gt;long&lt;/code&gt; value represented by this object.
     */
    public long longValue() {
	return (long)value;
    }

    /**
     * Returns the value of this Long as a float.
     *
     * @return  the &lt;code&gt;long&lt;/code&gt; value represented by this object is
     *          converted to type &lt;code&gt;float&lt;/code&gt; and the result of
     *          the conversion is returned.
     */
    public float floatValue() {
	return (float)value;
    }

    /**
     * Returns the value of this Long as a double.
     *
     * @return  the &lt;code&gt;long&lt;/code&gt; value represented by this object that
     *          is converted to type &lt;code&gt;double&lt;/code&gt; and the result of
     *          the conversion is returned.
     */
    public double doubleValue() {
	return (double)value;
    }

    /**
     * Returns a String object representing this Long's value. 
     * The long integer value represented by this Long object is converted 
     * to signed decimal representation and returned as a string, exactly 
     * as if the long value were given as an argument to the 
     * {@link #toString(long)} method that takes one argument.
     *
     * @return  a string representation of this object in base&amp;nbsp;10.
     */
    public String toString() {
	return String.valueOf(value);
    }

    /**
     * Computes a hashcode for this Long. The result is the exclusive 
     * OR of the two halves of the primitive &lt;code&gt;long&lt;/code&gt; value 
     * represented by this &lt;code&gt;Long&lt;/code&gt; object. That is, the hashcode 
     * is the value of the expression: 
     * &lt;blockquote&gt;&lt;pre&gt;
     * (int)(this.longValue()^(this.longValue()&gt;&gt;&gt;32))
     * &lt;/pre&gt;&lt;/blockquote&gt;
     *
     * @return  a hash code value for this object.
     */
    public int hashCode() {
	return (int)(value ^ (value &gt;&gt; 32));
    }

    /**
     * Compares this object against the specified object.
     * The result is &lt;code&gt;true&lt;/code&gt; if and only if the argument is
     * not &lt;code&gt;null&lt;/code&gt; and is a &lt;code&gt;Long&lt;/code&gt; object that
     * contains the same &lt;code&gt;long&lt;/code&gt; value as this object.
     *
     * @param   obj   the object to compare with.
     * @return  &lt;code&gt;true&lt;/code&gt; if the objects are the same;
     *          &lt;code&gt;false&lt;/code&gt; otherwise.
     */
    public boolean equals(Object obj) {
	if (obj instanceof Long) {
	    return value == ((Long)obj).longValue();
	}
	return false;
    }

    /**
     * Determines the &lt;code&gt;long&lt;/code&gt; value of the system property
     * with the specified name.
     * &lt;p&gt;
     * The first argument is treated as the name of a system property. 
     * System properties are accessible through the 
     * {@link java.lang.System#getProperty(java.lang.String)} method. The 
     * string value of this property is then interpreted as a long value 
     * and a &lt;code&gt;Long&lt;/code&gt; object representing this value is returned. 
     * Details of possible numeric formats can be found with the 
     * definition of &lt;code&gt;getProperty&lt;/code&gt;. 
     * &lt;p&gt;
     * If there is no property with the specified name, if the specified name
     * is empty or null, or if the property does not have the correct numeric
     * format, then &lt;code&gt;null&lt;/code&gt; is returned.
     * &lt;p&gt;
     * In other words, this method returns a &lt;tt&gt;Long&lt;/tt&gt; object equal to 
     * the value of:
     * &lt;blockquote&gt;&lt;pre&gt;
     * getLong(nm, null)
     * &lt;/pre&gt;&lt;/blockquote&gt;
     *
     * @param   nm   property name.
     * @return  the &lt;code&gt;Long&lt;/code&gt; value of the property.
     * @see     java.lang.System#getProperty(java.lang.String)
     * @see     java.lang.System#getProperty(java.lang.String, java.lang.String)
     */
    public static Long getLong(String nm) {
	return getLong(nm, null);
    }

    /**
     * Determines the &lt;code&gt;long&lt;/code&gt; value of the system property
     * with the specified name.
     * &lt;p&gt;
     * The first argument is treated as the name of a system property. 
     * System properties are accessible through the 
     * {@link java.lang.System#getProperty(java.lang.String)} method. The 
     * string value of this property is then interpreted as a long value 
     * and a &lt;code&gt;Long&lt;/code&gt; object representing this value is returned. 
     * Details of possible numeric formats can be found with the 
     * definition of &lt;code&gt;getProperty&lt;/code&gt;. 
     * &lt;p&gt;
     * The second argument is the default value. A &lt;code&gt;Long&lt;/code&gt; object
     * that represents the value of the second argument is returned if there
     * is no property of the specified name, if the property does not have
     * the correct numeric format, or if the specified name is empty or null.
     * &lt;p&gt;
     * In other words, this method returns a &lt;tt&gt;Long&lt;/tt&gt; object equal 
     * to the value of:
     * &lt;blockquote&gt;&lt;pre&gt;
     * getLong(nm, new Long(val))
     * &lt;/pre&gt;&lt;/blockquote&gt;
     * but in practice it may be implemented in a manner such as: 
     * &lt;blockquote&gt;&lt;pre&gt;
     * Long result = getLong(nm, null);
     * return (result == null) ? new Long(val) : result;
     * &lt;/pre&gt;&lt;/blockquote&gt;
     * to avoid the unnecessary allocation of a &lt;tt&gt;Long&lt;/tt&gt; object when 
     * the default value is not needed. 
     *
     * @param   nm    property name.
     * @param   val   default value.
     * @return  the &lt;code&gt;Long&lt;/code&gt; value of the property.
     * @see     java.lang.System#getProperty(java.lang.String)
     * @see     java.lang.System#getProperty(java.lang.String, java.lang.String)
     */
    public static Long getLong(String nm, long val) {
        Long result = Long.getLong(nm, null);
        return (result == null) ? new Long(val) : result;
    }

    /**
     * Returns the long value of the system property with the specified
     * name.  The first argument is treated as the name of a system property.
     * System properties are accessible through the 
     * {@link java.lang.System#getProperty(java.lang.String)} method. 
     * The string value of this property is then interpreted as a long 
     * value, as per the &lt;code&gt;Long.decode&lt;/code&gt; method, and a 
     * &lt;code&gt;Long&lt;/code&gt; object representing this value is returned.
     * &lt;p&gt;&lt;ul&gt;
     * &lt;li&gt;If the property value begins with the two ASCII characters
     * &lt;tt&gt;0x&lt;/tt&gt; or the ASCII character &lt;tt&gt;#&lt;/tt&gt;, not followed by a 
     * minus sign, then the rest of it is parsed as a hexadecimal integer
     * exactly as for the method {@link #valueOf(java.lang.String, int)} 
     * with radix 16. 
     * &lt;li&gt;If the property value begins with the character &lt;tt&gt;0&lt;/tt&gt; followed
     * by another character, it is parsed as an octal integer exactly
     * as for the method {@link #valueOf(java.lang.String, int)} with radix 8. 
     * &lt;li&gt;Otherwise the property value is parsed as a decimal
     * integer exactly as for the method 
     * {@link #valueOf(java.lang.String, int)} with radix 10. 
     * &lt;/ul&gt;
     * &lt;p&gt;
     * Note that, in every case, neither &lt;tt&gt;L&lt;/tt&gt; nor &lt;tt&gt;l&lt;/tt&gt; is 
     * permitted to appear at the end of the property value as a type 
     * indicator, as would be permitted in Java programming language 
     * source code.
     * &lt;p&gt;
     * The second argument is the default value. The default value is
     * returned if there is no property of the specified name, if the
     * property does not have the correct numeric format, or if the
     * specified name is empty or null.
     *
     * @param   nm   property name.
     * @param   val   default value.
     * @return  the &lt;code&gt;Long&lt;/code&gt; value of the property.
     * @see     java.lang.System#getProperty(java.lang.String)
     * @see java.lang.System#getProperty(java.lang.String, java.lang.String)
     * @see java.lang.Long#decode
     */
    public static Long getLong(String nm, Long val) {
        String v = null;
        try {
            v = System.getProperty(nm);
        } catch (IllegalArgumentException e) {
        } catch (NullPointerException e) {
        }
	if (v != null) {
	    try {
		return Long.decode(v);
	    } catch (NumberFormatException e) {
	    }
	}
	return val;
    }

    /**
     * Compares two Longs numerically.
     *
     * @param   anotherLong   the &lt;code&gt;Long&lt;/code&gt; to be compared.
     * @return  the value &lt;code&gt;0&lt;/code&gt; if the argument Long is equal to
     *          this Long; a value less than &lt;code&gt;0&lt;/code&gt; if this Long
     *          is numerically less than the Long argument; and a
     *          value greater than &lt;code&gt;0&lt;/code&gt; if this Long is
     *          numerically greater than the Long argument
     *		(signed comparison).
     * @since   1.2
     */
    public int compareTo(Long anotherLong) {
	long thisVal = this.value;
	long anotherVal = anotherLong.value;
	return (thisVal&lt;anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
    }

    /**
     * Compares this Long to another Object.  If the Object is a Long,
     * this function behaves like &lt;code&gt;compareTo(Long)&lt;/code&gt;.  Otherwise,
     * it throws a &lt;code&gt;ClassCastException&lt;/code&gt; (as Longs are comparable
     * only to other Longs).
     *
     * @param   o the &lt;code&gt;Object&lt;/code&gt; to be compared.
     * @return  the value &lt;code&gt;0&lt;/code&gt; if the argument is a Long
     *		numerically equal to this Long; a value less than
     *		&lt;code&gt;0&lt;/code&gt; if the argument is a Long numerically
     *		greater than this Long; and a value greater than
     *		&lt;code&gt;0&lt;/code&gt; if the argument is a Long numerically
     *		less than this Long.
     * @exception &lt;code&gt;ClassCastException&lt;/code&gt; if the argument is not a
     *		  &lt;code&gt;Long&lt;/code&gt;.
     * @see     java.lang.Comparable
     * @since   1.2
     */
    public int compareTo(Object o) {
	return compareTo((Long)o);
    }

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 4290774380558885855L;
}
</pre></body></html>