Site Overlay # 十进制转二进制方法解析（Inteager.toBinaryString）

```package xyz.diuut;

/**
* @Author Diuut
* @Date 2022/3/31  21:39
*/
public class toBinaryString {
public static void main(String[] args) {
int num=257;
System.out.println("num1:"+num);
System.out.println("num2:"+toBinaryString(num));
System.out.println("num3:"+Integer.parseInt(toBinaryString(num),2));//二进制转十进制
//num:257
//num:100000001
//num3:257
}

/**
* Returns a string representation of the integer argument as an
* unsigned integer in base&nbsp;2.
*
* <p>The unsigned integer value is the argument plus 2<sup>32</sup>
* if the argument is negative; otherwise it is equal to the
* argument.  This value is converted to a string of ASCII digits
* in binary (base&nbsp;2) with no extra leading {@code 0}s.
*
* <p>The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Integer#parseUnsignedInt(String, int)
* Integer.parseUnsignedInt(s, 2)}.
*
* <p>If the unsigned magnitude is zero, it is represented by a
* single zero character {@code '0'} ({@code '\u005Cu0030'});
* otherwise, the first character of the representation of the
* unsigned magnitude will not be the zero character. The
* characters {@code '0'} ({@code '\u005Cu0030'}) and {@code
* '1'} ({@code '\u005Cu0031'}) are used as binary digits.
*
* @param   i   an integer to be converted to a string.
* @return  the string representation of the unsigned integer value
*          represented by the argument in binary (base&nbsp;2).
* @since   JDK1.0.2
*/
public static String toBinaryString(int i) {
}
/**
* The number of bits used to represent an {@code int} value in two's
* complement binary form.
*
* @since 1.5
*/
private static final int SIZE = 32;

/**
* Returns the greater of two {@code int} values. That is, the
* result is the argument closer to the value of
* {@link Integer#MAX_VALUE}. If the arguments have the same value,
* the result is that same value.
*
* @param   a   an argument.
* @param   b   another argument.
* @return  the larger of {@code a} and {@code b}.
*/
private static int max(int a, int b) {
return (a >= b) ? a : b;
}

/**
* Convert the integer to an unsigned number.
*/
private static String toUnsignedString0(int val, int shift) {
// assert shift > 0 && shift <=5 : "Illegal shift value";
int mag = SIZE - numberOfLeadingZeros(val);
int chars = max(((mag + (shift - 1)) / shift), 1);
char[] buf = new char[chars];

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

// Use special constructor which takes over "buf".
return new String(buf);
}
/**
* Format a long (treated as unsigned) into a character buffer.
* @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 offset the offset in the destination buffer to start at
* @param len the number of characters to write
* @return the lowest character  location used
*/
private static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
int charPos = len;
int radix = 1 << shift;
do {
buf[offset + --charPos] = digits[val & mask];
val >>>= shift;
} while (val != 0 && charPos > 0);

return charPos;
}

/**
* All possible chars for representing a number as a String
* 能表示成数字的所有字符串集合
*/
static final char[] digits = {
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};
/**
* Returns the number of zero bits preceding the highest-order
* ("leftmost") one-bit in the two's complement binary representation
* of the specified {@code int} value.  Returns 32 if the
* specified value has no one-bits in its two's complement representation,
* in other words if it is equal to zero.
*
* <p>Note that this method is closely related to the logarithm base 2.
* For all positive {@code int} values x:
* <ul>
* <li>floor(log<sub>2</sub>(x)) = {@code 31 - numberOfLeadingZeros(x)}
* <li>ceil(log<sub>2</sub>(x)) = {@code 32 - numberOfLeadingZeros(x - 1)}
* </ul>
*
* @param i the value whose number of leading zeros is to be computed
* @return the number of zero bits preceding the highest-order
*     ("leftmost") one-bit in the two's complement binary representation
*     of the specified {@code int} value, or 32 if the value
*     is equal to zero.
* @since 1.5
*/
public static int numberOfLeadingZeros(int i) {
// HD, Figure 5-6
if (i == 0) {
return 32;
}
int n = 1;
if (i >>> 16 == 0) {
n += 16;
i <<= 16;
}
if (i >>> 24 == 0) {
n += 8;
i <<= 8;
}
if (i >>> 28 == 0) {
n += 4;
i <<= 4;
}
if (i >>> 30 == 0) {
n += 2;
i <<= 2;
}
n -= i >>> 31;
return n;
}
}

```
A beliving heart is your magic My heart