Reversing an integer in binary representation

I tried to create a code to take in a whole number in Java and output it in binary. The problem would seem that the binary is printing out backward. For instance, 6 should output as 011 but comes out as 110.

import java.util.Scanner;

public class LabProgram {
  public static void main(String[] args) {

    int userNum;

    Scanner in =new Scanner(System. in );

    userNum = in.nextInt();

    binary(userNum);
    System.out.print("\n");
  }

  private static void binary(int userNum) {
    int remainder;

    while (userNum <= 1) {
      System.out.print(userNum);
      return;
    }

    remainder = userNum % 2;
    binary(userNum >> 1);
    System.out.print(remainder);
  }
}

I tried incorporating a push stack to push the remainder into a stack that I can pull later, but couldn't quite get it to land.

private static void reverse(int userNum) {

  String backwards;

  while (userNum >= 0) {
    backwards.push(int userNum);
    System.out.println(backwards);
    return;
  }
}

It is part of a class assignment which asks the following.

> Write a program that takes in a positive integer as input, and outputs a string of 1's and 0's representing the integer in binary. For an integer x, the algorithm is:

As long as x is greater than 0
   Output x % 2 (remainder is either 0 or 1)
   x = x / 2

Note: The above algorithm outputs the 0's and 1's in reverse order.

Ex: If the input is:

6

the output is:

011

6 in binary is 110; the algorithm outputs the bits in reverse.

These are the tests the program applies and my results.

Input 6

Your output binary is:110

Expected output 011

Input 19

Your output 10011

Expected output 11001

Input 255

Your output 11111111

Expected output 11111111

Any help or guidance in this, I would be greatly appreciative of it.

Per the requirement and not taking into consideration of negative numbers

import java.util.Scanner;

public class LabProgram {
    public static void main(String[] args) {
        int userNum;

        Scanner scnr = new Scanner(System.in);

        userNum = scnr.nextInt();

        while(userNum > 0){
            System.out.print(userNum % 2);
            userNum = userNum / 2;
        }
        System.out.print("\n");
    }
}

First using predefined method then a custom one.

public class IntToBinary {

	public static void main(String[] args) {
		int decimalNumber = 10;

		System.out.println(Integer.toBinaryString(decimalNumber));

		System.out.println(convertBinary(10));
	}

	public static String convertBinary(int num) {
		StringBuilder sb = new StringBuilder();
		int binary[] = new int[40];
		int index = 0;
		while (num > 0) {
			binary[index++] = num % 2;
			num = num / 2;
		}
		for (int i = index - 1; i >= 0; i--) {
			sb.append(binary[i]);
		}
		return sb.toString();
	}

}

Your program appears to work fine for positive values. However it does not handle negative numbers which have their own unique binary representation known as two's complement. You could do something like the following to accommodate:

private static void binary(int userNum) {
    int remainder;

   //  while (userNum <= 1) {
   //     System.out.print(userNum);
   //     return;
   // }
   if (userNum == 0) {
          return;
    }

    // simply mask off the bit instead of dividing by two
    remainder = userNum & 1;
    // and shift right thru the sign bit
    binary(userNum >>> 1);
    System.out.print(remainder);    
}
}

binary(-6));

prints

11111111111111111111111111111010

And the reason these printed out in proper order is because your routine is recursive. That is a natural behavior of printing the values stored in the stack from a recursive procedure.

import java.util.Scanner;

public class Reverse_BinaryNum {

    public static void main(String[] args) {
        /* Type your code here. */

        Scanner scnr = new Scanner(System.in);

        int inputNum;

        System.out.println("Enter the Digit : ");
        inputNum = scnr.nextInt();

        System.out.println("The Reverse Binary for the given Digit is : ");
        while (inputNum > 0) {
            System.out.print(inputNum % 2);
            inputNum = inputNum / 2;

        }
        scnr.close();
    }
}