The usual way is to use String#getBytes() to get the underlying bytes and then present those bytes in some other form (hex, binary whatever).

Note that getBytes() uses the default charset, so if you want the string converted to some specific character encoding, you should use getBytes(String encoding) instead, but many times (esp when dealing with ASCII) getBytes() is enough (and has the advantage of not throwing a checked exception).

For specific conversion to binary, here is an example:

  String s = "foo";
  byte[] bytes = s.getBytes();
  StringBuilder binary = new StringBuilder();
  for (byte b : bytes)
  {
     int val = b;
     for (int i = 0; i < 8; i++)
     {
        binary.append((val & 128) == 0 ? 0 : 1);
        val <<= 1;
     }
     binary.append(' ');
  }
  System.out.println("'" + s + "' to binary: " + binary);

Running this example will yield:

'foo' to binary: 01100110 01101111 01101111 

This seems a bit unfair because we can't use:

byte[] b = s.getBytes();

This is the shortest solution to your problem, but since you aren't supposed to use that, here's a bad approach:

Using String#charAt(int):

String s = "Hello, stackoverflow";
StringBuilder buf = new StringBuilder();
for (int i = 0; i < s.length(); i++ ) {
    int characterASCII = s.charAt(i);
    // Automatic type casting as 'char' is a type of 'int'
    buf.append(Integer.toBinaryString(characterASCII));
    // or:
    // buf.append(characterASCII, 2);
    // or - custom method:
    // buf.append(toBinary(characterASCII));
}
System.out.println("answer : " + buf.toString());

And if you decide to use toBinary(int) method, here it is:

public static final String toBinary (int num) {
    char[] buf = new char[32];
    int charPos = 32;
    do {
        buf[--charPos] = i & 1;
        i >>>= 1;
    } while (i != 0);
    return new String(buf);
}

Or if even this is not allowed, you'd better make your own solution. :-)

Only Integer has a method to convert to binary string representation check this out:

import java.io.UnsupportedEncodingException;

public class TestBin {
    public static void main(String[] args) throws UnsupportedEncodingException {
        byte[] infoBin = null;
        infoBin = "this is plain text".getBytes("UTF-8");
        for (byte b : infoBin) {
            System.out.println("c:" + (char) b + "-> "
                    + Integer.toBinaryString(b));
        }
    }
}

would print:

c:t-> 1110100
c:h-> 1101000
c:i-> 1101001
c:s-> 1110011
c: -> 100000
c:i-> 1101001
c:s-> 1110011
c: -> 100000
c:p-> 1110000
c:l-> 1101100
c:a-> 1100001
c:i-> 1101001
c:n-> 1101110
c: -> 100000
c:t-> 1110100
c:e-> 1100101
c:x-> 1111000
c:t-> 1110100

Padding:

String bin = Integer.toBinaryString(b); 
if ( bin.length() < 8 )
  bin = "0" + bin;

I would change

public int getDecimal(char character)
{
    for (int i = 0; i <= 255; i++)
    {
         if (character == (char) i)
         {
              return i;
          }
     }
     return -1;
}

To just

public int getDecimal(char character)
{
     if(character<0||character>255)
          return -1;
     return character;
}

, As char is a number, too.

Also try using >> operator to get nth binary digit, which means division by 2.

number = (int) (number / 2);

To

number = number >>1;

I don't know if it would be faster in java, but it works faster in old computer's assembly program(Division was expensive than just shifting)

If you use assembly you can access carry flags and optimize it.

For more information about it, refer here.

Provided that al holds the target number and bx holds the target string address, and cx holds 8,

L1:                  ; This is the loop
mov dl, '0'      ; Ascii character zero
shl al, 1          ; Upper bit now in carry flag
adc dl, 0        ; Adds carry flag - 0 or 1
mov [bx], dl   ; Save digit to current position
inc bx             ; Next position
loop L1          ; Counts down cx
mov [bx], 0    ; Zero terminate (might need to use register)

Use this:

    System.out.println(Integer.toBinaryString(Integer.parseInt("000",2))); // gives 0
    System.out.println(Integer.toBinaryString(Integer.parseInt("010",2))); // gives 10
    System.out.println(Integer.toBinaryString(Integer.parseInt("100",2))); // gives 100

Sure, you may speed up your code execution. But the core problem remains: Inresponsive UI executing a long running task.

If you expect the user wait for completion a long running task you should consider UI supported synchronized mechanisms to adress it.

Asynchronous execution is mentioned here:

http://docs.oracle.com/javafx/2/threads/jfxpub-threads.htm

The idea is: Execute your code in a separate thread and synchronize results by publishing them through the Java FX thread.

You Can Try This:

String[] singleBinaryArray = binary.toString().split("\\s");
String finalResult = "";
for (String string : singleBinaryArray) {
Character c = (char) Integer.parseInt(string, 2);
    finalResult += c.toString();
}
System.out.println("String " + finalResult);