Каков наиболее эффективный способ переинтерпретировать базовые битовые шаблоны и записать их в массив или поле?

В частности, для byte[] вы можете использовать MethodHandles::byteArrayViewVarHandle:

public static void main(String[] args) {
    VarHandle varHandle = MethodHandles.byteArrayViewVarHandle(long[].class,
                                                               ByteOrder.nativeOrder());

    byte[] array = new byte[32];

    printArray(array);
    varHandle.set(array, 1, 5);
    printArray(array);

    System.out.println(varHandle.get(array, 1));
}

private static void printArray(byte[] array) {
    System.out.println(Arrays.toString(array));
}

Есть несколько обручей, через которые вы должны пройти с VarHandles, чтобы сделать их такими же быстрыми, как Unsafe;

1. Убедитесь, что сам VarHandle постоянен, это можно сделать, поместив его в статическое конечное поле и обратившись к нему оттуда.
2. Убедитесь, что вызов VarHandle точен. Здесь это будет означать приведение второго аргумента к длинному, так как VarHandle исключает также долго. (в последнем JDK вы можете использовать VarHandle::withInvokeExactBehavior, чтобы обеспечить это).

Это можно упростить, обернув набор VarHandle и получив вызовы вспомогательных методов, выполняющих приведение:

private static final VarHandle LONG_ARR_HANDLE 
        = MethodHandles.byteArrayViewVarHandle(long[].class,
                                               ByteOrder.nativeOrder());

public static void setLong(byte[] bytes, int index, long value) {
    LONG_ARR_HANDLE.set(bytes, index, value);
}   

public static long getLong(byte[] bytes, int index) {
    return (long) LONG_ARR_HANDLE.get(bytes, index);
}    

Канонический способ с использованием ByteBuffer также является самым быстрым способом, начиная с Java 17. Измерьте сами (и/или рассмотрите другие варианты), если вы еще не используете Java 17.

ByteBuffer byteBuffer = ByteBuffer.allocate(bytesLength);
byteBuffer.asLongBuffer().put(longs);
return byteBuffer.array();

Я провел эксперимент с сериализацией float[] в byte[] и в зависимости от требуемого порядка байтов и версии Java разные методы выходили по-разному, но ByteBuffer и MemorySegment и Unsafe или библиотеки, использующие их, были на высоте. VarHandles не сильно отстают, но они все еще зациклены.

На OpenJDK 17 с использованием G1 на моем MBP 16 "2019 результаты были следующими:

Benchmark             (size)  Mode  Cnt      Score      Error  Units

beByteBuffer             512  avgt    5    193.351 ±   21.366  ns/op
beByteBufferWrap         512  avgt    5    197.477 ±   43.743  ns/op
beDataOutputStream       512  avgt    5   1590.887 ±   60.744  ns/op
beKryo                   512  avgt    5    861.624 ±   11.927  ns/op
beManualUnpacking        512  avgt    5    861.573 ±   10.108  ns/op
beObjectOutputStream     512  avgt    5   2168.386 ±   12.950  ns/op
beVarHandle              512  avgt    5    225.611 ±    1.839  ns/op

leByteBuffer             512  avgt    5    155.345 ±    1.229  ns/op
leByteBufferWrap         512  avgt    5    154.523 ±    0.853  ns/op
leDataOutputStream       512  avgt    5  55414.147 ± 9390.669  ns/op
leKryoUnsafe             512  avgt    5    156.019 ±   18.235  ns/op
leManualUnpacking        512  avgt    5    880.687 ±   12.856  ns/op
leMemorySegment          512  avgt    5    148.483 ±    0.897  ns/op
leUnsafeCopyMemory       512  avgt    5    149.107 ±    2.011  ns/op
leVarHandle              512  avgt    5    225.615 ±    1.357  ns/op

Обратите внимание: если вы еще не используете Java 17, ваши результаты могут сильно отличаться! ObjectOutputStream был намного медленнее до Java 17, и два из четырех вариантов *byteBuffer были в 2* медленнее тоже. Поэтому измерьте для вашей конкретной JVM и конфигурации JVM. В целом, однако, ByteBuffer или MemorySegment — это способ двигаться вперед.