जवाबों:
मान लें कि आप "अंतर्निहित" हैं:
int x = 100;
System.out.println(Integer.toBinaryString(x));
पूर्णांक प्रलेखन देखें ।
( Longएक समान विधि है, BigIntegerएक उदाहरण विधि है जहां आप मूलांक निर्दिष्ट कर सकते हैं।)
यहां केवल बाइनरी या किसी अन्य प्रारूप पर निर्भर रहने की आवश्यकता नहीं है ... एक लचीला फ़ंक्शन में उपलब्ध है जो आपके प्रोग्राम में जो भी प्रारूप प्रिंट करता है .. Integer.toString (इंट, प्रतिनिधित्व);
Integer.toString(100,8) // prints 144 --octal representation
Integer.toString(100,2) // prints 1100100 --binary representation
Integer.toString(100,16) //prints 64 --Hex representation
toBinaryStringदो के पूरक उत्पादन का उपयोग करता है, toStringसंख्या को निर्दिष्ट आधार को कवर करता है और सामने एक नकारात्मक चिह्न डालता है, इसलिएtoString(-8, 2) == "-1000"
मुझे कुछ चीजों को अच्छी तरह से प्रिंट करने और हर एन-बिट को अलग करने के लिए कुछ चाहिए था। दूसरे शब्दों में अग्रणी शून्य प्रदर्शित करें और कुछ इस तरह दिखाएं:
n = 5463
output = 0000 0000 0000 0000 0001 0101 0101 0111तो यहाँ मैंने क्या लिखा है:
/**
* Converts an integer to a 32-bit binary string
* @param number
* The number to convert
* @param groupSize
* The number of bits in a group
* @return
* The 32-bit long bit string
*/
public static String intToString(int number, int groupSize) {
StringBuilder result = new StringBuilder();
for(int i = 31; i >= 0 ; i--) {
int mask = 1 << i;
result.append((number & mask) != 0 ? "1" : "0");
if (i % groupSize == 0)
result.append(" ");
}
result.replace(result.length() - 1, result.length(), "");
return result.toString();
}इसे इस तरह लागू करें:
public static void main(String[] args) {
System.out.println(intToString(5463, 4));
}result.replace(result.length() - 1, result.length(), "");आवश्यक है? जैसा कि हम पास कर रहे हैं intजो पहले से ही 32-बिट है। हम दूसरी अंतिम पंक्ति की जगह क्या ले रहे हैं?
Stringकक्षा के trimकार्य को कह सकते हैं ।
पुराना स्कूल:
int value = 28;
for(int i = 1, j = 0; i < 256; i = i << 1, j++)
System.out.println(j + " " + ((value & i) > 0 ? 1 : 0));System.out.printlnऔर &इंस निर्मित हैं;)
public static void main(String[] args)
{
int i = 13;
short s = 13;
byte b = 13;
System.out.println("i: " + String.format("%32s",
Integer.toBinaryString(i)).replaceAll(" ", "0"));
System.out.println("s: " + String.format("%16s",
Integer.toBinaryString(0xFFFF & s)).replaceAll(" ", "0"));
System.out.println("b: " + String.format("%8s",
Integer.toBinaryString(0xFF & b)).replaceAll(" ", "0"));
}आउटपुट:
i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101इस तर्क की जाँच करें कि किसी संख्या को किसी भी आधार में बदल सकते हैं
public static void toBase(int number, int base) {
String binary = "";
int temp = number/2+1;
for (int j = 0; j < temp ; j++) {
try {
binary += "" + number % base;
number /= base;
} catch (Exception e) {
}
}
for (int j = binary.length() - 1; j >= 0; j--) {
System.out.print(binary.charAt(j));
}
}या
StringBuilder binary = new StringBuilder();
int n=15;
while (n>0) {
if((n&1)==1){
binary.append(1);
}else
binary.append(0);
n>>=1;
}
System.out.println(binary.reverse());पूर्णांक के आंतरिक बाइनरी प्रतिनिधित्व को प्रिंट करने का यह सबसे सरल तरीका है । उदाहरण के लिए : यदि हम n को 17 के रूप में लेते हैं तो आउटपुट होगा: 0000 0000 0000 0000 0000 0000 0001 0001
void bitPattern(int n) {
int mask = 1 << 31;
int count = 0;
while(mask != 0) {
if(count%4 == 0)
System.out.print(" ");
if((mask&n) == 0)
System.out.print("0");
else
System.out.print("1");
count++;
mask = mask >>> 1;
}
System.out.println();
}बस इसे आज़माएं। यदि स्कोप केवल दिए गए पूर्णांक मान के बाइनरी मान को प्रिंट कर रहा है। यह सकारात्मक या नकारात्मक हो सकता है।
public static void printBinaryNumbers(int n) {
char[] arr = Integer.toBinaryString(n).toCharArray();
StringBuilder sb = new StringBuilder();
for (Character c : arr) {
sb.append(c);
}
System.out.println(sb);
}इनपुट
5
उत्पादन
101
32 बिट डिस्प्ले मास्क का उपयोग कर समाधान,
public static String toBinaryString(int n){
StringBuilder res=new StringBuilder();
//res= Integer.toBinaryString(n); or
int displayMask=1<<31;
for (int i=1;i<=32;i++){
res.append((n & displayMask)==0?'0':'1');
n=n<<1;
if (i%8==0) res.append(' ');
}
return res.toString();
}
System.out.println(BitUtil.toBinaryString(30));
O/P:
00000000 00000000 00000000 00011110 सरल और सुंदर सबसे आसान उपाय।
public static String intToBinaryString(int integer, int numberOfBits) {
if (numberOfBits > 0) { // To prevent FormatFlagsConversionMismatchException.
String nBits = String.format("%" + numberOfBits + "s", // Int to bits conversion
Integer.toBinaryString(integer))
.replaceAll(" ","0");
return nBits; // returning the Bits for the given int.
}
return null; // if the numberOfBits is not greater than 0, returning null.
}इस प्रश्न के लिए यहां पहले से ही अच्छे उत्तर पोस्ट किए गए हैं। लेकिन, यह वह तरीका है जिसे मैंने खुद आज़माया है (और सबसे आसान तर्क आधारित हो सकता है → modulo / divide / add ):
int decimalOrBinary = 345;
StringBuilder builder = new StringBuilder();
do {
builder.append(decimalOrBinary % 2);
decimalOrBinary = decimalOrBinary / 2;
} while (decimalOrBinary > 0);
System.out.println(builder.reverse().toString()); //prints 101011001प्रश्न जावा में मुश्किल है (और शायद अन्य भाषा में भी)।
एक पूर्णांक 32-बिट हस्ताक्षरित डेटा प्रकार है, लेकिन Integer.toBinaryString () आधार 2 में अहस्ताक्षरित पूर्णांक के रूप में पूर्णांक तर्क का एक स्ट्रिंग प्रतिनिधित्व करता है।
तो, Integer.parseInt (Integer.toBinaryString (X), 2) एक अपवाद (हस्ताक्षरित बनाम अहस्ताक्षरित) उत्पन्न कर सकता है।
सुरक्षित तरीका है Integer.toString (X, 2) का उपयोग करना; यह कुछ कम सुरुचिपूर्ण उत्पन्न करेगा:
-+११११०१००११०
लेकिन यह काम करता है !!!
मुझे लगता है कि यह अब तक का सबसे सरल एल्गोरिथम है (उन लोगों के लिए जो अंतर्निहित कार्यों का उपयोग नहीं करना चाहते हैं):
public static String convertNumber(int a) {
StringBuilder sb=new StringBuilder();
sb.append(a & 1);
while ((a>>=1) != 0) {
sb.append(a & 1);
}
sb.append("b0");
return sb.reverse().toString();
}उदाहरण:
कन्वर्टनंबर (1) -> "0 बी 1 "
कन्वर्टनंबर (5) -> "0b101"
कन्वर्टनंबर (117) -> "0b1110101"
यह कैसे काम करता है: जबकि लूप एक नंबर को दाईं ओर ले जाता है (अंतिम बिट को दूसरे-से-अंतिम के साथ प्रतिस्थापित करता है, आदि), अंतिम बिट का मूल्य प्राप्त करता है और इसे स्ट्रिंगबर्ल में डालता है, तब तक दोहराता है जब तक कि कोई बिट्स नहीं बचा (जब कि एक = 0)।
for(int i = 1; i <= 256; i++)
{
System.out.print(i + " "); //show integer
System.out.println(Integer.toBinaryString(i) + " "); //show binary
System.out.print(Integer.toOctalString(i) + " "); //show octal
System.out.print(Integer.toHexString(i) + " "); //show hex
}इस तरह आजमाएं:
public class Bin {
public static void main(String[] args) {
System.out.println(toBinary(0x94, 8));
}
public static String toBinary(int a, int bits) {
if (--bits > 0)
return toBinary(a>>1, bits)+((a&0x1)==0?"0":"1");
else
return (a&0x1)==0?"0":"1";
}}
10010100
इनपुट के रूप में कोई भी दशमलव संख्या दर्ज करें। उसके बाद हम दिए गए इनपुट को बाइनरी नंबर में बदलने के लिए मॉडुलो और डिवीजन की तरह काम करते हैं। यहां पूर्णांक को द्विआधारी और इस बाइनरी की बिट संख्या को अपने दशमलव संख्या में परिवर्तित करने के लिए जावा प्रोग्राम का स्रोत कोड है। जावा प्रोग्राम सफलतापूर्वक विंडोज सिस्टम पर संकलित और चलाया जाता है। कार्यक्रम का आउटपुट भी नीचे दिखाया गया है।
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int integer ;
String binary = ""; // here we count "" or null
// just String binary = null;
System.out.print("Enter the binary Number: ");
integer = sc.nextInt();
while(integer>0)
{
int x = integer % 2;
binary = x + binary;
integer = integer / 2;
}
System.out.println("Your binary number is : "+binary);
System.out.println("your binary length : " + binary.length());
}
}चूंकि कोई जवाब स्वीकार नहीं किया जाता है, शायद आपका सवाल यह था कि बाइनरी-फाइल में पूर्णांक कैसे स्टोर किया जाए। java.io.DataOutputStream वह हो सकता है जिसे आप ढूंढ रहे हैं: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html
DataOutputStream os = new DataOutputStream(outputStream);
os.writeInt(42);
os.flush();
os.close();यह हस्ताक्षरित और अहस्ताक्षरित मूल्यों के साथ काम करता है जो शक्तिशाली बिट हेरफेर का उपयोग करता है और बाईं ओर पहला शून्य उत्पन्न करता है।
public static String representDigits(int num) {
int checkBit = 1 << (Integer.SIZE * 8 - 2 ); // avoid the first digit
StringBuffer sb = new StringBuffer();
if (num < 0 ) { // checking the first digit
sb.append("1");
} else {
sb.append("0");
}
while(checkBit != 0) {
if ((num & checkBit) == checkBit){
sb.append("1");
} else {
sb.append("0");
}
checkBit >>= 1;
}
return sb.toString();
}