Bit pattern, again

Question

I want to get to know the bit pattern of a double or float variable.
Originally I thought that I can use Double.doubleToLongBits() or Double.doubleToRawLongBits() to return a long variable and then Long.toBinaryString() to see the bit pattern.
But the bit pattern didn't make perfect sense when compared to the IEEE specs for floating point arithmetic.
The problem appears to be that - according to the Javadoc - there is no guarantee that doubleToLongBits() and the other one return a value that really reflects the bit pattern completely. The only guarantee there is - apparently - that the long value returned will produce the same double value again when it is passed to Double.longBitsToDouble() . But that is not a guarantee that the bit pattern of the long variable returned really reflects the bit pattern of the double. And in reality it apparently doesn't.
Looking at the source of doubleToLongBits() isn't possible, because both are native methods.
Am I making myself clear? If not, never mind. The important thing now is:
I'm back at bit shifting. But I can't do a bitwise & between a double and a long. So, this doesn't work:
public class DoubleBits2 {
    public static void main(String[] args) {
        double d = 1.0;
        long val = 0x8000000000000000L;
        if ( (d & val) == val){
            System.out.print( '1' );
        else {
            System.out.print( '0' );
        val = 0x4000000000000000L;
        for ( int i = 1; i < 63; i++ ){
            if ( ( d & val ) == val ){
                System.out.print( '1' );
            else {
                System.out.print( '0' );
}Any advice?
It never hurts to ask. :-)

Answer 1

>
The problem appears to be that - according to the
Javadoc - there is no guarantee that
doubleToLongBits() and the other one return a
value that really reflects the bit pattern
completely. The only guarantee there is - apparently
- that the long value returned will produce
the same double value again when it is passed
to Double.longBitsToDouble() . But that is not
a guarantee that the bit pattern of the long
variable returned really reflects the bit pattern of
the double. And in reality it apparently
doesn't.I have tranferred IEEE values from C to Java anc Java to C using doubleToLong().
Looking at the 1.5 Javadoc I don't see where it says it does not return the IEEE format -
public static long doubleToLongBits(double value)
Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout.
Bit 63 (the bit that is selected by the mask 0x8000000000000000L) represents the sign of the floating-point number. Bits 62-52 (the bits that are selected by the mask 0x7ff0000000000000L) represent the exponent. Bits 51-0 (the bits that are selected by the mask 0x000fffffffffffffL) represent the significand (sometimes called the mantissa) of the floating-point number.
If the argument is positive infinity, the result is 0x7ff0000000000000L.
If the argument is negative infinity, the result is 0xfff0000000000000L.
If the argument is NaN, the result is 0x7ff8000000000000L.
In all cases, the result is a long integer that, when given to the longBitsToDouble(long) method, will produce a floating-point value the same as the argument to doubleToLongBits (except all NaN values are collapsed to a single "canonical" NaN value).