SSL Long.java Sprache: JAVA

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

package java.lang;

import.lang.annotation.;
importjavalang.nvoke;
importjava.invoke;
import javaimport java.lang.constant.Constable
javamath*
import java.util.Objects javamath*java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
* * *

 * {@code * * with a * @ *
import * class * @return * {@ * @see java * use instances */
import....IntrinsicCandidate*methods( @ {linknumberOfTrailingZeroslong onmaterial HenryS *Delighti, *

import @ authorJoseph * since
importtatic..String;;
import final radix=1)

/** /**
* 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}.
*
* 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}.
*
* 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.
*
* 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 Hacker's
* Delight, (Addison Wesley, 2002).
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Josh Bloch
* @author Joseph D. Darcy
* @since 1.0
*/
@jdk.internal
 (negative{
implements<>,ConstableConstantDesc{
 /**
 * A constant holding the minimum value a {@code long} can
 * have, -263.
 */
 @Native public static final long MIN_VALUE = 0x8000000000000000L;

 /**
 * A constant holding the maximum value a {@code long} can
 * have, 263-1.
 */
 @Native public *have 2<>63/sup-1

 /**
 * The {@code Class} instance representing the primitive type
 * {@code long}.
 *
 * @since 1.1
 */
 @
 /**

 /**
 * Returns a string representation of the first argument in the
 * radix specified by the second argument.
 *
 * 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.
 *
 * 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.
 *
 * 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
 =1;
 if uf-charPos=';
 return(i;

 if (COMPACT_STRINGS) { }
 byte]buf=newbyte65];
 int charPos = 64;
 booleannegative=(i <0)

if){
 i =-;
 ns a string representation of the first argument in the

 while ( *
 buf[charPos--] * or larger than {@code Character * {@code 10} is *
 *resultis ASCII (@code'u005Cu002d') ,no appears .
 }
 buf[charPos] = (byte) * represented by a single zero character {@code '0'}

 * the representation of the magnitude will not negative=( <0;
 [ *{code13568java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 }StringUTF16buf string the seejavalangCharacter
 } public toStringiint
 returnputChar- '
}

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 [] buf , no sign*
 {code'' * thefirstcharacter of the representation notbe *
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if(negative {
 i = -i;
 }
 while (i int =6;
StringUTF16(,, see#(long )
 i = */
 }

 (negative{ =-;
 putChar -,'

 while * We can *
 }

 /**
 * Returns a string representation of the first argument as an
 * unsigned integer value in the radix specified by the second
 * argument.
 *
 * 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.
 *
 * Note that since the first argument is treated as an unsigned
 * value, no leading sign character is printed.
 *
 * 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 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
 */
 * Return * *
if =)
 returnif
 {
 }

 String(long ,int) {
 case 8 -> toOctalString(i);
 1 - {
/*
 * 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.
 */
 (Integer())
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 yield(ASCII inhexadecimal*leading@code}*
 }
 case 16 - * Long#parseUnsignedLong * 16)} *
 case * otherwise, * unsigned magnitude will not*following areusedas digits
default- toUnsignedBigInteger(*{code023578abcdef * </blockquote>
 * These
 }
 }

 /** i/radix
 * Return a BigInteger equal to the unsigned value of the
 * argument.
 */
 private *ifnegative*<blockquote
 {linkjavautil ofbytearraysandprimitivestoreturnastringoradding an{linkAppendable}.
 return BigInteger.valueOf(i);
 else {
 int upper = * a delimiter, prefix, and suffix.
 lower=(int ;

 // return (upper << 32) + lower
 return (BigInteger * (base 16).
 add(BigInteger.valueOf * @see # * argument. * *
 }
 }

 /**
 * Returns a string representation of the {@code long}
 * argument as an unsigned integer in base 16.
 *
 * The unsigned {@code 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 {@code 0}s.
 *
 * 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)}.
 *
 * 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
 */
 public 4>toUnsignedString0i 2;
return(i,4;
 }

 * Returns a string representation of the {@
 argumentasanunsigned integer basenbsp8
 Long#parseUnsignedLongStringintLongparseUnsignedLong*positivevalue then by5
 * ).
 *
 * * If*toBigInteger.
 * ASCII digits in octal (base */
 * {@code 0}s.
 *
 * The value of the argument can be recovered from the returned
 * string {@code s} by calling {@link
 * Long#parseUnsignedLong(String, int) *single zerocharacter{@ode ''}(code\u005Cu0030'};
 * 8}.
*
 *}
 * 16->toHexStringi)
 otherwisethe characterof representationofthe
 * - toUnsignedBigInteger().(radix;
 * following characters are used as octal digits:
 *
 * <blockquote>
 * {@code 01234567}
 * </blockquote>
 *
 * These are the characters {@code '\u005Cu0030' }
 *}
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
*{ }tobeconvertedtoa string
 * @return if(
 * value represented by the argument in octal (base 8).
 * @see #parseUnsignedLong(String, int)
 * @see #toUnsignedString(long Thesearethe characters{@code'u005Cu0030} through
*since1.
 */
 public param a{code} beconvertedto.
 (,3;
 }

 /**
 * Returns a string representation of the {@code long}
 * argument as an unsigned integer in base 2.
 *
 * The unsigned {@code 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
 * {@code 0}s.
 *
 * 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)}.
 *
 * 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
 */
 * leading {@ * characters * * ' *java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 6
 return () />
 }

 /**
 * 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 * {@code Long.toHexString
 * @apiNote
 int mag = Long * of byte arrays and primitives to return a string or adding * {@code HexFormat} formats and parses uppercase or lowercase hexadecimal characters / assert shift>0&&shift<5:" shiftvalue;
int base1)
 * @see # int chars =. *see#(long)
 [*int
formatUnsignedLong0,shift ,0, *@ an unsignedstring oftheargument
 return * @since 1. */
 } {
 bytereturn (i, 1);
 formatUnsignedLong0UTF16( // assert shift > 0 && shift <=5 : "Illegal shift value";
 (, );
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5


 /** } else {
 * 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 negativepositive expose Long that param bytebuffertowriteto
* number java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 int radix = *@ ,after leastsignificantjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
int radix ;
 do {
 [-] = (byte)Integer.digits[((int)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 31
 val >>>= shift do{
 } (charPos >offset);
 }

 /** while( >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
 */
 *
 intcharPos = 10
 radix 1< i=q
 int mask = radix <shift
 do intq2;
 while (i2 <= -100 q2 = i2 /10
val>= []=IntegerDigitOnesbuf-charPos =IntegerDigitTensr;
 } while (charPos // We know there are at most two digits left at this point.
 }

 static String fastUUID( buf[--charPos] = Integer.DigitTens }
 if (COMPACT_STRINGS buf[--charPos] = (byte)' }
 byte }
 (lsb
 if (COMPACT_STRINGS) {
 formatUnsignedLong0 byte * @param x long value
 formatUnsignedLong0(msb >>> 16, * @implNote formatUnsignedLong0(lsb >>> 48, 4, buf, 19, 4);
 formatUnsignedLong0(msb >>> 32, 4, buf, formatUnsignedLong0(msb >>> 32, 4, buf, 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 buf[23] = '-';
 buf[18 formatUnsignedLong0UTF16(msb, 4, buf, 14, formatUnsignedLong0UTF16(msb >>> 16, 4, buf, 9, 4); formatUnsignedLong0UTF16(msb >>> 32, 4,
 buf[13] = '-';
 []

 return new String(buf, LATIN1);
}else
 byte[] buf = new byte[72] java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 byte[] buf [;
 (lsb>>4, , ,
 formatUnsignedLong0UTF16 return +java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 (msb>>1,4 buf , )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 (msb >>3, , buf , );

 /**returnnewStringuf,UTF16java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 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 10.
 */
 public static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
int (;
 if (COMPACT_STRINGS) {
byte]buf=new[size;
 getChars(i, size, buf);
 return new String(buf, LATIN1); * {@code L} or {@code l} may * radix greater than or equal to 22.
 } }
 byte
 .getCharsi
 returnnew(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 backwardsfrom there * @codelong
 return*@ <>Examples:


 **
 * parseLong*long
 array . Thejava.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 37
 * the buffer * parseLong("Hazelnut", 10) throws * parseLong"Hazelnut, 3) 15699546L
 * * @param s the {@code String} containing the
 * backwards from there.
 * * @param radix the radix to be used while parsing {@code *@param i to
 *@implNote methodconverts inputsintonegative
 * values, to cover the Long.MIN_VALUE case. Converting * parsable {@code long}.
 * (negative to publicstatic long parseLong @param , Latin1-encoded
 *long
 *
 /
 *staticintgetCharslong,indexbyte )
 * @ thrownewNumberFormatException r;
 * @return index of the most significant digit or minus sign, if present
 */
 staticintgetCharslongi intindex []
 long
 r;
 int if!negative thrownewNumberFormatException""+

 boolean }
 if if ( Character.)
 newNumberFormatException"radix "+


 java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
 while (i <= Integerinti ,len= (i =Integer
q int*0-)
 r
 q;
 buf[- firstChar s.(0;
 [-charPos =Integer.[]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 }

 // Get 2 digits/iteration using ints
intq2
 q2
 while (int =}elseiffirstChar!+) {
 =i2 10;
r =( *100 -i2
 i2 = q2;
 [- .forInputStrings,radix
 i2=;
 }

 // We know there are at most two digits left at this point.
buf-] .-;
 if (i2}
 buf +


 if ( [long=;
 buf-] 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.
 */
 }
 int d = 1;
 if (x >= 0) throwbuf-charPos ()'';
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 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.
 *
 * 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.
 *
 * 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>
 *
 * 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}.
 */
 *
 throws NumberFormatException
 {
 if (s == null * '+'} ({@code '\ NumberFormatException. * longer than length 1.
 * <, )
 }

 . { * Examples:
 throw new NumberFormatException( *parseLong0,1)returns0
 "lessthanCharacterMIN_RADIX)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 }
 if />/>
 throw new NumberFormatException(" *@ sthe @codeString the
 .)
 }

 boolean negative = false;
 int i = 0, len digitecifiedradix
it= LongMAX_VALUE

 (en 0
 char firstChar = s.charAt publicendIndex )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
ifs =null {
 thrownew NumberFormatException" parse string);
 = trueresult*radix
 limit = Long.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifthrow (radix radix+
 lessthanCharacterMIN_RADIX)
 }

 if (len == 1) { // Cannot have lone "+" or "-"
 NumberFormatExceptionforInputStrings radix;
 }
 i++;
 }
 thrownew( ++;
 long result=0;
 }
 // Accumulating negatively avoids surprises near MAX_VALUE
 digit=CharacterdigitscharAti)radix;
 if (digit throw NumberFormatException(";
 throw}
 }
 result*radix
 * Parses the string argument as a
 throw.forInputString(, *thatthefirstcharactermay be *(@code\u005Cu002D' toindicatea 0B}) to
 }
 result= *indicateapositivevalue Theresulting @codelongvalueis
 } onglimit=-.MAX_VALUE;
 return
 }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}.
 *
 * 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( * }
 throws NumberFormatException { * }
 Objects.requireNonNull(s);
 Objects.checkFromToIndex(beginIndex, endIndex, s.length());

 if (radix < Character. * An exception of type {@code int digit = Character. * thrown if any of the following situations occurs:
 throw new NumberFormatException("radix }
 " less than Character.MIN_RADIX");
 }
 if (radix > Character.MAX_RADIX) {
 throw } *
 " greater than Character.MAX_RADIX");
 }

 return negative ? result : -result;
 int i = beginIndex;
 long limit = -Long.MAX_VALUE;

 if (i <
 char firstChar = s.charAt(i);
 if (firstChar < '0') *
 if (firstChar == '-') * @param s the {@code String} containing the unsigned integer
 negative = true;
 limit = Long.MIN_VALUE;
 } else if (firstChar != '+') {
 throw NumberFormatException.forCharSequence(s, * * * @param endIndex the ending index, exclusive.
 endIndex static * @return signed @code long representedbythesubsequence specifiedradix
 }

 }
(= length. * @throws * contain a parsable {@code long} in the * {java.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 9
throw.(s ,
 endIndex, i);
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 long (.format"
 =;
 while (i < endIndex) {


 if digit =0 <8 java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
 throw NumberFormatException. " thanCharacterMIN_RADIX";
 endIndex, i) if radix>CharacterMAX_RADIX
 }
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 throw.forCharSequences,beginIndex
 ,i;
}
 ifsecond )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 result -= digit;
 ( endIndex
 return firstChar =charAti)
 } else{
 throw new if firstChar='- Testleftmostbitsofmultiprecisionextension offirstradix
 }


 /**
 * 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.
 *
 * 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}.
 */
 *
 return parseLong(s, 10);
 }

 * Given first = (left7 * 2^57) + (first result -= digit;
 * Parses the string argument as an return * Thus if radix*left7 < 92, radix <= 36, and second < 36,
 * radix specified by the }
 * maps the values usually associated with negative numbers to
 * positive numbers larger * C) Condition 92 <= * Parses the string argument as a signed decimal {@code long}.
 * * so that first*radix + second >= 92*2^57 + 0 > 2^63
 * The characters in the string must * ASCII plus sign * D) Condition guard < 128:
 * specified radix (as determined by whether {@ * returned, exactly * so
 * java.lang.Character#digit(char, * # *
 * value) * ({@code '\u005Cu004C'}) nor {@code l}
 * sign * radix * of the string as a type indicator, as would be permitted in
 *
 * * @param s * C and D combined imply the mathematical result
 * An exception of type { * bound is therefore negative as a signed long * decimal * upper * @throws NumberFormatException if the * parsable * signed long overflows *

 * <ul>
 * <li>The first argument is { * radix specified by the second argument. An unsigned integer * maps the values usually associated with negative numbers to
 * length zero.
 *
 *
 * * value), except that the first character may be an ASCII}
 *larger .
 *
he
 * radix, except that the first character may }
 * {@code '+'} ({@code '\u005Cu002B'}
 * string is longer than length 1.
 *
 * * the specified {@code radix} * {@link java.lang.Character#MIN_RADIX} or
 * largest unsigned {@code *
 *
 * </ul>
 *
 *
 * @param * @param s the {@code CharSequence} containing the unsigned
 * representation to be parsed
 * @param radix the radix to be used while * @param endIndex the ending index, exclusive.
 * @return * string is longer than length 1.
 * argument in the specified radix.
 * @throws NumberFormatException if *
 * does not contain a parsable {@code *
 * @since 1.8
 */
 public static long parseUnsignedLong(String s, int radix)
 throws * @throws NumberFormatException if the {@code CharSequence} does not
 if (s == null * * {@code radix}, or if {@code radix} * @since 1.8
 new(" parsenullstring";
 }

 len=*
 if (len > publicstatic longparseUnsignedLong(harSequence , beginIndex, intendIndex,int radix)
 char firstChar = s.charAt(0);
 iffirstChar ==''){
 throw new
 int = slength)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 start beginIndexl -beginIndex
 ( =-){
 throw new
 (radixNumberFormatException.format(Illegal +
 return parseLong(java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 35
}

 // No need for range checks on len due to testing above.
 }else {
 int .subSequence,start ))
 if (second < 0 len<1 |
throwNumberFormatException"at of" ;
 }
 long result = first * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

first (,start, + ,radixjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * Test leftmost thrownew ( ){
 * resultssubSequencestart );
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 * int guard * Test
 * overflow is tested by * Test leftmost bits of multiprecision extension of first*radix
 * guard < 92, 92 <= guard < 128, and 128 <= guard, * overflow is tested by splitting guard in the ranges
 * 92 = 128 - Character * on a value which does not include a prime factor in the legal
 * on a value which does not include a prime factor in the intguard=radix*(int ( >>>7;
 * radix range * guard < 92, 92 <= guard result> 0& = 18. Note guard take
 */
 int guard */
 if(guard> 128|
 (result >= 0 && guard f( >=18 |
/*
 * 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 * upper bound is too small to overflow again after the * signed long overflows to positive above 2^64 - 1. Hence
 "range of unsigned long.", java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
 return;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 throw NumberFormatException elsejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 } * }
 }

 /**
 * 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}.
 *
 * 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
 */
 public static longjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * with the radix given by the second argument. first
 Objects. Objects.requireNonNulls);
 ObjectscheckFromToIndexbeginIndex endIndex * parseLongjavalang, int. The*{@odeLong thatrepresents {@ode }

 intstart*<>In words this returnsa{codeLong objectequal * to the value of:

 iflen> 0 {
 charfirstChar=scharAtstart;
( =='' {
 throw new NumberFormatException( * @param s the string to be parsed
 "on unsigned string %s.", * @return a {@code Long} object holding the value newNumberFormatExceptionString* by stringargumentinthespecified
 } else {
 if (len */
 (radix==1 ( <1|// Long.MAX_VALUE in Character.MAX_RADIX is 13 digits
s )
 }


 long first
 int second=Character(.(start+len -1,);
 (second< 0
hrowNumberFormatException digit
 s.subSequence(start, start + len))*interpreted a decimal@ longjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}
 result * + new" of"


 first pother, @ Longequaltothe :
 * for
 * {@code * for * </blockquote>
 * * @param s the string to be parsed.
 * overflow is tested by splitting guard * guard < 92, 9 * represented by the string argument.
 * as a {@code long}.
 * 92 = 128 - Character.MAX_RADIX. /
 = radix * (int) (first >>>57);
 if(guard > 12 ||
 /
 int guard}
 if ( privatestatic*Forpurposes of exposition,the statements
 (result >= 0 && guard >= 128 - Character * subject to overflow.
 /*
 * 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.
 */
throwNumberFormatExceptionStringformat"
 "range of unsigned long.", s.subSequence(start,}
 }
 return result;
 }
 } else {
 throw
 }
 }

 /** result;
 * 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
 */
 return ()
 return parseUnsignedLong}
 }

 /**
 * 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.
 *
 * 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}.
 */
 * * {@code long} in the radix specified by the second * This sequence of * argument, exactly as if the arguments were given to the {@link
 return Long.valueOf(parseLong(s, radix));
 }

 /**
 * Returns a {@code Long} object holding the value
 * of the specified {@code String}. The argument is
 * interpreted as representing a signed decimal {@code long},
 * exactly as if the argument were given to the {@link
 * #parseLong(java.lang.String)} method. The result is a
 * {@code Long} object that represents the integer value
 * specified by the string.
 *
 * 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}.
 */
 public ;
 {index+
 return }else firstChar =' *#parseLongjavalangString} method result a
 }

private LongCachejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 private LongCache() {}

 static final Long[] cache;
 static Long[] archivedCache;

 static {
 int =6java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 taticLong valueOfString s)
 {
 if (archivedCache ==null | archivedCache.length != size {
 Long[] c = new } radix =1;
 long value = -12 elseif (. index
 +
 i new(value+;
 }
 archivedCache = c;
 }
 =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
public Longlong)
 final int offset = 128;
 if (l >= -128 = ;
 return LongCache.cache[(int)l + offset];
 }
 return new Long(l);
 }

 /**
 * Decodes a {@code String} into a {@code Long}.
 * Accepts decimal, hexadecimal, and octal numbers given by the
 * following grammar:
 *
 * <blockquote>
 * <dl>
 * <dt>DecodableString:
 * <dd>Signopt DecimalNumeral
 * <dd>Signopt {@code 0x} HexDigits
 * <dd>Signopt {@code 0X} HexDigits
 * <dd>Signopt {@code #} HexDigits
 * <dd>Signopt {@code 0} OctalDigits
 *
 * <dt>Sign:
 * <dd>{@code -}
 * <dd>{@code +}
 * </dl>
 * </blockquote>
 *
 * DecimalNumeral, HexDigits, and OctalDigits
 * are as defined in section {@jls 3.10.1} of
 * <cite>The Java Language Specification</cite>,
 * except that underscores are not accepted between digits.
 *
 * 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 static Long * <dt> * Use {@link * <dd>Signopt * {@code * <dd>Signopt< * to convert a string to a {@code * *
 int *
 int index ) NumberFormatException{
negative
 longjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 if (nm.isEmpty())
 throw new NumberFormatException("Zero length string");
 .charAt0) *
 * The sequence of characters following an optional
if= } )is thec
 negative = true; * a {@link NumberFormatException} will be thrown. The result is
 index++;
 } * negated if */
index+;

 if (nm.startsWith("0 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 index + * a narrowing primitive conversion.
 radix = 16;
 */ * contain a parsable {@code long}.
 else if (nm. return (int)value since1
+
 radix = 16;
 }
 else if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 indexlongresult
 radix = 8;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

 if
 throw new NumberFormatException if(();

 try
 result = parseLong(nm, index * Returns the } if ( = +'
resultnegative -
 catchNumberFormatException java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43


 // rethrown.
 String constant = negative (.",){
: ;
 result = parseLong(constant, radix);

 return result;
 }

 /**index++
 * The value of the {@code Long}.
 *
 * @serial
 */
privatelong;

 /**
 * 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=,
public )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
thisvalue=;
}

 /**
 * 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.
 */
 @Deprecated(since=" this.alue=valuejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 public equalsObjectobj
 .value parseLongs 0 @ long valuein exactly themannerusedbythe
 }

 /**
 * Returns the value of this {@code Long} as a {@code byte} after
 * a narrowing primitive conversion.
 * @jls 5.1.3 Narrowing Primitive Conversion
 */
 public byte byteValue() {
 return (byte)value;
 }

 /**
 * Returns the value of this {@code Long} as a {@code short} after
 * a narrowing primitive conversion.
 * @jls 5.1.3 Narrowing Primitive Conversion
 */

return()value
 }

 /**
 * Returns the value of this {@code Long} as an {@code int} after
 * a narrowing primitive conversion.
 * @jls 5.1.3 Narrowing Primitive Conversion
 */
 public int intValue( *property propertiesareaccessiblethroughthe{link
 returnint;
 #getProperty(java.langString . java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

 /**
 * Returns the value of this {@code Long} as a
 * {@code long} value.
 */
 @IntrinsicCandidate
lic (java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 return*
 }

/**
 * Returns the value of this {@code Long} as a {@code float} after
 * a widening primitive conversion.
 * @jls 5.1.2 Widening Primitive Conversion
 */
 public float floatValue this {@code *
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

 /**
 * Returns the value of this {@code Long} as a {@code double}
 * after a widening primitive conversion.
 * @jls 5.1.2 Widening Primitive Conversion
 */
*paramnm .
 (double
 }

 /**
 * Returns a {@code String} object representing this
 * {@code Long}'s value. The value is converted to signed
 * decimal representation and returned as a string, exactly as if
 * the {@code 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 * @ *base 1.
 return toString(value); public StringtoString( java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 /**
 * 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.
 */
 * Long } @ }object
 public int hashCode( *

 } * * Determines the {@code long} value of the system * with the specified * @throws SecurityException for *

 /**
 * 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
 */
 {
 return * <blockquote>
 } * </blockquote>


 * * @throws SecurityException for the same reasons as
 * @see java.lang. if (v != null) {
 */
me{codelong c ( e){
 *
 * }
 * @return {@code true} if the objects are the same;
 * {@code }
 */
 public * Determines the {@code * @param anotherLong the {@code Long} to be
 if (obj instanceof * equal to * property. System properties are accessible through the {@link
 return * than the * long} value using the grammar supported by {@link Long#decode * and a {@code Long} object representing this value *
 }
 return false;
 }

 /**
 * Determines 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 using the grammar supported by {@link Long#decode decode}
 * and a {@code Long} object representing this value is returned.
 *
 * If there is no property with the specified name, if the
 * specified name is empty or {@code null}, or if the property
 * does not have the correct numeric format, then {@code null} is
 * returned.
 *
 * In other words, this method returns a {@code Long} object
 * equal to the value of:
 *
 * <blockquote>
 * {@code getLong(nm, null)}
 * </blockquote>
 *
 * @param nm property name.
 * @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)
 */
 public static Long getLong(String * {@code 0} followed by another character, it is parsed as
 * <li>Otherwise the property value * integer exactly as by the method
 }

 /**
 * Determines 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 using the grammar supported by {@link Long#decode decode}
 * and a {@code Long} object representing this value is returned.
 *
 * 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.
 *
 * 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)
 */
 public static Long getLong(String nm, long val) {
 Long result = Long.getLong(nm, null);
 return (result == null) ? Long.valueOf(val) : result;
 }

 /**
 * 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>
 *
 * 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.
 *
 * 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)
 */
 public static Long getLong(String nm, Long val) {
 String v = null;
 try {
 v = System.getProperty(nm);
 } catch (IllegalArgumentException | NullPointerException e) {
 }
 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
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5

¤ 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.0.34Bemerkung: ¤

*Bot Zugriff

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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.