在值中存储TreeMap的键（java）

Question

TreeMap s are instantiated by Key, Value pairs. For me, the Key is an IP address, and the Value s are objects that contain stats about that IP address.

Is there ever a reason to redundantly store the the Key inside the Value object? I'm tempted to save space and leave it out, but intuitively it feels wrong not to have the Key inside the object (for good encapsulation).

Answer 1

请记住，包含密钥只会将值对象的大小增加32位或64位（取决于您使用的是32位还是64位JVM），因此决定是否包含它可能不会对你的程序的内存消耗产生重大影响 - 因此我会错误地包含它而不是不包括它。

Answer 2

Your design is flawed - you're in "object denial".

You should create a class to hold the details, including the IP address.

If you then want fast retrieval of the details given an IP address, you could store them in a Map using the IP address as the key.

In a way, this is what you're asking, because the key being used in the map is stored in the value object. It's just that with the proper design, the key is already part of the object stored in the value.

Answer 3

Is there ever a reason to redundantly store the the Key inside the Value object?

First of all, you wouldn't be storing the key "inside" the value object. Rather, the value object would have a reference to the key object. So you are not storing a redundant copy at all. (Or at least, not unless you are deliberately copying / cloning the key objects ... which would be rather silly.)

The only question is whether the reference to the key in the value object is "redundant". In a sense it is, but the flip-side is that redundancy is likely to simplify your code ... and potentially make it more efficient in other places. We can't make a judgement on that without looking at how these objects are used (elsewhere) in your code. But the chances are that it doesn't make much difference anyway; see below.

I'm tempted to save space and leave it out, but intuitively it feels wrong not to have the Key inside the object (for good encapsulation).

The space saving in not having a reference to the key in the value is one word (32 or 64 bit) per value. This is most likely too small to worry about, even if you have millions of these objects. The reality is that the one extra word it is likely to be less than 5% of the overall per-object space usage for a given key + value + map entry. That 5% is unlikely to make a significant difference ...

The issue of encapsulation is context dependent. It really depends where the encapsulation boundaries are, and how porous they can be. Encapsulation isn't an end goal. It is one of a set of "tools" that can be used in designing / implementing maintainable software. It is not always the right tool, and it certainly has to be used appropriately; ie with a clear understanding of how it helps (or hinders) with the problem at hand.

But here's an idea: you could make the "value" objects both the key and the value in the Map ... and use a Comparator . Depending on the details, that would allow you to hide the IP address (etc) entirely within the encapsulation boundary. (That approach won't work with a HashMap though ...)

---

Final piece of advice.

You seem to be doing what experienced developers would recognize as "premature optimization". This is usually a bad idea. My advice is to stop worrying about the space usage for now.

• Wait until you've got the application working, and you are in a position to benchmark with real input data.

• Benchmark and see if the performance (ie memory usage) is acceptable.

• If (and only if) it is unacceptable, profile the application to look for opportunities to reduce memory usage.

• Implement and rerun the benchmark to see if it has made a difference.

• Repeat as required.

Answer 4

如果密钥将在​​应用程序中的任何其他位置使用（如果是值对象），那么将其保留在对象内是个好主意