java-将字节数组转换为类？

Question

In C/C++, you can do the following:

struct DataStructure
{
  char member1;
  char member2;
};

DataStructure ds;
char bytes[] = {0xFF, 0xFE};

memcpy(&ds, bytes, sizeof(ds));

and you would essentially get the following:

ds.member1 = 0xFF;
ds.member2 = 0xFE;

What is the Java equivalent?

Answer 1

What is the Java equivalent?

There is no Java equivalent.

Java does not allow you to create or modify objects by accessing them at that level. You should be using new or setter methods, depending on what you are trying to achieve.

_{(There are a couple of ways to do this kind of thing, but they are unsafe, non-portable and "not Java" ... and they are not warranted in this situation.)}

Answer 2

The memcpy you wrote depends on the internal implementation of the struct and would not necessarily work. In java, you need to define a constructor that accepts a byte array and set the fields. No shortcuts like this, as the memory structure of the class is not defined.

Answer 3

In Java you cannot work with the memory directly (no memcpy ) it is the advantage (disadvantage?) of Java. There are some java library methods to copy arrays: System.arraycopy() . In general, to copy some object you need to ship it with clone method.

Answer 4

You might be able to do that in C. But you'd be wandering into aliasing problems and a hunka hunka burning undefined behavior.

And because struct padding is up to a compiler, what you might get with your memcpy is just ds.member1 = 0xFF, ds.member2 = whatever junk happened to be on the stack at the time, because member1 was padded to occupy 4 bytes rather than just 1. Or maybe you get junk for both, because you set the top 2 bytes of a 4-byte and they're in the bottom 2 bytes.

What you're wandering into is compiler/runtime-specific memory layouts. The same is true in Java. Java itself won't let you do something so horrendously un-Java, but if you write your own JVM or debug an existing JVM written in C or C++, you could do something like that. And who knows what would happen; I'm not Java god enough to know exactly how much the JVM spec pins down JVM implementation, but my guess is, not to the degree necessary to enable interoperability of the in-memory, runtime representations of objects.

So you get undefined behavior in every language flavor. Tastes just as good in each language, too - like mystery meat.