/*

* Copyright (c) 1994, 2021, Oracle and/or its affiliates. All rights reserved.

* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

*

* This code is free software; you can redistribute it and/or modify it

* under the terms of the GNU General Public License version 2 only, as

* published by the Free Software Foundation. Oracle designates this

* particular file as subject to the "Classpath" exception as provided

* by Oracle in the LICENSE file that accompanied this code.

*

* This code is distributed in the hope that it will be useful, but WITHOUT

* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

* version 2 for more details (a copy is included in the LICENSE file that

* accompanied this code).

*

* You should have received a copy of the GNU General Public License version

* 2 along with this work; if not, write to the Free Software Foundation,

* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

*

* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

* or visit www.oracle.com if you need additional information or have any

* questions.

*/

package java.lang;

import java.lang.annotation.Native;

import java.lang.invoke.MethodHandles;

import java.lang.constant.Constable;

import java.lang.constant.ConstantDesc;

import java.math.*;

import java.util.Objects;

import java.util.Optional;

import jdk.internal.misc.CDS;

import jdk.internal.vm.annotation.IntrinsicCandidate;

import static java.lang.String.COMPACT_STRINGS;

import static java.lang.String.LATIN1;

import static java.lang.String.UTF16;

/**

* 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

public final class Long extends Number

implements Comparable<Long>, Constable, ConstantDesc {

/**

* A constant holding the minimum value a {@code long} can

* have, -2⁶³.

*/

@Native public static final long MIN_VALUE = 0x8000000000000000L;

/**

* A constant holding the maximum value a {@code long} can

* have, 2⁶³-1.

*/

@Native public static final long MAX_VALUE = 0x7fffffffffffffffL;

/**

* The {@code Class} instance representing the primitive type

* {@code long}.

*

* @since 1.1

*/

@SuppressWarnings("unchecked")

public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long");

/**

* 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

*/

public static String toString(long i, int radix) {

if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)

radix = 10;

if (radix == 10)

return toString(i);

if (COMPACT_STRINGS) {

byte[] buf = new byte[65];

int charPos = 64;

boolean negative = (i < 0);

if (!negative) {

i = -i;

}

while (i <= -radix) {

buf[charPos--] = (byte)Integer.digits[(int)(-(i % radix))];

i = i / radix;

}

buf[charPos] = (byte)Integer.digits[(int)(-i)];

if (negative) {

buf[--charPos] = '-';

}

return StringLatin1.newString(buf, charPos, (65 - charPos));

}

return toStringUTF16(i, radix);

}

private static String toStringUTF16(long i, int radix) {

byte[] buf = new byte[65 * 2];

int charPos = 64;

boolean negative = (i < 0);

if (!negative) {

i = -i;

}

while (i <= -radix) {

StringUTF16.putChar(buf, charPos--, Integer.digits[(int)(-(i % radix))]);

i = i / radix;

}

StringUTF16.putChar(buf, charPos, Integer.digits[(int)(-i)]);

if (negative) {

StringUTF16.putChar(buf, --charPos, '-');

}

return StringUTF16.newString(buf, charPos, (65 - charPos));

}

/**

* 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

*/

public static String toUnsignedString(long i, int radix) {

if (i >= 0)

return toString(i, radix);

else {

switch (radix) {

case 2:

return toBinaryString(i);

case 4:

return toUnsignedString0(i, 2);

case 8:

return toOctalString(i);

case 10:

/*

* 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;

return toString(quot) + rem;

case 16:

return toHexString(i);

case 32:

return toUnsignedString0(i, 5);

default:

return toUnsignedBigInteger(i).toString(radix);

}

}

}

/**

* Return a BigInteger equal to the unsigned value of the

* argument.

*/

private static BigInteger toUnsignedBigInteger(long i) {

if (i >= 0L)

return BigInteger.valueOf(i);

else {

int upper = (int) (i >>> 32);

int lower = (int) i;

// return (upper << 32) + lower

return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).

add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));

}

}

/**

* Returns a string representation of the {@code long}

* argument as an unsigned integer in base&nbsp;16.

*

* <p>The unsigned {@code long} value is the argument plus

* 2⁶⁴ 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&nbsp;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&nbsp;16).

* @see java.util.HexFormat

* @see #parseUnsignedLong(String, int)

* @see #toUnsignedString(long, int)

* @since 1.0.2

*/

public static String toHexString(long i) {

return toUnsignedString0(i, 4);

}

