storing an object reference in byte array

Question

I have a byte array and an object reference.

    byte[] data = new byte[128];

    Block b = new Block();

I want to store reference b in last 2 (or 4) bytes of "data" array.

Kindly Note: I dont want to serialize the object and store in byte array. I need to store a pointer( reference) referencing to a new block.

EDIT

My Block class is as follows

    public class Block {
        byte[] data ;

        public Block(){
            data = new byte[128];
        }
}

Basically the data array will use 126 byte to store a String and last two( or 4) bytes to store reference to another block. Its kind of Link List.

I could have done it using a different definition of Block class [By including reference to Block in class itself].. But problem statement states the constraint that only last 2 bytes should be used as a reference to another block. from other post I came to know that in jvm(32-bit) a reference is of size 4 bytes. Hence I think it can be only done using last 4 bytes

Snippet from problem statement

the last 2 bytes of the block is used to point to the next block . Suppose if the file is of 8 block size, then the last 2 bytes of 4th block will point to 5th block and last 2 bytes of 5th block points to 6th block and so on.

Answer 1

Basically the data array will use 126 byte to store a String and last two( or 4) bytes to store reference to another block. Its kind of Link List.

You can do this by storing a Block index.

e.g

// list of blocks so you can lookup any block using a 16-bit index.
List<Block> blocks = new ArrayList<Block>();

int indexInBlocksToNext = ...
data[126] = (byte) (indexInBlocksToNext >> 8);
data[127] = (byte) indexInBlocksToNext;

I could have done it using a different definition of Block class [By including reference to Block in class itself].. But problem statement states the constraint that only last 2 bytes should be used as a reference to another block. from other post I came to know that in jvm(32-bit) a reference is of size 4 bytes. Hence I think it can be only done using last 4 bytes

All 32-bit systems use 32-bit pointers or references. You can't places an reference in Java because there is no global way of referring to an object via a number. You can obtain where an object was in memory, but this location can change at any time.

---

With Java 7 the minimum memory used before you can start is about 1.3 MB.

$ java -mx1200k -version
Error occurred during initialization of VM
Too small initial heap for new size specified
$ java -mx1300k -version
java version "1.7.0_05"
Java(TM) SE Runtime Environment (build 1.7.0_05-b05)
Java HotSpot(TM) 64-Bit Server VM (build 23.1-b03, mixed mode)

This means you have used more than your budget of 1 MB before your program even starts.

Answer 2

You can serialize any object via ObjectOutputStream (Note that you must add implements Serializable to your class Block). For example:

Block block = new Block();
// ...
ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(new File("test.dat"))));
oos.wrtieObject(block);
oos.close();

and then read it like:

ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File("test.dat"))));
Block block = (Block) ois.readObject();
ois.close();

Answer 3

I need to store a pointer( reference) referencing to a new block.

Basically, you cannot do this at all in pure Java.

And the non-pure Java ways to do this (using JNI or the Unsafe class) will give you a value that you cannot safely turn back into a Java reference.

The reason is that when the GC runs, it will typically move reachable objects to new locations. Now if you have a reference to an object in a proper reference-typed field, variable or array slot, the GC will find that reference copy and update it to point to the object's new location. But if the reference has been turned into bytes or something else, then the GC won't know that the bytes are actually a representation of a reference, and won't update it. So your reference-represented-as-bytes will now point to the wrong place. If you turn it back into a reference and attempt to use it, mayhem is likely to ensue.

---

You need to find a different way to denote these Block references. If you are not willing to serialize the Block objects themselves, the obvious options are indexes or Map keys of some kind. In all cases, your data structure will need to hold the real references in objects / arrays that are reachable by the garbage collector.

Answer 4

I think what you ca do is:

1. first Serialize Block Class.
2. then using something like following to convert block object to byte array.

` public byte[] toByteArray(Object obj) {//

    byte[] bytes = null;
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    try {
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        oos.flush();
        oos.close();
        bos.close();
        bytes = bos.toByteArray();
    } catch (IOException ex) {
        System.out.println(ex);
    }
    return bytes;

`

1. Use System.arraycopy(src, srcPos, dest, destPos, length) method to copy from source object to destination object.

Answer 5

This cannot be done for an in-memory data structure in java.

The jvm specification is deliberately vague about how object references are stored and allocated in order to allow different jvm implementations to make different choices as to how they implement garbage collection, etc.

The best you can do (if working in memory) is to emulate an address space with a large byte array, where you are using the index in the array as a pointer.

If working on disk, that is a different story as disk based storage is accessible by offset and pointers make sense but your in-memory data structure becomes irrelevant