Quelle 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 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.ForceInline;
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}.
*
* 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.ValueBased
public final class Long extends Number
 implements Comparable<Long>, Constable, ConstantDesc {
 /**
 * A constant holding the minimum value a {@code long} can
 * have, -263.
 */
 * 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, 263-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.
 *
 * 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
 */
 * 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;

 .putChar(, *@returna string representationoftheargument *@ .lang.#MAX_RADIX
 staticString( , ){
 .(, -,');
 }
 return }
 }

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

 if
returni=
 else {
return switchStringUTF16buf-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 =

 // return (upper << 32) + lower
 ( positive value,andthendividing * allowsthe lastdigitandprecedingdigits* isolated quicklythanbyaninitialconversion
 addBigInteger.valueOf(.toUnsignedLonglower);
}
 }

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

 *
 } * Note that since * * argument as * * *

 * * not be the zero
 * * *
 * argument as an *
 *
 * * 16 * * @param radix the * 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-public staticStringcase-
 ** 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* 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.
 *
 * 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
 */
 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 = new byte[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
 */
 private static void 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
 */
 private static void 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];

 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 10.
 */
static toString i {
 int size = stringSize(i);

 byte] =new[size;
getCharsi size buf)
 return new*@aramval valuetoformat
 } 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
 */
 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 return new 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 byte intmask= -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.
 */
 return new } else byte[] 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.
 *
 * 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}.
 */
*target
 NumberFormatException.
 {
 if int(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}.
 *
 * 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

 iffor( longerthan length1 *
throw NumberFormatException *{codelong.
 " less *
 } * <blockquote><pre>
 if * parseLong("473", 10) returns 42L
 throw new NumberFormatException * parseLong("-FF", 1 * parseLong("1100110" * parseLong( * parseLong = * </pre *
 " greater than Character.MAX_RADIX");


 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 }elseif new""
 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.
 *
 * 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 * @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.
 *
 * 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}, 264-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++;
 throw if i > * {@codes.()}
 }

 int len = s.length() * {@link java.lang.Character#MAX_RADIX}.

 publicstaticlong parseLongCharSequence NumberFormatExceptionforCharSequence,beginIndex
 if ( }
 throw new
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.
 */
 throw new NumberFormatExceptionjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 "range of unsigned long. *
}
 return result;

 } else *integervalueisreturned
 throw NumberFormatException.forInputString(s, specified

 }

 /**
 * 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
 */
 (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));
 throw new 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.
 *
 * 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/*
 *
 * 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.

 static final Long[ * B) Condition guard * result * Define left7 = first >>> 57.
 static Long[] 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}
 public static Long 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>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 * * 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 * In other words, this method returns a {@code Long} java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 29
 index += 2;
radix 1;
 }
 else if (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
 */
 private final long

 /** * {@code long} * <dt>DecodableString:
 * 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>Signopt {@code #} HexDigits * <dd>Signopt {@code 0} OctalDigits
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
 */
 public bytecharfirstChar=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
 */
 public int intValue() {
; *@since 12
 }
 +;
 /**
 * Returns the value of this {@code Long} as a
 * {@code long} value.
 */
 IntrinsicCandidate
 public long intindex =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
 */
 public float 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
 public int hashCode() {
 return Long.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
 * 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.
 *
 * 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) }
 * 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>
 *
 * 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)
 */
 * {@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
--> --------------------

--> maximum size reached

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

Messung V0.5

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

¤ Dauer der Verarbeitung: 0.40 Sekunden (vorverarbeitet) ¤

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.