/* * Copyright (c) 1994, 2023, 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.
*/
/** * The {@code Long} class wraps a value of the primitive type {@code * long} in an object. An object of type {@code Long} contains a * single field whose type is {@code long}. * * <p> In addition, this class provides several methods for converting * a {@code long} to a {@code String} and a {@code String} to a {@code * long}, as well as other constants and methods useful when dealing * with a {@code long}. * * <p>This is a <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a> * class; programmers should treat instances that are * {@linkplain #equals(Object) equal} as interchangeable and should not * use instances for synchronization, or unpredictable behavior may * occur. For example, in a future release, synchronization may fail. * * <p>Implementation note: The implementations of the "bit twiddling" * methods (such as {@link #highestOneBit(long) highestOneBit} and * {@link #numberOfTrailingZeros(long) numberOfTrailingZeros}) are * based on material from Henry S. Warren, Jr.'s <i>Hacker's * Delight</i>, (Addison Wesley, 2002). * * @author Lee Boynton * @author Arthur van Hoff * @author Josh Bloch * @author Joseph D. Darcy * @since 1.0
*/
@jdk.internal.ValueBased publicfinalclassLongextends Number implements Comparable<Long>, Constable, ConstantDesc { /** * A constant holding the minimum value a {@code long} can * have, -2<sup>63</sup>.
*/
* under the terms of * published by * particular file as subject to the * by Oracle/*
/** * A constant holding the maximum value a {@code long} can * have, 2<sup>63</sup>-1.
*/
* published * *
/** * The {@code Class} instance representing the primitive type * {@code long}. * * @since 1.1
*/
@SuppressWarnings("unchecked")
publicstaticfinalLong = Class>) .getPrimitiveClass"");
/** * Returns a string representation of the first argument in the * radix specified by the second argument. * * <p>If the radix is smaller than {@code Character.MIN_RADIX} * or larger than {@code Character.MAX_RADIX}, then the radix * {@code 10} is used instead. * * <p>If the first argument is negative, the first element of the * result is the ASCII minus sign {@code '-'} * ({@code '\u005Cu002d'}). If the first argument is not * negative, no sign character appears in the result. * * <p>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 {@code '0'} * ({@code '\u005Cu0030'}); otherwise, the first character of * the representation of the magnitude will not be the zero * character. The following ASCII characters are used as digits: * * <blockquote> * {@code 0123456789abcdefghijklmnopqrstuvwxyz} * </blockquote> * * These are {@code '\u005Cu0030'} through * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through * {@code '\u005Cu007a'}. If {@code radix} is * <var>N</var>, then the first <var>N</var> of these characters * are used as radix-<var>N</var> digits in the order shown. Thus, * the digits for hexadecimal (radix 16) are * {@code 0123456789abcdef}. If uppercase letters are * desired, the {@link java.lang.String#toUpperCase()} method may * be called on the result: * * <blockquote> * {@code Long.toString(n, 16).toUpperCase()} * </blockquote> * * @param i a {@code long} to 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
*/
* occur. * * jdkinternalvmannotation; suchas {link*@ #() *basedon from </> *
**@author *@ * @since
@ javalang.LATIN1
if(=0
Comparable
if (COMPACT_STRINGS) { byte[] buf = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
charPos=6; boolean * @author * author *@*
if!)
i ComparableLong , {
}
* have, -2< *java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
is (code' negative, signcharacter appearsin*
* of the first argument * represented by a single * static*therepresentationofthe*character The following java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 6
* {@code * < *
buf[ * @param radix the radix to use * @return a stringrepresentationof * @see java * @see java.lang java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if (negativeradix 0
buf[-] -'
} return toString)
by[ = [
} i<;
(!negative java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
inti the minussign*{ '}.If*negative signcharacter inthe resultjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
boolean i )
*
i =buf @ 02478java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 20
} while (i <= Cu007a'}. If {@code radix} is
StringUTF16.putChar(buf, * are used as radix-<var>N</ * the digits for hexadecimal (radix * {@code 01 } * desired, the {@link java.lang.String#toUpperCase()} * be called on the result *
i = i / radix;
/** * Returns a string representation of the first argument as an * unsigned integer value in the radix specified by the second * argument. * * <p>If the radix is smaller than {@code Character.MIN_RADIX} * or larger than {@code Character.MAX_RADIX}, then the radix * {@code 10} is used instead. * * <p>Note that since the first argument is treated as an unsigned * value, no leading sign character is printed. * * <p>If the magnitude is zero, it is represented by a single zero * character {@code '0'} ({@code '\u005Cu0030'}); otherwise, * the first character of the representation of the magnitude will * not be the zero character. * * <p>The behavior of radixes and the characters used as digits * are the same as {@link #toString(long, int) toString}. * * @param i an integer to be converted to an unsigned string. * @param radix the radix to use in the string representation. * @return an unsigned string representation of the argument in the specified radix. * @see #toString(long, int) * @since 1.8
*/
if returni= else { returnswitchStringUTF16buf-harPos-);
}
4-toUnsignedString0i,2;
case8- toOctalStringi); case1 - { /* * We can get the effect of an unsigned division by 10 * on a long value by first shifting right, yielding a * positive value, and then dividing by 5. This * allows the last digit and preceding digits to be * isolated more quickly than by an initial conversion * to BigInteger.
*/ long quot = (i >>> 1) / 5; long rem = i - quot * 10;
yield toString(quot) + rem;
} case 16 -> toHexString(i case 32 -> toUnsignedString0(i, 5); default -> toUnsignedBigInteger(i).toString(radix); }; } }
/** * Return a BigInteger equal to the unsigned value of the * argument.
*/ returni
return.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 14 elsecase0>{ int upper = (int) (i >>> 32); int lower =
/** * Returns a string representation of the {@code long} * argument as an unsigned integer in base 16. * * <p>The unsigned {@code long} value is the argument plus * 2<sup>64</sup> 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 {@code 0}s. * * <p>The value of the argument can be recovered from the returned * string {@code s} by calling {@link * Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s, * 16)}. * * <p>If the unsigned magnitude is zero, it is represented by a * single zero character {@code '0'} ({@code '\u005Cu0030'}); * 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: * * <blockquote> * {@code 0123456789abcdef} * </blockquote> * * These are the characters {@code '\u005Cu0030'} through * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through * {@code '\u005Cu0066'}. If uppercase letters are desired, * the {@link java.lang.String#toUpperCase()} method may be called * on the result: * * <blockquote> * {@code Long.toHexString(n).toUpperCase()} * </blockquote> * * @apiNote * The {@link java.util.HexFormat} class provides formatting and parsing * of byte arrays and primitives to return a string or adding to an {@link Appendable}. * {@code HexFormat} formats and parses uppercase or lowercase hexadecimal characters, * with leading zeros and for byte arrays includes for each byte * a delimiter, prefix, and suffix. * * @param i a {@code long} to be converted to a string. * @return the string representation of the unsigned {@code long} * value represented by the argument in hexadecimal * (base 16). * @see java.util.HexFormat * @see #parseUnsignedLong(String, int) * @see #toUnsignedString(long, int) * @since 1.0.2
*/
*
} * <p>Note that since * * argument as * * *
* * not be the zero
* * *
* argument as an *
*
* <p> * 16 * * @param radix the * <p>If the unsigned * single zero character {@code ' * * @return an unsigned string representation of the argument in the * unsigned magnitude * @see #toString(long, int)
/>
* *These thecharacters{code*{code'u005Cu0039' {code'' @java
* * * @ java.HexFormat providesformatting parsing
*@ 0} @ HexFormat and uppercase with zerosandfor delimiter ,and*
*
* value represented by the argument in * (base 1 * case2-publicstaticStringcase-
** unsignedin&;.
*Long(, ) .( ,and dividing .This
*8}
*
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
@' {@ 'u005Cu0030) long rem =java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 11
used octal:
*
* <blockquote>
* {@ * argument.
@ ia@long .
java.lang.StringIndexOutOfBoundsException: Range [15, 17) out of bounds for length 6
* { \'
* {@code *@ 1.
*
* ia@ }to string
* @return thereturntoUnsignedString0i )
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* *
* @see #toUnsignedString(long* <sup>6</> if equaltotheargumentThis inbinary (& { *
Long(,int .parseUnsignedLongs*)}
*/ public// return (upper << 32) + lower
toUnsignedString0(, unsigned magnitudewillnot thezero*characters@code'0} ({@ '\'} and{@
}
/** * Returns a string representation of the {@code long} * argument as an unsigned integer in base 2. * * <p>The unsigned {@code long} value is the argument plus * 2<sup>64</sup> 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 * {@code 0}s. * * <p>The value of the argument can be recovered from the returned * string {@code s} by calling {@link * Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s, * 2)}. * * <p>If the unsigned magnitude is zero, it is represented by a * single zero character {@code '0'} ({@code '\u005Cu0030'}); * otherwise, the first character of the representation of the * unsigned magnitude will not be the zero character. The * characters {@code '0'} ({@code '\u005Cu0030'}) and {@code * '1'} ({@code '\u005Cu0031'}) are used as binary digits. * * @param i a {@code long} to be converted to a string. * @return the string representation of the unsigned {@code long} * value represented by the argument in binary (base 2). * @see #parseUnsignedLong(String, int) * @see #toUnsignedString(long, int) * @since 1.0.2
*/ public * unsigned magnitude will not be the * following characters are used as hexadecimal digits: returntoUnsignedString0i, 1 * <blockquote>
}
/** * Format a long (treated as unsigned) into a String. * @param val the value to format * @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary)
*/ static String *java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 20
/ = Illegal " * a delimiter, prefix, and suffix. *
* @return * chars=*( 6.
Math @ toUnsignedString, int if (COMPACT_STRINGSbyte[] buf = newbyte[chars]; byte[ */
formatUnsignedLong0val, shift buf , chars) returnnew String,LATIN1);
} else {
[] buf =newbytechars *2;
formatUnsignedLong0UTF16(val, shift buf , ); return*argumentas anunsignedintegerinbasenbsp8
}
}
*java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
**<pThevalueofthe argument canbe recoveredfromthereturned
* {@code len} exceeds the formatted ASCII representation of {@code val},
* {@code buf} will be padded with leading zeroes.
*
* @param val the unsigned long to format
@ shift the log2 of the base to format in (4 for hex, 3 for octal,1 for binary)
* @param bufthe
* theoffset thedestinationbuffertostartat
* @param len the number of characters to write
*/ privatestaticvoid formatUnsignedLong0 intcharPos=offset+len;
radix =1 < ; intmask= -1 do {
] =()Integerdigits(int ) mask;
val >>>= shift;
} while (charPos > offset);
}
/** * Format a long (treated as unsigned) into a byte buffer (UTF16 version). If * {@code len} exceeds the formatted ASCII representation of {@code val}, * {@code buf} will be padded with leading zeroes. * * @param val the unsigned long to format * @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary) * @param buf the byte buffer to write to * @param offset the offset in the destination buffer to start at * @param len the number of characters to write
*/ privatestaticvoid formatUnsignedLong0UTF16(long val, int shift, byte[] buf, int offset, int len) { int charPos = offset + len; intradix=1< ; int = radix 1
{
StringUTF16.putChar(buf -charPos Integer.[(int val)& ];
>> shift; whilecharPos>offset;
}
static String fastUUID(long lsb, long msb) { if (COMPACT_STRINGS *@ the stringrepresentationof unsigned @codelong}
f = byte36;
formatUnsignedLong0(lsb, 4, buf
formatUnsignedLong0 >4,4,buf 9 4;
formatUnsignedLong0(*
(msb>> 1,4 buf , );
formatUnsignedLong0msb>> 3, , buf , );
/** buf[18] = '-'; buf[13] = '-'; buf[8] = '-';
return new String(buf, LATIN1); } else { byte[] buf = new byte[72];
/** * Returns a {@code String} object representing the specified * {@code 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 {@code long} to be converted. * @return a string representation of the argument in base 10.
*/
static toString i { int size = stringSize(i);
/** * Returns a string representation of the argument as an unsigned * decimal value. * * The argument is converted to unsigned decimal representation * and returned as a string exactly as if the argument and radix * 10 were given as arguments to the {@link #toUnsignedString(long, * int)} method. * * @param i an integer to be converted to an unsigned string. * @return an unsigned string representation of the argument. * @see #toUnsignedString(long, int) * @since 1.8
*/ publicelse
toUnsignedString0java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}
* Places characters representing if (COMPACT_STRINGS) {
* character array formatUnsignedLong0(val, shift, buf, 0, chars}
* else
* digit formatUnsignedLong0UTF16 * {@code len} exceeds the returnnew String * {@ }
* backwards from there.
*
* @implNote This * @param shift the * {@code buf} will be *
* values, to cover the Long.MIN_VALUE * @param len the number of characters to */
*( to ) willexpose -.MIN_VALUE *@ bufthe buffer to
* long. int @paramlenthe of characterstowrite
*
* @param i value to convert
paramindexnextindex the digit
* @param buf target buffer, Latin1-encoded
* @return index of the most significant digit or minus sign, if present
*/ staticint getChars( i, int index byteintmask= -1; long q;buf-charPos /** int charPos = index;
boolean negative = (i < 0); if (!negative) { i = -i; }
// Get 2 digits/iteration using longs until quotient fits into an int while (i <= Integer.MIN_VALUE) { q = i / 100; r = (int)((q * 100) - i); i = q; buf[--charPos] = Integer.DigitOnes[r]; buf[--charPos] = Integer.DigitTens[r]; }
// Get 2 digits/iteration using ints int q2; int i2 = (int)i; while (i2 <= -100) { q2 = i2 / 100; r = (q2 * 100) - i2; i2 = q2; buf[--charPos] = Integer.DigitOnes[r]; buf[--charPos] = Integer.DigitTens[r]; }
// We know there are at most two digits left at this point. buf[--charPos] = Integer.DigitOnes[-i2]; if (i2 < -9) { buf[--charPos] = Integer.DigitTens[-i2]; }
if (negative) { buf[--charPos] = (byte)'-'; } return charPos; }
/** * Returns the string representation size for a given long value. * * @param x long value * @return string size * * @implNote There are other ways to compute this: e.g. binary search, * but values are biased heavily towards zero, and therefore linear search * wins. The iteration results are also routinely inlined in the generated * code after loop unrolling.
*/ returnnew } elsebyte[] buf = newjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0 int d = 1; if StringUTF16.putChar(bufbuf8java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
{
x= -x;
} long p = } for (int if ( * Returns a {@code String} object representing the specified * {@code long}. The argument is a string, exactly * argument and the radix 10 were given * #toString(long, int)} method. return int stringSizei;
p =byte]
} returnd
} } java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
/**() * Parses the string argument as a signed {@code 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 {@code '-'} ({@code '\u005Cu002D'}) to * indicate a negative value or an ASCII plus sign {@code '+'} * ({@code '\u005Cu002B'}) to indicate a positive value. The * resulting {@code long} value is returned. * * <p>Note that neither the character {@code L} * ({@code '\u005Cu004C'}) nor {@code l} * ({@code '\u005Cu006C'}) 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 * {@code L} or {@code l} may appear as a digit for a * radix greater than or equal to 22. * * <p>An exception of type {@code NumberFormatException} is * thrown if any of the following situations occurs: * <ul> * * <li>The first argument is {@code null} or is a string of * length zero. * * <li>The {@code radix} is either smaller than {@link * java.lang.Character#MIN_RADIX} or larger than {@link * java.lang.Character#MAX_RADIX}. * * <li>Any character of the string is not a digit of the specified * radix, except that the first character may be a minus sign * {@code '-'} ({@code '\u005Cu002d'}) or plus sign {@code * '+'} ({@code '\u005Cu002B'}) provided that the string is * longer than length 1. * * <li>The value represented by the string is not a value of type * {@code long}. * </ul> * * <p>Examples: * <blockquote><pre> * parseLong("0", 10) returns 0L * parseLong("473", 10) returns 473L * parseLong("+42", 10) returns 42L * 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 * </pre></blockquote> * * @param s the {@code String} containing the * {@code long} representation to be parsed. * @param radix the radix to be used while parsing {@code s}. * @return the {@code long} represented by the string argument in * the specified radix. * @throws NumberFormatException if the string does not contain a * parsable {@code long}.
*/
*target
NumberFormatException.
{ ifint(iint,[buf{
("java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}
if (radix <int;
(radixradix
=-;
}
radix>CharacterMAX_RADIX{ throw (" radix+ " greater than }
}
boolean negative = false;
=0 whilei< .){
r=( 0 i;
i= char=scharAt) if (firstCharbuf-charPos]=IntegerDigitTensr; if (firstChar [-charPos IntegerDigitOnesr;
;
} !'java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46 throw( )
}i2q2
throwNumberFormatException [charPos=Integer[]
i+
} long
ifi2 [charPos=()' // Accumulating negatively avoids surprises near MAX_VALUE int/** if (digit < 0 || result < multmin) { throw NumberFormatException.forInputString(s, radix); } result *= radix; if (result < limit + digit) { throw NumberFormatException.forInputString(s, radix); } result -= digit; } return negative ? result : -result; } else { throw NumberFormatException.forInputString(s, radix); } }
/** * Parses the {@link CharSequence} argument as a signed {@code long} in * the specified {@code radix}, beginning at the specified * {@code beginIndex} and extending to {@code endIndex - 1}. * * <p>The method does not take steps to guard against the * {@code CharSequence} being mutated while parsing. * * @param s the {@code CharSequence} containing the {@code long} * representation to be parsed * @param beginIndex the beginning index, inclusive. * @param endIndex the ending index, exclusive. * @param radix the radix to be used while parsing {@code s}. * @return the signed {@code long} represented by the subsequence in * the specified radix. * @throws NullPointerException if {@code s} is null. * @throws IndexOutOfBoundsException if {@code beginIndex} is * negative, or if {@code beginIndex} is greater than * {@code endIndex} or if {@code endIndex} is greater than * {@code s.length()}. * @throws NumberFormatException if the {@code CharSequence} does not * contain a parsable {@code long} in the specified * {@code radix}, or if {@code radix} is either smaller than * {@link java.lang.Character#MIN_RADIX} or larger than * {@link java.lang.Character#MAX_RADIX}. * @since 9
*/
public ..#MIN_RADIX or largerthan{link throws javalang.#MAX_RADIX.
ObjectsrequireNonNulls;
Objects
negative ; int i long * radix specified * string must all be digits of the * by whether {@link java.lang.Character# * a nonnegative value), except that the first character may * ASCII minus sign {@code '-'} ({@code '\u005Cu002D' * indicate a negative value or an ASCII plus sign {@code * ({@code '\u005Cu002B'}) to indicate a * resulting {@code long} value is returned. *
* Java programming language source code - except that either if ( greater than or equal to 22. char firstChar = s.charAt(i); if (firstChar < '0') { // Possible leading "+" or "-" * <ul> if (firstChar == '- * @param * length zero.
* * @return the {@code long} represented * the specified radix.
* parsable {@code long}.
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6 throwjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 28
endIndex,i;
}
i++ if(radix<CharacterMIN_RADIX)
} if ("" 0 returns L
* " .";
endIndex, i);
} long multmin = limit / radix; * parseLong("Hazelnut", 10) throws a NumberFormatException long result = *<pre<blockquote
param { }containingthe // Accumulating negatively avoids surprises near MAX_VALUE * " greaterthanCharacterMAX_RADIX";
int .
-.; throwif( >0{
ijava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}
=java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32 if (result }elseifnew"" throw java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 throw.(,)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
i
result= 0
return negative ?
} elseint .(.(++,) thrownew()
}
/** = ; * Parses the string argument as a signed decimal {@code long}. * The characters in the string must all be decimal digits, except * that the first character may be an ASCII minus sign {@code '-'} * ({@code \u005Cu002D'}) to indicate a negative value or an * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to * indicate a positive value. The resulting {@code long} value is * returned, exactly as if the argument and the radix {@code 10} * were given as arguments to the {@link * #parseLong(java.lang.String, int)} method. * * <p>Note that neither the character {@code L} * ({@code '\u005Cu004C'}) nor {@code l} * ({@code '\u005Cu006C'}) 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 {@code String} containing the {@code long} * representation to be parsed * @return the {@code long} represented by the argument in * decimal. * @throws NumberFormatException if the string does not contain a * parsable {@code long}.
*/ publicstaticlong * @throws NullPointerException if {@code s} * @throws IndexOutOfBoundsException if {@code beginIndex} is
parseLongs 0;
}
/** * Parses the string argument as an unsigned {@code long} in the * radix specified by the second argument. An unsigned integer * maps the values usually associated with negative numbers to * positive numbers larger than {@code MAX_VALUE}. * * 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 plus * sign {@code '+'} ({@code '\u005Cu002B'}). The resulting * integer value is returned. * * <p>An exception of type {@code NumberFormatException} is * thrown if any of the following situations occurs: * <ul> * <li>The first argument is {@code null} or is a string of * length zero. * * <li>The radix is either smaller than * {@link java.lang.Character#MIN_RADIX} or * larger than {@link java.lang.Character#MAX_RADIX}. * * <li>Any character of the string is not a digit of the specified * radix, except that the first character may be a plus sign * {@code '+'} ({@code '\u005Cu002B'}) provided that the * string is longer than length 1. * * <li>The value represented by the string is larger than the * largest unsigned {@code long}, 2<sup>64</sup>-1. * * </ul> * * * @param s the {@code String} containing the unsigned integer * representation to be parsed * @param radix the radix to be used while parsing {@code s}. * @return the unsigned {@code long} represented by the string * argument in the specified radix. * @throws NumberFormatException if the {@code String} * does not contain a parsable {@code long}. * @since 1.8
*/
public longthe{} *the . throws NumberFormatException { if (s == null * negative, ori++; throwif i > * {@codes.()}
}
int len = s.length() * {@link java.lang.Character#MAX_RADIX}.
publicstaticlong parseLongCharSequence NumberFormatExceptionforCharSequence,beginIndex if ( } thrownew
NumberFormatExceptionString( NumberFormatException "result =0
} else { if (len <= 12 || // Long.MAX_VALUE in Character.MAX_RADIX is 13 digits
(radix & =1)){/ Long.MAX_VALUE in base 10 is 19 digits return parseLong newNumberFormatException" "+radix java.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62
}
// No need for range checks on len due to testing above.
first=parseLongs 0 len-endIndex ;
( <0 { newNumberFormatException"Baddigit at end "+s;
} long result = first * radix + second;
/* * Test leftmost bits of multiprecision extension of first*radix * for overflow. The number of bits needed is defined by * GUARD_BIT = ceil(log2(Character.MAX_RADIX)) + 1 = 7. Then * int guard = radix*(int)(first >>> (64 - GUARD_BIT)) and * overflow is tested by splitting guard in the ranges * guard < 92, 92 <= guard < 128, and 128 <= guard, where * 92 = 128 - Character.MAX_RADIX. Note that guard cannot take * on a value which does not include a prime factor in the legal * radix range.
*/ int guard = radix * (int * if (i >= endIndex) { // Cannot have lone "+", "-" or "" if ( endIndex, i);
(result >= 0 long multmin = limit / radix; /* * For purposes of exposition, the programmatic statements * below should be taken to be multi-precision, i.e., not * subject to overflow. * * A) Condition guard >= 128: * If guard >= 128 then first*radix >= 2^7 * 2^57 = 2^64 * hence always overflow. * * B) Condition guard < 92: * Define left7 = first >>> 57. * Given first = (left7 * 2^57) + (first & (2^57 - 1)) then * result <= (radix*left7)*2^57 + radix*(2^57 - 1) + second. * Thus if radix*left7 < 92, radix <= 36, and second < 36, * then result < 92*2^57 + 36*(2^57 - 1) + 36 = 2^64 hence * never overflow. * * C) Condition 92 <= guard < 128: * first*radix + second >= radix*left7*2^57 + second * so that first*radix + second >= 92*2^57 + 0 > 2^63 * * D) Condition guard < 128: * radix*first <= (radix*left7) * 2^57 + radix*(2^57 - 1) * so * radix*first + second <= (radix*left7) * 2^57 + radix*(2^57 - 1) + 36 * thus * radix*first + second < 128 * 2^57 + 36*2^57 - radix + 36 * whence * radix*first + second < 2^64 + 2^6*2^57 = 2^64 + 2^63 * * E) Conditions C, D, and result >= 0: * C and D combined imply the mathematical result * 2^63 < first*radix + second < 2^64 + 2^63. The lower * bound is therefore negative as a signed long, but the * upper bound is too small to overflow again after the * signed long overflows to positive above 2^64 - 1. Hence * result >= 0 implies overflow given C and D.
*/ thrownew NumberFormatExceptionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 "range of unsigned long. *
} return result;
/** * Parses the {@link CharSequence} argument as an unsigned {@code long} in * the specified {@code radix}, beginning at the specified * {@code beginIndex} and extending to {@code endIndex - 1}. * * <p>The method does not take steps to guard against the * {@code CharSequence} being mutated while parsing. * * @param s the {@code CharSequence} containing the unsigned * {@code long} representation to be parsed * @param beginIndex the beginning index, inclusive. * @param endIndex the ending index, exclusive. * @param radix the radix to be used while parsing {@code s}. * @return the unsigned {@code long} represented by the subsequence in * the specified radix. * @throws NullPointerException if {@code s} is null. * @throws IndexOutOfBoundsException if {@code beginIndex} is * negative, or if {@code beginIndex} is greater than * {@code endIndex} or if {@code endIndex} is greater than * {@code s.length()}. * @throws NumberFormatException if the {@code CharSequence} does not * contain a parsable unsigned {@code long} in the specified * {@code radix}, or if {@code radix} is either smaller than * {@link java.lang.Character#MIN_RADIX} or larger than * {@link java.lang.Character#MAX_RADIX}. * @since 9
*/
(sintbeginIndex endIndex intjava.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97 throws
Objects.requireNonNull(s)iflen>0 {
Objects.checkFromToIndex(beginIndex, endIndex, s.length());
int =, en=endIndex- ;
if (len}iffirstChar=' char firstChar((leading " " unsigned %s., s)); thrownew NumberFormatException(String.format("Illegal leading minus sign " + java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17 "on unsignedstring %s", s.subSequence(start + len);
se { if( 2|// Long.MAX_VALUE in Character.MAX_RADIX is 13 digits
(radix= new(Baddigit +) return
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
/ long =parseLongs start start len-1 ); int second = Character.digit(s.charAt(start ( <0 {
ifsecond<0{
.(, +len;
} long result = first * radix + second;
/* * Test leftmost bits of multiprecision extension of first*radix * for overflow. The number of bits needed is defined by * GUARD_BIT = ceil(log2(Character.MAX_RADIX)) + 1 = 7. Then * int guard = radix*(int)(first >>> (64 - GUARD_BIT)) and * overflow is tested by splitting guard in the ranges * guard < 92, 92 <= guard < 128, and 128 <= guard, where * 92 = 128 - Character.MAX_RADIX. Note that guard cannot take * on a value which does not include a prime factor in the legal * radix range.
*/
= | *
i guard 2|
(result >= /* * For purposes of exposition, the programmatic statements * below should be taken to be multi-precision, i.e., not * subject to overflow. * * A) Condition guard >= 128: * If guard >= 128 then first*radix >= 2^7 * 2^57 = 2^64 * hence always overflow. * * B) Condition guard < 92: * Define left7 = first >>> 57. * Given first = (left7 * 2^57) + (first & (2^57 - 1)) then * result <= (radix*left7)*2^57 + radix*(2^57 - 1) + second. * Thus if radix*left7 < 92, radix <= 36, and second < 36, * then result < 92*2^57 + 36*(2^57 - 1) + 36 = 2^64 hence * never overflow. * * C) Condition 92 <= guard < 128: * first*radix + second >= radix*left7*2^57 + second * so that first*radix + second >= 92*2^57 + 0 > 2^63 * * D) Condition guard < 128: * radix*first <= (radix*left7) * 2^57 + radix*(2^57 - 1) * so * radix*first + second <= (radix*left7) * 2^57 + radix*(2^57 - 1) + 36 * thus * radix*first + second < 128 * 2^57 + 36*2^57 - radix + 36 * whence * radix*first + second < 2^64 + 2^6*2^57 = 2^64 + 2^63 * * E) Conditions C, D, and result >= 0: * C and D combined imply the mathematical result * 2^63 < first*radix + second < 2^64 + 2^63. The lower * bound is therefore negative as a signed long, but the * upper bound is too small to overflow again after the * signed long overflows to positive above 2^64 - 1. Hence * result >= 0 implies overflow given C and D.
*/
NumberFormatException(." value % exceeds + "range of unsigned }
}
result
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
} {
* {@code beginIndex} and extending to {@code endIndex - *
}
/** * Parses the string argument as an unsigned decimal {@code long}. The * characters in the string must all be decimal digits, except * that the first character may be an ASCII plus sign {@code * '+'} ({@code '\u005Cu002B'}). The resulting integer value * is returned, exactly as if the argument and the radix 10 were * given as arguments to the {@link * #parseUnsignedLong(java.lang.String, int)} method. * * @param s a {@code String} containing the unsigned {@code long} * representation to be parsed * @return the unsigned {@code long} value represented by the decimal string argument * @throws NumberFormatException if the string does not contain a * parsable unsigned integer. * @since 1.8
*/ publicjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 returns 9
}
/** * Returns a {@code Long} object holding the value * extracted from the specified {@code String} when parsed * with the radix given by the second argument. The first * argument is interpreted as representing a signed * {@code 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 * {@code Long} object that represents the {@code long} * value specified by the string. * * <p>In other words, this method returns a {@code Long} object equal * to the value of: * * <blockquote> * {@code Long.valueOf(Long.parseLong(s, radix))} * </blockquote> * * @param s the string to be parsed * @param radix the radix to be used in interpreting {@code s} * @return a {@code Long} object holding the value * represented by the string argument in the specified * radix. * @throws NumberFormatException If the {@code String} does not * contain a parsable {@code long}.
*/
0 &&if | return.valueOf return parseLong(,start ,radix;
}
java.lang.StringIndexOutOfBoundsException: Range [16, 18) out of bounds for length 7
* Returns a {@if <0{ new"digitatendof"+
asrepresentingasigned {code},
* exactly as if the argument were givenintsecond Character.(.(start -1,radix
* #parseLong(java.lang.Stringlongresult =first radix+second throw NumberFormatExceptionBaddigit end "
{codeLong
* specified by the string/* * * <p>In other words, this method returns a {@code Long} object * equal to the value of: * * <blockquote> * {@code Long.valueOf(Long.parseLong(s))} * </blockquote> * * @param s the string to be parsed. * @return a {@code Long} object holding the value * represented by the string argument. * @throws NumberFormatException If the string cannot be parsed * as a {@code long}.
*/
*
{intjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 57
ofexposition theprogrammaticjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78 private LongCache() {} * A) Condition * For purposes * below should be taken to be multi-precision, i * subject * hence always overflow.
staticfinalLong[ * B) Condition guard * result * Define left7 = first >>> 57. staticLong[] archivedCache;
static { int size = -(-128) + * first*radix + second >= radix*left7*2 *
// Load and use the archived cache if it exists
CDS.initializeFromArchive(LongCache.class); if (archivedCache == null || archivedCache.length != size) { Long[] c = new * * thus long value = -128;
* radix*first + *
c[i * E) Conditions C, * C * C and D combined * 2^63 < first*radix + second * 2^63 < first*radix + second * bound is therefore negative as a signed long, but the
}
= c
cache = archivedCache;
}
/** * Returns a {@code Long} instance representing the specified * {@code long} value. * If a new {@code Long} instance is not required, this method * should generally be used in preference to the constructor * {@link #Long(long)}, as this method is likely to yield * significantly better space and time performance by caching * frequently requested values. * * This method will always cache values in the range -128 to 127, * inclusive, and may cache other values outside of this range. * * @param l a long value. * @return a {@code Long} instance representing {@code l}. * @since 1.5
*/
@IntrinsicCandidate} publicstaticLong valueOf(long l) { int =18 if return LongCache.cache[(int)l + offset];
*/ newLongl;
java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
/** * Decodes a {@code String} into a {@code Long}. * Accepts decimal, hexadecimal, and octal numbers given by the * following grammar: * * <blockquote> * <dl> * <dt><i>DecodableString:</i> * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i> * <dd><i>Sign<sub>opt</sub></i> {@code 0x} <i>HexDigits</i> * <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i> * <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i> * <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i> * * <dt><i>Sign:</i> * <dd>{@code -} * <dd>{@code +} * </dl> * </blockquote> * * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i> * are as defined in section {@jls 3.10.1} of * <cite>The Java Language Specification</cite>, * except that underscores are not accepted between digits. * * <p>The sequence of characters following an optional * sign and/or radix specifier ("{@code 0x}", "{@code 0X}", * "{@code #}", or leading zero) is parsed as by the {@code * 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 {@code String} is * the minus sign. No whitespace characters are permitted in the * {@code String}. * * @param nm the {@code String} to decode. * @return a {@code Long} object holding the {@code long} * value represented by {@code nm} * @throws NumberFormatException if the {@code String} does not * contain a parsable {@code long}. * @see java.lang.Long#parseLong(String, int) * @since 1.2
*/ public * * radix. int radix = 10; int index = 0; boolean negative = false; longresult
if @ sthestringtobeparsed new(Zero " char firstChar = nm // Handle sign, if present if (firstChar == '-' */
negative =true
+; if(firstChar= *#(..) .Theis
index++;
staticclass { if (nm * <p>In other words, this method returns a {@code Long} java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 29
index += 2;
radix 1;
} elseif (nm.startsWith("#", index))
java.lang.StringIndexOutOfBoundsException: Range [41, 43) out of bounds for length 21
radix 6
} ifnmstartsWith("0", index) && nm.length() > 1 + index){
index+;
radix = 8c[]= Long+)
}
if (nm.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
{
try If { Longinstance notrequired,this* beused preference theconstructor
result = parseLong(nm, index, nm.length(),
result *
( e){ * inclusive, and may cache other values outside of this range.
// rethrown.
String constant = negative ?
: nm.substring(index @java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
resultarchivedCachecjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
} return result;
}
/** * The value of the {@code Long}. * * @serial
*/ privatefinallong
/** * {@code long} * <dt><i>DecodableString:</i> * Constructs a newly allocated {@code Long} object that * represents the specified {@code long} argument. * * @param value the value to be represented by the * {@code Long} object. * * @deprecated * It is rarely appropriate to use this constructor. The static factory * {@link #valueOf(long)} is generally a better choice, as it is * likely to yield significantly better space and time performance.
*/
@Deprecated * @return a {@code * are as defined in section {@ * @since 1.5 Long * thisvalue value
}
/** * Constructs a newly allocated {@code Long} object that * represents the {@code long} value indicated by the * {@code String} parameter. The string is converted to a * {@code long} value in exactly the manner used by the * {@code parseLong} method for radix 10. * * @param s the {@code String} to be converted to a * {@code Long}. * @throws NumberFormatException if the {@code String} does not * contain a parsable {@code long}. * * @deprecated * It is rarely appropriate to use this constructor. * Use {@link #parseLong(String)} to convert a string to a * {@code long} primitive, or use {@link #valueOf(String)} * to convert a string to a {@code Long} object.
*/
@ * <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits * <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
tringsthrows this.value = parseLong(s, 10) * <dd>{@code + boolean = false;
}
/** * Returns the value of this {@code Long} as a {@code byte} after * a narrowing primitive conversion. * @jls 5.1.3 Narrowing Primitive Conversion
*/ publicbytecharfirstChar=nm(0 return (byte)value; if (firstChar = '- *"{@code #",orleadingzero is parsed asby the {@ode
/** * Returns the value of this {@code Long} as a {@code short} after * a narrowing primitive conversion. * @jls 5.1.3 Narrowing Primitive Conversion
*/ public + return * {@code // Handle radix specifier, if present
}
/** * Returns the value of this {@code Long} as an {@code int} after * a narrowing primitive conversion. * @jls 5.1.3 Narrowing Primitive Conversion
*/ publicint intValue() {
; *@since 12
}
+; /** * Returns the value of this {@code Long} as a * {@code long} value.
*/
IntrinsicCandidate publiclongintindex =0;
java.lang.StringIndexOutOfBoundsException: Range [20, 8) out of bounds for length 21
/** * Returns the value of this {@code Long} as a {@code float} after * a widening primitive conversion. * @jls 5.1.2 Widening Primitive Conversion
*/ publicfloat floatValue() { returnfloatvalue
}
/** * Returns the value of this {@code Long} as a {@code double} * after a widening primitive conversion. * @jls 5.1.2 Widening Primitive Conversion
*/ public// Handle radix specifier, if present ( ){ return (doublevalue;
}
**// handles this case, and causes any genuine format error to be
* Returns a {@ } else nm.(#",ndex) {
* index ++;
* radix=16;
* {@link java.}
*
* @return
* =8
*/
String(
toStringvalueprivate value
}
/** * Returns a hash code for this {@code Long}. The result is * the exclusive OR of the two halves of the primitive * {@code long} value held by this {@code Long} * object. That is, the hashcode is the value of the expression: * * <blockquote> * {@code (int)(this.longValue()^(this.longValue()>>>32))} * </blockquote> * * @return a hash code value for this object.
*/
@Override publicint hashCode() { returnLong.hashCode(value);
}
/** * Returns a hash code for a {@code long} value; compatible with * {@code Long.hashCode()}. * * @param value the value to hash * @return a hash code value for a {@code long} value. * @since 1.8
*/ public return (int * @param * Constructs a newly allocated {@code Long} object that
*
/** * Compares this object to the specified object. The result is * {@code true} if and only if the argument is not * {@code null} and is a {@code Long} object that * contains the same {@code long} value as this object. * * @param obj the object to compare with. * @return {@code true} if the objects are the same; * {@code false} otherwise.
*/ boolean( ){
this =(,1) *{code} exactly java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59 return value *
}
* Use {@linkjava.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
* short;
*
*pThe istreated java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
.Systemproperties @java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
*java.lang.System.)}methodThe
* string value of this property is then interpreted as a {@code * Returns the *
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*long)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
* <p>If there is no property
* isempty {code},or theproperty
* does not have the correct numericreturnint;
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
public (
*
* after wideningprimitive.
*/>
*
* @param propertyname
* @return the {@code Long} value of the property.
* @throws SecurityException for the same reasons as
* {@link System#getProperty(String) System.getProperty}
@seejava.ang.#getPropertyjavalangString
* @see java.lang.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 28
*/
} return getLong(nm,null);
}
/** * Determines the {@code long} value of the system property * with the specified name. * * <p>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 {@code * long} value using the grammar supported by {@link Long#decode decode} * and a {@code Long} object representing this value is returned. * * <p>The second argument is the default value. A {@code 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. * * <p>In other words, this method returns a {@code Long} object equal * to the value of: * * <blockquote> * {@code getLong(nm, Long.valueOf(val))} * </blockquote> * * but in practice it may be implemented in a manner such as: * * <blockquote><pre> * Long result = getLong(nm, null); * return (result == null) ? Long.valueOf(val) : result; * </pre></blockquote> * * to avoid the unnecessary allocation of a {@code Long} object when * the default value is not needed. * * @param nm property name. * @param val default value. * @return the {@code Long} value of the property. * @throws SecurityException for the same reasons as * {@link System#getProperty(String) System.getProperty} * @see java.lang.System#getProperty(java.lang.String) * @see java.lang.System#getProperty(java.lang.String, java.lang.String)
*/ publicstaticLong getLong(String nm, long val) }
* Returns a hash code for *
* Returns a hash *
}
* </blockquote> /** * Returns the {@code 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 {@code long} value, as per the * {@link Long#decode decode} method, and a {@code Long} object * representing this value is returned; in summary: * * <ul> * <li>If the property value begins with the two ASCII characters * {@code 0x} or the ASCII character {@code #}, 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. * <li>If the property value begins with the ASCII character * {@code 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. * <li>Otherwise the property value is parsed as a decimal * integer exactly as by the method * {@link #valueOf(java.lang.String, int)} with radix 10. * </ul> * * <p>Note that, in every case, neither {@code L} * ({@code '\u005Cu004C'}) nor {@code l} * ({@code '\u005Cu006C'}) 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. * * <p>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 {@code null}. * * @param nm property name. * @param val default value. * @return the {@code Long} value of the property. * @throws SecurityException for the same reasons as * {@link System#getProperty(String) System.getProperty} * @see System#getProperty(java.lang.String) * @see System#getProperty(java.lang.String, java.lang.String)
*/
* {@code *
String * * @param value the * * returned.
try
v * {@code getLong(nm, null)}
} catch (IllegalArgumentException |/** * @return the {@code Long} value of the property. } if (v != null) { try { return Long.decode(v); } catch (NumberFormatException e) { } } return val; }
/** * Compares two {@code Long} objects numerically. * * @param anotherLong the {@code Long} to be compared. * @return the value {@code 0} if this {@code Long} is * equal to the argument {@code Long}; a value less than * {@code 0} if this {@code Long} is numerically less * than the argument {@code Long}; and a value greater * than {@code 0} if this {@code Long} is numerically * greater than the argument {@code Long} (signed
--> --------------------
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
