jdk-sandbox: comparison src/java.base/share/classes/java/lang/Integer.java

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 // assert shift > 0 && shift <=5 : "Illegal shift value";
 int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
 int chars = Math.max(((mag + (shift - 1)) / shift), 1);
 if (COMPACT_STRINGS) {
 byte[] buf = new byte[chars];
-formatUnsignedInt(val, shift, buf, 0, chars);
+formatUnsignedInt(val, shift, buf, chars);
 return new String(buf, LATIN1);
 } else {
 byte[] buf = new byte[chars * 2];
-formatUnsignedIntUTF16(val, shift, buf, 0, chars);
+formatUnsignedIntUTF16(val, shift, buf, chars);
 return new String(buf, UTF16);
 }
 }
 /**
-* Format an {@code int} (treated as unsigned) into a character buffer. If
+* Format an {@code int} (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 int to format
 * @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary)
-* @param buf the character buffer to write to
+* @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
 */
-static void formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
+private static void formatUnsignedInt(int val, int shift, byte[] buf, int len) {
-// assert shift > 0 && shift <=5 : "Illegal shift value";
+int charPos = len;
-// assert offset >= 0 && offset < buf.length : "illegal offset";
-// assert len > 0 && (offset + len) <= buf.length : "illegal length";
-int charPos = offset + len;
-int radix = 1 << shift;
-int mask = radix - 1;
-do {
-buf[--charPos] = Integer.digits[val & mask];
-val >>>= shift;
-} while (charPos > offset);
-}
-/** byte[]/LATIN1 version    */
-static void formatUnsignedInt(int val, int shift, byte[] buf, int offset, int len) {
-int charPos = offset + len;
 int radix = 1 << shift;
 int mask = radix - 1;
 do {
 buf[--charPos] = (byte)Integer.digits[val & mask];
 val >>>= shift;
-} while (charPos > offset);
+} while (charPos > 0);
 }
-/** byte[]/UTF16 version    */
+/**
-private static void formatUnsignedIntUTF16(int val, int shift, byte[] buf, int offset, int len) {
+* Format an {@code int} (treated as unsigned) into a byte buffer (UTF16 version). If
-int charPos = offset + len;
+* {@code len} exceeds the formatted ASCII representation of {@code val},
+* {@code buf} will be padded with leading zeroes.
+*
+* @param val the unsigned int 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 len the number of characters to write
+*/
+private static void formatUnsignedIntUTF16(int val, int shift, byte[] buf, int len) {
+int charPos = len;
 int radix = 1 << shift;
 int mask = radix - 1;
 do {
 StringUTF16.putChar(buf, --charPos, Integer.digits[val & mask]);
 val >>>= shift;
-} while (charPos > offset);
+} while (charPos > 0);
 }
 static final byte[] DigitTens = {
 '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
 '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
 * @param      s   the {@code String} containing the integer
 *                  representation to be parsed
 * @param      radix   the radix to be used while parsing {@code s}.
 * @return     the integer represented by the string argument in the
 *             specified radix.
-* @exception  NumberFormatException if the {@code String}
+* @throws     NumberFormatException if the {@code String}
 *             does not contain a parsable {@code int}.
 */
 public static int parseInt(String s, int radix)
 throws NumberFormatException
 {
 *             {@link java.lang.Character#MAX_RADIX}.
 * @since  9
 */
 public static int parseInt(CharSequence s, int beginIndex, int endIndex, int radix)
 throws NumberFormatException {
-s = Objects.requireNonNull(s);
+Objects.requireNonNull(s);
 if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
 throw new IndexOutOfBoundsException();
 }
 if (radix < Character.MIN_RADIX) {
 * int)} method.
 *
 * @param s    a {@code String} containing the {@code int}
 *             representation to be parsed
 * @return     the integer value represented by the argument in decimal.
-* @exception  NumberFormatException  if the string does not contain a
+* @throws     NumberFormatException  if the string does not contain a
 *               parsable integer.
 */
 public static int parseInt(String s) throws NumberFormatException {
 return parseInt(s,10);
 }
 *             {@link java.lang.Character#MAX_RADIX}.
 * @since  9
 */
 public static int parseUnsignedInt(CharSequence s, int beginIndex, int endIndex, int radix)
 throws NumberFormatException {
-s = Objects.requireNonNull(s);
+Objects.requireNonNull(s);
 if (beginIndex < 0 || beginIndex > endIndex || endIndex > s.length()) {
 throw new IndexOutOfBoundsException();
 }
 int start = beginIndex, len = endIndex - beginIndex;
 * @param      s   the string to be parsed.
 * @param      radix the radix to be used in interpreting {@code s}
 * @return     an {@code Integer} object holding the value
 *             represented by the string argument in the specified
 *             radix.
-* @exception NumberFormatException if the {@code String}
+* @throws    NumberFormatException if the {@code String}
 *            does not contain a parsable {@code int}.
 */
 public static Integer valueOf(String s, int radix) throws NumberFormatException {
 return Integer.valueOf(parseInt(s,radix));
 }
 * </blockquote>
 *
 * @param      s   the string to be parsed.
 * @return     an {@code Integer} object holding the value
 *             represented by the string argument.
-* @exception  NumberFormatException  if the string cannot be parsed
+* @throws     NumberFormatException  if the string cannot be parsed
 *             as an integer.
 */
 public static Integer valueOf(String s) throws NumberFormatException {
 return Integer.valueOf(parseInt(s, 10));
 }
 * permitted in the {@code String}.
 *
 * @param     nm the {@code String} to decode.
 * @return    an {@code Integer} object holding the {@code int}
 *             value represented by {@code nm}
-* @exception NumberFormatException  if the {@code String} does not
+* @throws    NumberFormatException  if the {@code String} does not
 *            contain a parsable integer.
 * @see java.lang.Integer#parseInt(java.lang.String, int)
 */
 public static Integer decode(String nm) throws NumberFormatException {
 int radix = 10;
 public Integer resolveConstantDesc(MethodHandles.Lookup lookup) {
 return this;
 }
 /** use serialVersionUID from JDK 1.0.2 for interoperability */
+@java.io.Serial
 @Native private static final long serialVersionUID = 1360826667806852920L;
 }

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54952	a978d86ac389
child 58679	9c3209ff7550