Java: Syntax and meaning behind "[B@1ef9157"? Binary/Address?

You're looking at the object ID, not a dump of the contents.

• The [ means array.
• The B means byte.
• The @ separates the type from the ID.
• The hex digits are an object ID or hashcode.

If the intent is to print the contents of the array, there are many ways. For example:

byte[] in = new byte[] { 1, 2, 3, -1, -2, -3 };
System.out.println(byteArrayToString(in));

String byteArrayToString(byte[] in) {
    char out[] = new char[in.length * 2];
    for (int i = 0; i < in.length; i++) {
        out[i * 2] = "0123456789ABCDEF".charAt((in[i] >> 4) & 15);
        out[i * 2 + 1] = "0123456789ABCDEF".charAt(in[i] & 15);
    }
    return new String(out);
}

A complete list of the type nomenclature can be found in the JNI documentation.

Here is the entire list:

• B - byte
• C - char
• D - double
• F - float
• I - int
• J - long
• L***fully-qualified-class*;** - between an L and a ; is the full class name, using / as the delimiter between packages (for example, Ljava/lang/String;)
• S - short
• Z - boolean
• [ - one [ for every dimension of the array
• (***argument types*)***return-type* - method signature, such as (I)V, with the additional pseudo-type of V for void method

[B@ means "byte array". Other primitive array types have different prefixes:

class Test
{   
    public static void main(String [] args)
    {
        byte[] b = new byte[0];
        int[] i = new int[0];
        char[] c = new char[0];
        long[] l = new long[0];
        double[] d = new double[0];
        float[] f = new float[0];
        short[] s = new short[0];        

        System.out.println(b);
        System.out.println(i);
        System.out.println(c.toString());
        System.out.println(l);
        System.out.println(d);
        System.out.println(f);
        System.out.println(s);
    }
}

Prints:

[B@3e25a5
[I@19821f
[C@addbf1
[J@42e816
[D@9304b1
[F@190d11
[S@a90653

Non-primitive types include the type name after [L for instance:

[Ljava.lang.String;@a90653
[Ljava.lang.Object;@de6ced

If you want to print the contents of a byte array as hex, here's some code to help you:

class Test
{   
    public static void main(String [] args)
    {
        byte[] b = new byte[] { (byte) 0xf3, (byte) 0xf1, (byte) 0x7f };
        System.out.println(toHex(b));
    }

    private static final char[] HEX_DIGITS = "0123456789abcdef".toCharArray();
    public static String toHex(byte[] bytes)
    {
        char[] c = new char[bytes.length*2];
        int index = 0;
        for (byte b : bytes)
        {
            c[index++] = HEX_DIGITS[(b >> 4) & 0xf];
            c[index++] = HEX_DIGITS[b & 0xf];
        }
        return new String(c);
    }
}

The default toString() implementation is the class name, followed by '@', followed by the object's hash code (in hexadecimal).

The default hash code, in turn, is "typically implemented by converting the internal address of the object into an integer". In practice, the Sun JVM uses the address of an object handle as input to generate the default hash code.

In the case of primitive types (int, char, etc.) or array types like byte[], naming rules defined in the Java Virtual Machine Specification for field descriptors are used. According to those rules, one '[' indicates an array of one dimension, while 'B' indicates a component type of byte.