/**

* Returns a string representation of the {@code long}

* argument as an unsigned integer in base&nbsp;8.

*

* <p>The unsigned {@code long} value is the argument plus

* 2⁶⁴ 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&nbsp;8) 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,

* 8)}.

*

* <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 octal digits:

*

* <blockquote>

* {@code 01234567}

* </blockquote>

*

* These are the characters {@code '\u005Cu0030'} through

* {@code '\u005Cu0037'}.

*

* @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 octal (base&nbsp;8).

* @see #parseUnsignedLong(String, int)

* @see #toUnsignedString(long, int)

* @since 1.0.2

*/

public static String toOctalString(long i) {

return toUnsignedString0(i, 3);

}

/**

* Returns a string representation of the {@code long}

* argument as an unsigned integer in base&nbsp;2.

*

* <p>The unsigned {@code long} value is the argument plus

* 2⁶⁴ 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&nbsp;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&nbsp;2).

* @see #parseUnsignedLong(String, int)

* @see #toUnsignedString(long, int)

* @since 1.0.2

*/

public static String toBinaryString(long i) {

return toUnsignedString0(i, 1);

}

/**

* 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 toUnsignedString0(long val, int shift) {

// assert shift > 0 && shift <=5 : "Illegal shift value";

int mag = Long.SIZE - Long.numberOfLeadingZeros(val);

int chars = Math.max(((mag + (shift - 1)) / shift), 1);

if (COMPACT_STRINGS) {

byte[] buf = new byte[chars];

formatUnsignedLong0(val, shift, buf, 0, chars);

return new String(buf, LATIN1);

} else {

byte[] buf = new byte[chars * 2];

formatUnsignedLong0UTF16(val, shift, buf, 0, chars);

return new String(buf, UTF16);

}

}

/**

* Format a long (treated as unsigned) into a byte buffer (LATIN1 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

*/

