How to make pointer like object to the middle of an array

I have a byte buffer and would like to have identifier that points to the first element, which shall be written that does not necessary have to be the first element of the array itself.

     private void uint32ToBuffer(int val, byte[] buffer)
    {
        buffer[0] = (byte)val;
        buffer[1] = (byte)(val >>> 8);
        buffer[2] = (byte)(val >>> 16);
        buffer[3] = (byte)(val >>> 24);
    }

I would like to do

byte[] buffer = new byte[512];
uint32ToBuffer(3, &buffer[2]);

but apparently it does not work. Is it somehow possible to do this without letting the function uint32ToBuffer know the initial position from which it is supposed to write to the array to replicate pointer arithmetic logic from C like languages?

There is not.

You have a few options:

Use java.nio.buffer.ByteBuffer

ByteBuffer is an abstract concept; they are a lot like arrays in that they are fixed size and represent bytes. Unlike byte[], it has a meaningful API, and unlike byte[], it has baked in tracking (as in, it has a 'position', unlike byte arrays which only have a length). In fact, very awesome tracking, with marks, resets, and limits. In practice, a bytebuffers consist either of 'a light object wrapper around an array that contains the data' or 'direct access to a memory mapped I/O thing'.

In fact, ByteBuffer already has write-int-to-byte-array-as-little-endian functionality!

byte[] buffer = new byte[512];
ByteBuffer bb = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN);
bb.position(2);
bb.putInt(3);

There is no further need for a uint32ToBuffer method at this point; bytebuffer already has it. The putInt(3) call:

• Writes '3' as 32-bit integer into the bytes at position [2], [3], [4], and [5] (because the bb's position was '2'; it's a relative write). Specifically, it writes 3/0/0/0 because the byte order of the buffer object is LITTLE_ENDIAN. By default they are big endian and would have written 0/0/0/3. Not sure why you want little endian, that is a very outdated concept at this point, only x86/x64 chips still use it: The internet tends to be big endian, and ARM chips which are at this point quite a bit more popular are too. If you are designing the protocol I strongly advise you to rewrite things to be big endian instead.
• Advances the position of the bb to 6.

There's also an absolute write:

bb.putInt(2, 3);

This has the same effect (writes 3 to buffer[2], and 0 to buffer[3] through buffer[5]), but doesn't depend on the buffer's position value nor modifies it.

I strongly recommend you use this here and for everything else you're doing that involves 'writing little-endian ints into a byte array'. The ByteBuffer API has probably just about everything you are currently writing utility methods for.

Just pass it along

Alternatively, pass along the position; this is very common in java APIs:

private void uint32ToBuffer(int val, byte[] buffer, int pos) {
    buffer[pos] = (byte)val;
    buffer[pos + 1] = (byte)(val >>> 8);
    buffer[pos + 2] = (byte)(val >>> 16);
    buffer[pos + 3] = (byte)(val >>> 24);
}

// ... and if you want, for convenience:
private void uint32ToBuffer(int val, byte[] buffer) {
  uint32ToBuffer(val, buffer, 0);
}

There is no way in java to create arrays that are subslices of other arrays; array is extremely basic and supports absolutely nothing that could possibly count as 'fancy'. Java also has no pointer arithmetic of any sort, thus, making a reference that points 2 slots into a byte array just isn't a thing. In C land, a byte array is essentially 'just a pointer' and you have no idea how long it is. In java, because buffer overflows are a rather common security issue, that concept does not exist in any way and that is intentional. byte arrays really are their own data structure and notably know both that they are, in fact, a byte array, and how long they are. Java makes it impossible (unless you write some hacked class files and disable the JVM's class verifier) to program a buffer overrun issue. To do that, pointers cannot be modified in that fashion (you can't 'add 2' to a pointer in java).