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

* 2 along * Inc. * Please contact Oracle, 500 Oracle * or visit * questions */

javaannotationNative ...MethodHandles
.lang.MethodHandles
importconstant;
import import..;
import..;
import java.util.Objects;
import java.util.Optional;

import jdk.internal.misc.CDS;
import * The {@code Class} instance representing the primitive * {@code * @since */
import Class<>TYPE(<LongClass(long;

import * If the * result is the ASCII minus * ({@code * negative, no *
import static * * the * character. *
 * </blockquote>

/** * These are {@code '\u005Cu0030'} through
* 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
*/
sjava
public )
implements
 /**
 * A constant holding the minimum value a {@code long} can
 * have, -263.
 */
 @Native * * In * a {@code long} to a { * long}, as * with *

* * * methods * {@linkon material fromint 4
*@ java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
,sup<>.
 */
 * The {@ * {@code long}.

 /**
 * The {@code Class} instance representing the primitive type
 * {@code long}.
 *
 * @since 1.1
 */
 @SuppressWarnings("unchecked" * {@code * If the first argument *result *(@ \ *negativeno
public . of.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /** i
 * 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
 */
 long radix
 toStringUTF16StringUTF16bufcharPos-
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 *bytebuf*valuenoleading *
 haracter@ 0} characterofthe * bethe

 *
 byte[] buf = new * @param if !){
charPos 4
 * @return an unsigned string .putCharbuf charPos-- *@ toString,int

if)
 =i
 switch.(,- '

case>( )
 >()
 0 >java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Range [35, 37) out of bounds for length 13
 * * * If * character { * the first * are the same as {@link #toString(long, int) toString}.

 if (negative) {
 * @return an unsigned string * @see } * }

 (>0
}
 return BigInteger else{


ic toStringUTF16longi radixjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
return* the more java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 * argument as an *
 boolean * 2 * toString * digits { 0 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 characters used hexadecimal:
 i * <blockquote> > toUnsignedBigInteger @ 02469}
 }
 while

 i= ;
 }
 * *
 ( />
 *The@ ..* to @ Appendablejava.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
 }
 returnint )i
 }

 /**
 * 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
 */
 * <blockquote>
 if (i *<blockquote
return are @ @ 'u005Cu0039} * @ '\u005Cu0066} *the {link java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21
 elselink.util}class formatting and
 return switch {code}*{code}formatsparsesuppercase* leading byte *a,prefix java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 * @see * @see #toUnsignedString * @since 1. */
 (,)
 toUnsignedString0 )
 case case
/*
 * 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.
 */
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 18
long=)
 yield toString(quot) + rem; *

case >(;
 case 32 -*, first ofthe
default>toUnsignedBigIntegeritoString)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 ;
 }

*
 /***followingcharactersare as digits:
 * Return a BigInteger equal to the unsigned value of the
 * argument.
 */
 private* param code be string
 i if (i >
 return* 0
else@ codelong ajava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 2>4sup * . value*ASCIIdigits binarybase*{codejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 intlower* #parseUnsignedLongString )Long( 2.


 returntoUnsignedString0i * notbe { ''(codeu005Cu0030) code

 } * Returns a string * argument as an unsigned integer in base *
 }

 /**
 * 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
 */
 (,,0;
 (buf ATIN1
 }

byte= [ ]
 * ,,0chars
 as &;.
 *

 *
/*
 * ASCII digits in octal (base 8) with no extra leading
 * {@code 0}s.
 *
 <> java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 * string {@code s} by calling {*param binary
 * param byte buffer to write to
 * 8 @paramoffsetthe in java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
*
 * +len
 int <shift
 * radix ;
 * unsigned buf[--charPos byte.[()val&]java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 * following * @param shift the log2 of the base * @param buf the * @param offset the offset in * @param len the number java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * <shift
 mask -;
 *do{
 * </blockquote>StringUTF16,-,Integerdigits()val mask)
 *
val>=shift
 * {} ( )
 *
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
return of theunsigned{ }
 * byte[] bunew[6
 * @see #parseUnsignedLong(String, int)
 * @see #toUnsignedString(long, int)
 * @since (lsb>> 8 4 ,1,)
 /
 formatUnsignedLong0 > 6 ,,94
 return( > 24,08
 }

 * 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 *
 return * @return a string representation * public String(long){
 }

 byte[buf byte]
 (,,;
 @ the java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 * @java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 9
 */
 * and returned as a string exactly as if the argument and radix * 1 * * @param i (val , buf , return representation .

 int mag = Long.SIZE - Long.numberOfLeadingZerosreturn newStringbufUTF16;
 int/**
 if (COMPACT_STRINGS) {
 byte[] buf = new byte[chars];
 formatUnsignedLong0(val, shift, buf, 0, chars);
 return new String(buf, LATIN1);
 } else {
 byte[] buf = new byte[chars * 2];
 formatUnsignedLong0UTF16(val, shift, buf, 0, chars);
 return new String(buf, UTF16);
 }
 }

 /**
 * Format a long (treated as unsigned) into a byte buffer (LATIN1 version). If
 * {@code len} exceeds the formatted ASCII representation of {@code val},
 * {@code buf} will be padded with leading zeroes.
 *
 * @param val the unsigned long to format
 * @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary)
 * @param buf the byte buffer to write to
 * @param offset the offset in the destination buffer to start at
 * @param len the number of characters to write
 */
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 long, radixjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 int radix = 1 << shift;
 int mask = radix - 1;

 while>

 } charPos)
 }

 /**
 * 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
 */
 q=i/0;
 int int = < q;
int =1< ;
 int mask = radix - 1
 do {
 nt = 0;
 val >>> i2 = >>buf--charPos . [-] .[]
 } while java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 }

 formatUnsignedLong0/**
 if (COMPACT_STRINGS) {
 byte[] buf = new byte[36];
 formatUnsignedLong0(lsb, 4, buf, 24, 12);
 formatUnsignedLong0(lsb >>> 48, 4, buf, 19, 4);
 formatUnsignedLong0(msb, 4, buf, 14, 4);
 formatUnsignedLong0(msb >>> 16, 4, buf, 9, 4);
 formatUnsignedLong0(msb >>> 32, 4, buf, 0, 8);

 buf[23] = '-';
 buf[18] = '-';
 buf[13] = '-';
 buf[8] = '-';

 return new String(buf, LATIN1);
 } else {
 byte[] buf = new byte[72];

 formatUnsignedLong0UTF16(lsb, 4, buf, 24, 12);
 formatUnsignedLong0UTF16(lsb >>> 48, 4, buf, 19, 4);
 formatUnsignedLong0UTF16(msb, 4, buf, 14, 4);
 formatUnsignedLong0UTF16(msb >>> 16, 4, buf, 9, 4);
 formatUnsignedLong0UTF16(msb >>> 32, 4, buf, 0, 8);

 StringUTF16.putChar(buf, 23, '-');
 StringUTF16.putChar(buf, 18, '-');
 StringUTF16.putChar(buf, 13, '-');
 StringUTF16.putChar(buf, 8, '-');

 return new String(buf, UTF16);
 }
 }

 /**
 * Returns a {@code String} object representing the specified
 * {@code long}. The argument is converted to signed decimal
 * representation and returned as a string, exactly as if the
 * argument and the radix 10 were given as arguments to the {@link
 * #toString(long, int)} method.
 *
 * @param i a {@code long} to be converted.
 * @return a string representation of the argument in base 10.
 */
 public static String toString(long i) {
 size=()
 if (COMPACT_STRINGS) {
 newsize
 getCharsformatUnsignedLong0UTF16 > 8 4buf }
 19+;
 else{
 byte[] buf = new byte[size *formatUnsignedLong0UTF16 > 6 ,,94;
 StringUTF16.getCharsformatUnsignedLong0UTF16msb> 24 ,08;
 ( ;
 }
 }

 /**
 * Returns a string representation of the argument as an unsigned
 * decimal value.
 *
 * The argument is converted to unsigned decimal representation
 * and returned as a string exactly as if the argument and radix
 * 10 were given as arguments to the {@link #toUnsignedString(long,
 * int)} method.
 *
 * @param i an integer to be converted to an unsigned string.
 * @return an unsigned string representation of the argument.
 * @see #toUnsignedString(long, int)
 * @since 1.8
 */
 public static String toUnsignedString( * ({@code ' size =stringSizei)
 return [ byte]java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40


 *StringUTF16(
 String,)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 * character array buf * decimal value. *
 * * * and returned as a java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 6
 * digit at the * @return * '+'} ( * @ * longer than length 1.
* fromthere* { }.
 *
 @*pExamples
 *}
 /*
 .
 *characterarraybuf * * parseLong * parseLong("("6returns30449java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
valueconvert
 * This positive java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
*bufbuffer
 * @returnthrows .
*
static ( [
 long q;
intjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 int ( , ,byte

 ;
()throwNumberFormatException +
 i -i;
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 // Get 2 digits/iteration using longs until quotient fits into an int
(MIN_VALUE
 q = i / 100;
 ()(q 1)-java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 i = q;
buf-]=.[]
 buf[--charPos] = Integer.DigitTens[r];
 }

 ;
int
 i2 if( '
 q2= /0
 q2 0) ;
 r = (q2 *buf-NumberFormatExceptionforInputString ;

 buf
 buf[--charPos .buf- DigitOnesi2
 }

 // We know there are at most two digits left at this point.}
buf result0
( < -]'java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 * Returns if (digit < 0 || *
 }

 if (negative) { if (result * but values are biased throw * wins. The }
 [-]=byte-
 } }
 return charPos;
 }


 * for (int i = 1; if (x > p)
 * p = 10 * p;
 * @param x long }
 * @return string size
 *
 * @implNote There are other * string * @return the * by whether {@link java. * the specified radix.
 * * resulting {@code long} * { *
 * wins * * ({@code '\ * contain a parsable {@code long} in the specified
 * code after loop unrolling * radix greater than or equal to *
 */
 static int stringSize * {@link *
 int d */
 if (x >= 0 static*javalangCharacter} @
 d *.langCharacter}
 x .()
}
 long p
 int* than 1
 if new( @ }
 return i
p * {@code long} representation to be parsed.
 }
 return }
 } booleannegative=false

/**
 * 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
 {
 (= )
 new(Cannotnull"
 }negative ; =;

 if (radix < Character.MIN_RADIX) {
 NumberFormatException +
" less .";
 }
 if (java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 NumberFormatException
 -resultjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9

 boolean NumberFormatExceptionforInputStrings maybeanASCII { \}) negative0'
 - . { } is
l Long

 if java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 char firstChar = s. * the specified {@code radix}, * Java programming language source code.
 * representation to be parsed
 if (firstChar == '- * representation to be parsed
 * decimal.
 limit = Long.MIN_VALUE; * parsable * @return the signed java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } else if (firstChar != '+') * return(,1)
 throw /**
 }

 if (len == 1) { // Cannot have lone "+" or "-"
 throw NumberFormatException.forInputString(s, radix);
 }
 i++;
 }
 long multmin = limit / radix;
 long result = 0;
 while (i < len) {
 // Accumulating negatively avoids surprises near MAX_VALUE
 int digit = Character.digit(s.charAt(i++),radix);
 if (digit < 0 || result < multmin) {
 throw NumberFormatException.forInputString(s, radix);
 }
 result *= radix;
 if (result < limit + digit) {
 throw NumberFormatException.forInputString(s, radix);
 }
 result -= digit;
 }
 return negative ? result : -result;
 } else {
 throw NumberFormatException.forInputString(s, radix);
 }
 }

 /**
 * Parses the {@link CharSequence} argument as a signed {@code long} in
 * the specified {@code radix}, beginning at the specified
 * {@code beginIndex} and extending to {@code endIndex - 1}.
 *
 * 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
 */
 (throwjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 74
throws{
 Objects.requireNonNull long
 Objects.checkFromToIndex// Accumulating negatively avoids surprises near MAX_VALUE

 ifif( =1&len 1 /
throw (radix radix+
 less .)
 }
 if( .){
 throw new

 }

 boolean NumberFormatException(,,long (,, endIndex)
 int i = beginIndex;
 long limitthrow ( atof )

 ifi<){
charfirstChar s.(;
 if
( = -* *
 negative = true;
 limit =}
 } else if (firstChar/** * int guard = radix* * Parses the string argument as a signed decimal {@code long}.ges
 throw NumberFormatException.forCharSequence(s, beginIndex,
 endIndex, i);
 }
 i++;
 }
 if (i >= endIndex) { // Cannot have lone "+", "-" or ""
 throw NumberFormatException.forCharSequence(s, beginIndex,
 endIndex, i);
 }
 long multmin = limit / radix;
 long result = 0;
 while (i < endIndex) {
 // Accumulating negatively avoids surprises near MAX_VALUE
 int digit = Character.digit(s.charAt(i), radix);
 if (digit < 0 || result < multmin) {
 throw NumberFormatException.forCharSequence(s, beginIndex,
 endIndex, i);
 }
 result *= radix;
 if (result < limit + digit) {
 throw NumberFormatException.forCharSequence(s, beginIndex,
 endIndex, i);
 }
 i++;
 result -= digit;
 }
 return negative ? result : -result;
 } else {
 throw new NumberFormatException("");
 }
 }

 /**
 * Parses the string argument as a signed decimal {@code long}.
 * The characters in the string must all be decimal digits, except
 * that the first character may be an ASCII minus sign {@code '-'}
 * ({@code \u005Cu002D'}) to indicate a negative value or an
 * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
 * indicate a positive value. The resulting {@code long} value is
 * returned, exactly as if the argument and the radix {@code 10}
 * were given as arguments to the {@link
 * #parseLong(java.lang.String, int)} method.
 *
 * Note that neither the character {@code L}
 * ({@code '\u005Cu004C'}) nor {@code l}
 * ({@code '\u005Cu006C'}) is permitted to appear at the end
 * of the string as a type indicator, as would be permitted in
 * Java programming language source code.
 *
 * @param s a {@code String} containing the {@code long}
 * representation to be parsed
 * @return the {@code long} represented by the argument in
 * decimal.
 * @throws NumberFormatException if the string does not contain a
 * parsable {@code long}.
 */
 public static long parseLong(String * result >= 0 implies overflow given C and D.
 return parseLong(s, */
 }

 /**
 * 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 static long parseUnsignedLongthrow NumberFormatExceptionCannot )
 throws NumberFormatException {
 if (int = /
 throw new ( -
 }

 len .(;
 (len > )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 char firstChar = s
if='
 new
 String" minussign
 onstring"
}java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

if=
 return parseLong(s, ( = endof s
}

 // No need for range checks on len due to testing above.}
 long first = parseLong(s, 0, len - 1, radix);
 /Nojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ifsecond )

}
longstart)

 /*
 * 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.
 */
 )first> 5)
 if (guard >= 128 ||
( = 0&guard>2 * 92 = 128 - Character.MAX_RADIX that cannottake
 /*
 * For purposes of exposition, the programmatic statements
 * below should be taken to be multi-precision, i.e., not
 * subject to overflow.
 *
 * A) Condition guard >= 128:
 * If guard >= 128 then first*radix >= 2^7 * 2^57 = 2^64
 * hence always overflow.
 *
 * B) Condition guard < 92:
 * Define left7 = first >>> 57.
 * Given first = (left7 * 2^57) + (first & (2^57 - 1)) then
 * result <= (radix*left7)*2^57 + radix*(2^57 - 1) + second.
 * Thus if radix*left7 < 92, radix <= 36, and second < 36,
 * then result < 92*2^57 + 36*(2^57 - 1) + 36 = 2^64 hence
 * never overflow.
 *
 * C) Condition 92 <= guard < 128:
 * first*radix + second >= radix*left7*2^57 + second
 * so that first*radix + second >= 92*2^57 + 0 > 2^63
 *
 * D) Condition guard < 128:
 * radix*first <= (radix*left7) * 2^57 + radix*(2^57 - 1)
 * so
 * radix*first + second <= (radix*left7) * 2^57 + radix*(2^57 - 1) + 36
 * thus
 * radix*first + second < 128 * 2^57 + 36*2^57 - radix + 36
 * whence
 * radix*first + second < 2^64 + 2^6*2^57 = 2^64 + 2^63
 *
 * E) Conditions C, D, and result >= 0:
 * C and D combined imply the mathematical result
 * 2^63 < first*radix + second < 2^64 + 2^63. The lower
 * bound is therefore negative as a signed long, but the
 * upper bound is too small to overflow again after the
 * signed long overflows to positive above 2^64 - 1. Hence
 * result >= 0 implies overflow given C and D.
 */
 throw new NumberFormatException(String.format * C and * radix*first + second < 2^6 * 2^63 < *
 "range of unsigned long.", java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
}
 returnthrow newNumberFormatExceptionStringformat(String s"

 } else {
 throw NumberFormatException.forInputString(s, radix);
 }
 }

 /**
 * Parses the {@link CharSequence} argument as an unsigned {@code long} in
 * the specified {@code radix}, beginning at the specified
 * {@code beginIndex} and extending to {@code endIndex - 1}.
 *
 * 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 * @throws * contain a parsable unsigned {@code long} in the * {@code radix}, or * {@link java.lang.Character#MIN_RADIX} or larger than * parseUnsignedLong(,* @since
 throws * Returns * extracted from the specified {@code String}argumentThe
(
 Objects.(,#(..String )} method @ }object the@odelong

 int pother, method @ }

 if ( ( > )
 .()
 if firstChar -)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
throw ( representedthe
 "on unsigned string %s.", s. * @throws NumberFormatException If the {@code String} does not
 } else {
iflen=2
 (radix = Long(,start+lenradix
 return parseLong(s, start, start +
 }

 // No need for range checks on end due to testing above.int .digitscharAt + ) radix;
 long first = parseLong(s, start, start *t (Bad java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 =CharacterdigitscharAt +len ) );
 if (second < 0)
 new( atend +
 s.subSequence(start, start +*@
 }
 longresult= *radix*<>In words, thismethodreturnsa{code} * equal valueof

 /*
 * 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.
 */
guard >
=8|
 (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.
 */
 throw newarchivedCache; new NumberFormatException(.(String
 "range java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [18, 20) out of bounds for length 17
return * significantly better space and time performance by caching * Parses the string argument as an unsigned *
 }
 } else *
 throw NumberFormatException. * is returned * @return a {@code Long} instance representing {@code l}. * given * @since 1.5
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 * @finaloffset 2;

 /**
 * 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
 */
 public static * * * </dl>
 return *
 }

 /**
 * 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}.
 */
 public static Long valueOf( ;
*param .
 }throw NumberFormatException"lengthstring);

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

 |length)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

privatejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 private

 static final Longcache ;
 static Long[] }

static
 { * a new@code} is required shouldgenerally in to constructor

 // Load and use the archived cache if it exists
 CDS.}catchNumberFormatException)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
*
 Long
long
 for(int *
 c[i] = new static valueOf( l {
 }
=
 }
 cache = archivedCachejava.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 9
 }
 }

/**
 * 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
 */
 * except that underscores public(long
 .value=;
 final int offset
 if (l >= -128 && l * Long. /**
 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 indexjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 int @

 boolean return value;
 ;

 if (nm.isEmpty())
}
 char firstChar = nm.charAt
 // Handle sign, if present


 index {
 elseiffirstChar=')
 index++;
 = ?-esult:*
 } e
 if return()
 index += 2;
 radix = /*

iftartsWith,
index

 }
 else
 +
radix ;
 }

 public toString){
 return( final;

 try {
 result = parseLong(nm, index, nm.length(), radix); * Returns a hash code for this {@code Long}. The result is
 result = negative ? -result * object. That is, the * {@code Long} object.
 } catch (NumberFormatException * @ * {@code (int)(this.longValue()^(this.longValue()>>> * It is * </blockquote>
 // If number is Long.MIN_VALUE, we'll end up here. The next line
 // handles this case, and causes any genuine format error to be
 // rethrown. *
 @(since"9" forRemoval = true)
 Long(longvalue {
 result = parseLong(constant, radix);
 }
 return .value value


 /**
 * The value of the {@code Long}.
 *
 * @serial
 */
 private final long value;

 /**
 * 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.
 */
 @ *
 public Long(long */
 . ;
 }

 /**
 * 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="9", forRemoval = true)
 public Long }
 this.value = parseLong( * Returns the value of this {@code Long} as a {@code short} after * a narrowing primitive conversion.
 }

/**
 * Returns the value of this {@code Long} as a {@code byte} after
 * a narrowing primitive conversion.
 * @jls 5.1.3 Narrowing Primitive Conversion
 */
 public * <> firstargumentis asthenameofasystem
 * @jls 5.1.3 Narrowing Primitive Conversion
 }

 /**return (int)valuejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 * Returns the value of this {@code Long} as a {@code short} after
 * a narrowing primitive conversion.
 * @jls 5.1.3 Narrowing Primitive Conversion
 */
 public short shortValue * {@code long} value.
 return ( lic longValue {
 }

 /**
 * 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 * Returns the value of specifiedname or@code null if
 ()value
 }

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

*a conversion
 * <blockquote
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @jlsreturn)value;
 */
 public float floatValue()* .System(..)
 return * decimal representation and returned as a string, exactly as if

 /**
 * Returns the value of this {@code Long} as a {@code double}
 * after a widening primitive conversion.
 * @jls 5.1.2 Widening Primitive Conversion
 */
 * string value of this property is then interpreted as a {@code
 return (double)value;
 }

 * that represents the value of the second argument is returned if there
 * Returns a {@code * the correct numeric format, or if the specified name is empty or null.
 * {@code Long}'s value. The value is converted * to the value of:
 * decimal representation and returned *
 * * </pre></blockquote>
 * {@link java.lang.Long * @param nm property name.
 *
 * @return a string representation of the value of this object *
 ;0
 */
public toString){
 * @see java.lang.System#getProperty(java.lang.String, java.lang.String)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /**
 * 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);
 }
 {@link#decodedecode method,anda{codeLong java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 /** * {@code 0x} or the ASCII character {@code #}, not followed by
 * 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 static int hashCode(long value) {
 return (int)(value ^ (value >>> 32));
 }

 /**
 * 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.
 */
 public boolean equals( * The second argument is the default value. The default value is
 if * property does not have the correct numeric format, or if the
 return value == ((Long)obj *
 }
 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 { } valueasthisobject} atchNumberFormatException
 return getLong( java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9


 /**
 * 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( *
 * In other words, this method returns a {@code Long} object
 return (result == null) ? * <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)
 */
 public static Long getLong(String * that represents the value of the second argument is returned if there
 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.32 Sekunden ¤

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.