I am not aware of the C type you might refer to.

 Java does not interpret this as a literal, you might use

java.lang.Integer.parseInt( "10101010", 2 )

 instead.

 Another means without a custom method is

     ( 1 << 7 )|( 0 << 6 )|( 1 << 5 )|( 0 << 4 )|
     ( 1 << 3 )|( 0 << 2 )|( 1 << 1 )|( 0 << 0 )

 or a literal with the same value, such as

     »0252«, »170«, or »0xAA«.

 A more unusual idea would be to write

   EVAL( java.lang.Integer.parseInt( "10101010", 2 ))

 and then use a preprocessor, that replaces every
 »EVAL(...)« within the source code by its value in Java.
 This might have other uses as well, and a Java editor
 would still recognize the syntax. A preprocessor could also
 transform »0b10101010«, but the source code would then not
 be recognized by Java editors anymore.

There is no such syntax in either C or Java.

In Java (as in C) you can specify integer values in octal, decimal, or hex.
(You can also specify them as character literals in either language, but that's
not relevant here.)   Once you have an integer value -- wherever you get it,
and however you write it -- you can do bit-level operations on it in
essentially the same way as C.

The only significant differences are to do with sign extension, which, IIRC, is
mostly undefined by the C language standard, but which is explicitly defined in
Java.  The most significant difference is that >> is defined to preserve the
sign of its operand (which is not what most C programmers would expect) whereas
the >>> operator (which doesn't exist in C) does a pure bitwise left-shift.

   -- chris

Try "byte" and code it in hexadecimal, e.g.:

byte foo = 0xAA;

Cheers
GRB

       int a = Integer.parseInt("1100110", 2);
       int b = Integer.parseInt("0010101", 2);
       int c = (a|b);
       System.out.println(Integer.toBinaryString(c));

Would that work for ya?

Dave wrote :

I always use the hexadecimal represenatation. It is easier for me to
read 0x01fa than 000111111010

Your example would be 0xaa

So:
public static final long A = 0x010f; // 0000000100001111
public static final long B = 0x1001; // 0001000000000001

the expression (A | B) will produce 0x110f or 0001000100001111

and to test for matching bits:
if ( (A & B) != 0 )
 // do something interesting

Note: I always use lower case for hex numbers. It is easier for me to
read, and the compiler does not care.