private static void formatUnsignedLong0(long val, int shift, byte[] buf, int offset, int len) {

int charPos = offset + len;

int radix = 1 << shift;

int mask = radix - 1;

do {

buf[--charPos] = (byte)Integer.digits[((int) val) & 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

*/

private static void formatUnsignedLong0UTF16(long val, int shift, byte[] buf, int offset, int len) {

int charPos = offset + len;

int radix = 1 << shift;

int mask = radix - 1;

do {

StringUTF16.putChar(buf, --charPos, Integer.digits[((int) val) & mask]);

val >>>= shift;

} while (charPos > offset);

}

static String fastUUID(long lsb, long msb) {

if (COMPACT_STRINGS) {

byte[] buf = new byte[36];

formatUnsignedLong0(lsb, 4, buf, 24, 12);

formatUnsignedLong0(lsb >>> 48, 4, buf, 19, 4);

formatUnsignedLong0(msb, 4, buf, 14, 4);

formatUnsignedLong0(msb >>> 16, 4, buf, 9, 4);

formatUnsignedLong0(msb >>> 32, 4, buf, 0, 8);

buf[23] = '-';

buf[18] = '-';

buf[13] = '-';

buf[8] = '-';

return new String(buf, LATIN1);

} else {

byte[] buf = new byte[72];

formatUnsignedLong0UTF16(lsb, 4, buf, 24, 12);

formatUnsignedLong0UTF16(lsb >>> 48, 4, buf, 19, 4);

formatUnsignedLong0UTF16(msb, 4, buf, 14, 4);

formatUnsignedLong0UTF16(msb >>> 16, 4, buf, 9, 4);

formatUnsignedLong0UTF16(msb >>> 32, 4, buf, 0, 8);

StringUTF16.putChar(buf, 23, '-');

StringUTF16.putChar(buf, 18, '-');

StringUTF16.putChar(buf, 13, '-');

StringUTF16.putChar(buf, 8, '-');

return new String(buf, UTF16);

}

}

/**

* 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&nbsp;10.

*/

public static String toString(long i) {

int size = stringSize(i);

if (COMPACT_STRINGS) {

byte[] buf = new byte[size];

getChars(i, size, buf);

return new String(buf, LATIN1);

} else {

byte[] buf = new byte[size * 2];

StringUTF16.getChars(i, size, buf);

return new String(buf, UTF16);

}

}

/**

* 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

*/

public static String toUnsignedString(long i) {

return toUnsignedString(i, 10);

}

/**

* Places characters representing the long i into the

* character array buf. The characters are placed into

* the buffer backwards starting with the least significant

* digit at the specified index (exclusive), and working

* backwards from there.

*

* @implNote This method converts positive inputs into negative

* values, to cover the Long.MIN_VALUE case. Converting otherwise

* (negative to positive) will expose -Long.MIN_VALUE that overflows

* long.

*

* @param i value to convert

* @param index next index, after the least significant digit

* @param buf target buffer, Latin1-encoded

* @return index of the most significant digit or minus sign, if present

*/

static int getChars(long i, int index, byte[] buf) {

long q;

int r;

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.

q2 = i2 / 10;

r = (q2 * 10) - i2;

buf[--charPos] = (byte)('0' + r);

// Whatever left is the remaining digit.

if (q2 < 0) {

buf[--charPos] = (byte)('0' - q2);

}

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.

*/

static int stringSize(long x) {

int d = 1;

if (x >= 0) {

d = 0;

x = -x;

}

long p = -10;

for (int i = 1; i < 19; i++) {

if (x > p)

return i + d;

p = 10 * p;

}

return 19 + d;

}

/**

* 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}.

*/

public static long parseLong(String s, int radix)

throws NumberFormatException

{

if (s == null) {

throw new NumberFormatException("Cannot parse null string");

}

if (radix < Character.MIN_RADIX) {

throw new NumberFormatException("radix " + radix +

" less than Character.MIN_RADIX");

}

if (radix > Character.MAX_RADIX) {

throw new NumberFormatException("radix " + radix +

" greater than Character.MAX_RADIX");

}

boolean negative = false;

int i = 0, len = s.length();

long limit = -Long.MAX_VALUE;

if (len > 0) {

char firstChar = s.charAt(0);

if (firstChar < '0') { // Possible leading "+" or "-"

if (firstChar == '-') {

negative = true;

limit = Long.MIN_VALUE;

} else if (firstChar != '+') {

throw NumberFormatException.forInputString(s, radix);

}

if (len == 1) { // Cannot have lone "+" or "-"

throw NumberFormatException.forInputString(s, radix);

}

i++;

}

long multmin = limit / radix;

long result = 0;

while (i < len) {

// Accumulating negatively avoids surprises near MAX_VALUE

int digit = Character.digit(s.charAt(i++),radix);

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 static long parseLong(CharSequence s, int beginIndex, int endIndex, int radix)

throws NumberFormatException {

Objects.requireNonNull(s);

if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {

throw new IndexOutOfBoundsException();

}

if (radix < Character.MIN_RADIX) {

throw new NumberFormatException("radix " + radix +

" less than Character.MIN_RADIX");

}

if (radix > Character.MAX_RADIX) {

throw new NumberFormatException("radix " + radix +

" greater than Character.MAX_RADIX");

}

boolean negative = false;

int i = beginIndex;

long limit = -Long.MAX_VALUE;

if (i < endIndex) {

char firstChar = s.charAt(i);

if (firstChar < '0') { // Possible leading "+" or "-"

if (firstChar == '-') {

negative = true;

limit = Long.MIN_VALUE;

} else if (firstChar != '+') {

throw NumberFormatException.forCharSequence(s, beginIndex,

endIndex, i);

}

i++;

}

if (i >= endIndex) { // Cannot have lone "+", "-" or ""

throw NumberFormatException.forCharSequence(s, beginIndex,

endIndex, i);

}

long multmin = limit / radix;

long result = 0;

while (i < endIndex) {

// Accumulating negatively avoids surprises near MAX_VALUE

int digit = Character.digit(s.charAt(i), radix);

if (digit < 0 || result < multmin) {

throw NumberFormatException.forCharSequence(s, beginIndex,

endIndex, i);

}

result *= radix;

if (result < limit + digit) {

throw NumberFormatException.forCharSequence(s, beginIndex,

endIndex, i);

}

i++;

result -= digit;

}

return negative ? result : -result;

} else {

throw new NumberFormatException("");

}

}

/**

* 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}.

*/

public static long parseLong(String s) throws NumberFormatException {

return parseLong(s, 10);

}

/**

* 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⁶⁴-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 static long parseUnsignedLong(String s, int radix)

throws NumberFormatException {

if (s == null) {

throw new NumberFormatException("Cannot parse null string");

}

int len = s.length();

if (len > 0) {

char firstChar = s.charAt(0);

if (firstChar == '-') {

throw new

NumberFormatException(String.format("Illegal leading minus sign " +

"on unsigned string %s.", s));

} else {

if (len <= 12 || // Long.MAX_VALUE in Character.MAX_RADIX is 13 digits

(radix == 10 && len <= 18) ) { // Long.MAX_VALUE in base 10 is 19 digits

return parseLong(s, radix);

}

// No need for range checks on len due to testing above.

long first = parseLong(s, 0, len - 1, radix);

int second = Character.digit(s.charAt(len - 1), radix);

if (second < 0) {

throw new NumberFormatException("Bad digit at end of " + 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) (first >>> 57);

if (guard >= 128 ||

(result >= 0 && guard >= 128 - Character.MAX_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.

*/

throw new NumberFormatException(String.format("String value %s exceeds " +

"range of unsigned long.", s));

}

return result;

}

} else {

throw NumberFormatException.forInputString(s, radix);

}

}

/**

* 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