java.lang.Long Maven / Gradle / Ivy
/*
This is not an official specification document, and usage is restricted.
NOTICE
(c) 2005-2007 Sun Microsystems, Inc. All Rights Reserved.
Neither this file nor any files generated from it describe a complete
specification, and they may only be used as described below. For
example, no permission is given for you to incorporate this file, in
whole or in part, in an implementation of a Java specification.
Sun Microsystems Inc. owns the copyright in this file and it is provided
to you for informative, as opposed to normative, use. The file and any
files generated from it may be used to generate other informative
documentation, such as a unified set of documents of API signatures for
a platform that includes technologies expressed as Java APIs. The file
may also be used to produce "compilation stubs," which allow
applications to be compiled and validated for such platforms.
Any work generated from this file, such as unified javadocs or compiled
stub files, must be accompanied by this notice in its entirety.
This work corresponds to the API signatures of JSR 219: Foundation
Profile 1.1. In the event of a discrepency between this work and the
JSR 219 specification, which is available at
http://www.jcp.org/en/jsr/detail?id=219, the latter takes precedence.
*/
package java.lang;
/**
* The Long class wraps a value of the primitive type
* long in an object. An object of type Long
* contains a single field whose type is long.
*
*
*
* In addition, this class provides several methods for converting a
* long to a String and a
* String to a long, as well as other
* constants and methods useful when dealing with a long.
*
* @author Lee Boynton
* @author Arthur van Hoff
* @version 1.52, 02/02/00
* @since JDK1.0
*/
public final class Long extends java.lang.Number implements java.lang.Comparable
{
/**
* A constant holding the minimum value a long can
* have, -263.
*/
public static final long MIN_VALUE = -9223372036854775808L;
/**
* A constant holding the maximum value a long can
* have, 263-1.
*/
public static final long MAX_VALUE = 9223372036854775807L;
/**
* The Class instance representing the primitive type
* long.
*
* @since JDK1.1
*/
public static final java.lang.Class TYPE = null;
/**
* The value of the Long.
*
* @serial
*/
private long value;
/**
* Constructs a newly allocated Long object that
* represents the specified long argument.
*
* @param value the value to be represented by the
* Long object.
*/
public Long(long value) { }
/**
* Constructs a newly allocated Long object that
* represents the long value indicated by the
* String parameter. The string is converted to a
* long value in exactly the manner used by the
* parseLong method for radix 10.
*
* @param s the String to be converted to a
* Long.
* @exception NumberFormatException if the String does not
* contain a parsable long.
* @see java.lang.Long#parseLong(java.lang.String, int)
*/
public Long(java.lang.String s) throws java.lang.NumberFormatException { }
/**
* Returns a string representation of the first argument in the
* radix specified by the second argument.
*
* If the radix is smaller than Character.MIN_RADIX
* or larger than Character.MAX_RADIX, then the radix
* 10 is used instead.
*
* If the first argument is negative, the first element of the
* result is the ASCII minus sign '-'
* ('\u002d'). If the first argument is not
* negative, no sign character appears in the result.
*
* 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 '0'
* ('\u0030'); otherwise, the first character of
* the representation of the magnitude will not be the zero
* character. The following ASCII characters are used as digits:
*
* 0123456789abcdefghijklmnopqrstuvwxyz
*
* These are '\u0030' through
* '\u0039' and '\u0061' through
* '\u007a'. If radix is
* N, then the first N of these characters
* are used as radix-N digits in the order shown. Thus,
* the digits for hexadecimal (radix 16) are
* 0123456789abcdef. If uppercase letters are
* desired, the {@link java.lang.String#toUpperCase()} method may
* be called on the result:
*
* Long.toString(n, 16).toUpperCase()
*
*
* @param i a longto be converted to a string.
* @param radix the radix to use in the string representation.
* @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 java.lang.String toString(long i, int radix) {
return null;
}
/**
* Returns a string representation of the long
* argument as an unsigned integer in base 16.
*
* The unsigned long value is the argument plus
* 264 if the argument is negative; otherwise, it is
* equal to the argument. This value is converted to a string of
* ASCII digits in hexadecimal (base 16) with no extra
* leading 0s. If the unsigned magnitude is zero, it
* is represented by a single zero character '0'
* ('\u0030'); 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:
*
* 0123456789abcdef
*
* These are the characters '\u0030' through
* '\u0039' and '\u0061' through
* '\u0066'. If uppercase letters are desired,
* the {@link java.lang.String#toUpperCase()} method may be called
* on the result:
*
* Long.toHexString(n).toUpperCase()
*
*
* @param i a long to be converted to a string.
* @return the string representation of the unsigned long
* value represented by the argument in hexadecimal
* (base 16).
* @since JDK 1.0.2
*/
public static java.lang.String toHexString(long i) {
return null;
}
/**
* Returns a string representation of the long
* argument as an unsigned integer in base 8.
*
* The unsigned long value is the argument plus
* 264 if the argument is negative; otherwise, it is
* equal to the argument. This value is converted to a string of
* ASCII digits in octal (base 8) with no extra leading
* 0s.
*
* If the unsigned magnitude is zero, it is represented by a
* single zero character '0'
* ('\u0030'); 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:
*
* 01234567
*
* These are the characters '\u0030' through
* '\u0037'.
*
* @param i a long to be converted to a string.
* @return the string representation of the unsigned long
* value represented by the argument in octal (base 8).
* @since JDK 1.0.2
*/
public static java.lang.String toOctalString(long i) {
return null;
}
/**
* Returns a string representation of the long
* argument as an unsigned integer in base 2.
*
* The unsigned long value is the argument plus
* 264 if the argument is negative; otherwise, it is
* equal to the argument. This value is converted to a string of
* ASCII digits in binary (base 2) with no extra leading
* 0s. If the unsigned magnitude is zero, it is
* represented by a single zero character '0'
* ('\u0030'); otherwise, the first character of
* the representation of the unsigned magnitude will not be the
* zero character. The characters '0'
* ('\u0030') and '1'
* ('\u0031') are used as binary digits.
*
* @param i a long to be converted to a string.
* @return the string representation of the unsigned long
* value represented by the argument in binary (base 2).
* @since JDK 1.0.2
*/
public static java.lang.String toBinaryString(long i) {
return null;
}
/**
* Returns a String object representing the specified
* long. 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.
*
* @param i a long to be converted.
* @return a string representation of the argument in base 10.
*/
public static java.lang.String toString(long i) {
return null;
}
/**
* Parses the string argument as a signed long 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 {@link java.lang.Character#digit(char, int)} returns
* a nonnegative value), except that the first character may be an
* ASCII minus sign '-' ('\u002D') to
* indicate a negative value. The resulting long
* value is returned.
*
* Note that neither the character L
* ('\u004C') nor l
* ('\u006C') 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
* L or l may appear as a digit for a
* radix greater than 22.
*
* An exception of type NumberFormatException is
* thrown if any of the following situations occurs:
*
* - The first argument is
null or is a string of
* length zero.
* - The
radix is either smaller than {@link
* java.lang.Character#MIN_RADIX} or larger than {@link
* java.lang.Character#MAX_RADIX}.
* - Any character of the string is not a digit of the specified
* radix, except that the first character may be a minus sign
*
'-' ('\u002d') provided that the
* string is longer than length 1.
* - The value represented by the string is not a value of type
*
long.
*
* Examples:
*
* 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
*
*
* @param s the String containing the
* long representation to be parsed.
* @param radix the radix to be used while parsing s.
* @return the long represented by the string argument in
* the specified radix.
* @exception NumberFormatException if the string does not contain a
* parsable long.
*/
public static long parseLong(java.lang.String s, int radix)
throws java.lang.NumberFormatException
{
return -1;
}
/**
* Parses the string argument as a signed decimal
* long. The characters in the string must all be
* decimal digits, except that the first character may be an ASCII
* minus sign '-' (\u002D') to
* indicate a negative value. The resulting long
* value is returned, exactly as if the argument and the radix
* 10 were given as arguments to the {@link
* #parseLong(java.lang.String, int)} method.
*
* Note that neither the character L
* ('\u004C') nor l
* ('\u006C') 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 containing the long
* representation to be parsed
* @return the long represented by the argument in
* decimal.
* @exception NumberFormatException if the string does not contain a
* parsable long.
*/
public static long parseLong(java.lang.String s)
throws java.lang.NumberFormatException
{
return -1;
}
/**
* Returns a Long object holding the value
* extracted from the specified String when parsed
* with the radix given by the second argument. The first
* argument is interpreted as representing a signed
* long in the radix specified by the second
* argument, exactly as if the arguments were given to the {@link
* #parseLong(java.lang.String, int)} method. The result is a
* Long object that represents the long
* value specified by the string.
*
* In other words, this method returns a Long object equal
* to the value of:
*
*
* new Long(Long.parseLong(s, radix))
*
*
* @param s the string to be parsed
* @param radix the radix to be used in interpreting s
* @return a Long object holding the value
* represented by the string argument in the specified
* radix.
* @exception NumberFormatException If the String does not
* contain a parsable long.
*/
public static java.lang.Long valueOf(java.lang.String s, int radix)
throws java.lang.NumberFormatException
{
return null;
}
/**
* Returns a Long object holding the value
* of the specified String. The argument is
* interpreted as representing a signed decimal long,
* exactly as if the argument were given to the {@link
* #parseLong(java.lang.String)} method. The result is a
* Long object that represents the integer value
* specified by the string.
*
* In other words, this method returns a Long object
* equal to the value of:
*
*
* new Long(Long.parseLong(s))
*
*
* @param s the string to be parsed.
* @return a Long object holding the value
* represented by the string argument.
* @exception NumberFormatException If the string cannot be parsed
* as a long.
*/
public static java.lang.Long valueOf(java.lang.String s)
throws java.lang.NumberFormatException
{
return null;
}
/**
* Decodes a String into a Long.
* Accepts decimal, hexadecimal, and octal numbers given by the
* following grammar:
*
*
*
* - DecodableString:
*
- Signopt DecimalNumeral
*
- Signopt
0x HexDigits
* - Signopt
0X HexDigits
* - Signopt
# HexDigits
* - Signopt
0 OctalDigits
*
*
- Sign:
*
-
*
*
*
* DecimalNumeral, HexDigits, and OctalDigits
* are defined in §3.10.1
* of the Java
* Language Specification.
*
* The sequence of characters following an (optional) negative
* sign and/or radix specifier ("0x",
* "0X", "#", or
* leading zero) is parsed as by the Long.parseLong
* method with the indicated radix (10, 16, or 8). This sequence
* of characters must represent a positive value or a {@link
* NumberFormatException} will be thrown. The result is negated
* if first character of the specified String is the
* minus sign. No whitespace characters are permitted in the
* String.
*
* @param nm the String to decode.
* @return a Long object holding the long
* value represented by nm
* @exception NumberFormatException if the String does not
* contain a parsable long.
* @see java.lang.Long#parseLong(String, int)
* @since 1.2
*/
public static java.lang.Long decode(java.lang.String nm)
throws java.lang.NumberFormatException
{
return null;
}
/**
* Returns the value of this Long as a
* byte.
*/
public byte byteValue() {
return ' ';
}
/**
* Returns the value of this Long as a
* short.
*/
public short shortValue() {
return -1;
}
/**
* Returns the value of this Long as an
* int.
*/
public int intValue() {
return 0;
}
/**
* Returns the value of this Long as a
* long value.
*/
public long longValue() {
return -1;
}
/**
* Returns the value of this Long as a
* float.
*/
public float floatValue() {
return 0.0f;
}
/**
* Returns the value of this Long as a
* double.
*/
public double doubleValue() {
return 0.0d;
}
/**
* Returns a String object representing this
* Long's value. The value 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 java.lang.Long#toString(long)} method.
*
* @return a string representation of the value of this object in
* base 10.
*/
public java.lang.String toString() {
return null;
}
/**
* Returns a hash code for this Long. The result is
* the exclusive OR of the two halves of the primitive
* long value held by this Long
* object. That is, the hashcode is the value of the expression:
*
* (int)(this.longValue()^(this.longValue()>>>32))
*
*
* @return a hash code value for this object.
*/
public int hashCode() {
return 0;
}
/**
* Compares this object to the specified object. The result is
* true if and only if the argument is not
* null and is a Long object that
* contains the same long value as this object.
*
* @param obj the object to compare with.
* @return true if the objects are the same;
* false otherwise.
*/
public boolean equals(java.lang.Object obj) {
return false;
}
/**
* Determines 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 and a Long object
* representing this value is returned. Details of possible
* numeric formats can be found with the definition of
* getProperty.
*
* 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
* null is returned.
*
* In other words, this method returns a Long object equal to
* the value of:
*
* getLong(nm, null)
*
*
* @param nm property name.
* @return the Long 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 java.lang.Long getLong(java.lang.String nm) {
return null;
}
/**
* Determines 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 and a Long object
* representing this value is returned. Details of possible
* numeric formats can be found with the definition of
* getProperty.
*
* The second argument is the default value. A Long 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.
*
* In other words, this method returns a Long object equal
* to the value of:
*
* getLong(nm, new Long(val))
*
* but in practice it may be implemented in a manner such as:
*
* Long result = getLong(nm, null);
* return (result == null) ? new Long(val) : result;
*
* to avoid the unnecessary allocation of a Long object when
* the default value is not needed.
*
* @param nm property name.
* @param val default value.
* @return the Long 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 java.lang.Long getLong(java.lang.String nm, long val) {
return null;
}
/**
* 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
* Long.decode method, and a Long object
* representing this value is returned.
*
* - If the property value begins with the two ASCII characters
*
0x or the ASCII character #, 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.
* - If the property value begins with the ASCII character
*
0 followed by another character, it is parsed as
* an octal integer exactly as by the method {@link
* #valueOf(java.lang.String, int)} with radix 8.
* - Otherwise the property value is parsed as a decimal
* integer exactly as by the method
* {@link #valueOf(java.lang.String, int)} with radix 10.
*
*
* Note that, in every case, neither L
* ('\u004C') nor l
* ('\u006C') 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.
*
* 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 Long 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 java.lang.Long getLong(java.lang.String nm, java.lang.Long
val)
{
return null;
}
/**
* Compares two Long objects numerically.
*
* @param anotherLong the Long to be compared.
* @return the value 0 if this Long is
* equal to the argument Long; a value less than
* 0 if this Long is numerically less
* than the argument Long; and a value greater
* than 0 if this Long is numerically
* greater than the argument Long (signed
* comparison).
* @since 1.2
*/
public int compareTo(java.lang.Long anotherLong) {
return 0;
}
/**
* Compares this Long object to another object. If
* the object is a Long, this function behaves like
* compareTo(Long). Otherwise, it throws a
* ClassCastException (as Long objects
* are comparable only to other Long objects).
*
* @param o the Object to be compared.
* @return the value 0 if the argument is a
* Long numerically equal to this
* Long; a value less than 0
* if the argument is a Long numerically
* greater than this Long; and a value
* greater than 0 if the argument is a
* Long numerically less than this
* Long.
* @exception ClassCastException if the argument is not a
* Long.
* @see java.lang.Comparable
* @since 1.2
*/
public int compareTo(java.lang.Object o) {
return 0;
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = 4290774380558885855L;
}