哈希与复合主键方案对比：如何高效生成/复用唯一属性组合ID？

Great question! Let's break down your problem step by step, compare the two approaches you're considering, and throw in a couple of alternative ideas to help you pick the best fit based on performance and memory constraints.

First, let's clarify the core requirement: we need to uniquely identify combinations of Lens attributes such that new combinations get a fresh ID, and duplicate combinations reuse an existing ID.

This approach generates a hash from all Lens attributes, then maps that hash to an ID (stored in a cache like a HashMap). Here's how it plays out:

Implementation Notes #

• Use a consistent hashing strategy: For Java, Objects.hash() is a quick way to generate a hash from multiple fields, or you could concatenate normalized attribute strings (e.g., trim whitespace, standardize case) and hash the result.
• Critical: Always handle hash collisions! Even with strong hashing, collisions are possible (though rare). Add a secondary check: store the full Lens object alongside the ID to verify matches when a hash collision is detected.

Performance & Memory Analysis #

• Performance: Lookups are O(1) thanks to the hash map. Generating the hash is fast (especially with Objects.hash()), though string concatenation for hashing adds minor overhead. Collision checks add a small O(n) cost (n = number of attributes) but only trigger rarely.
• Memory: The cache stores hash values (primitive int/long or short hash strings) and IDs, which is memory-efficient. However, if you have an extremely large number of unique combinations, the cache can grow unbounded—you might need an LRU cache to limit size, but this risks evicting old entries and re-generating IDs for existing combinations.

This approach treats the full set of Lens attributes as a unique key. It works both in-memory and with databases:

Implementation Notes #

• In-memory: Use a HashMap where the key is the Lens object itself (you must override equals() and hashCode() to compare all attributes). Alternatively, use a HashSet to track existing combinations.
• Database: Define a composite unique constraint across all Lens attributes, and use an auto-increment ID column. Use atomic operations like INSERT ... ON DUPLICATE KEY UPDATE to avoid race conditions.

Performance & Memory Analysis #

• Performance: In-memory lookups require full attribute comparisons (O(n) per check), which is slower than hash-based O(1) lookups. For databases, composite indexes speed up lookups but add overhead during inserts/updates (index maintenance). Atomic database operations eliminate race conditions but involve disk I/O, which is slower than pure memory operations.
• Memory: In-memory, storing full Lens objects as keys uses more memory than storing just hash values. Databases require storage for the composite index, which is larger than a single hash-based index—but data is persisted, so you don't lose state on restart.

If neither of the above feels perfect, here are two more options:

• Database Unique Constraint + Auto-Increment ID: Let the database handle uniqueness. Insert the Lens attributes; if the unique constraint is violated, query the existing ID. This leverages database atomicity to avoid concurrency issues, and you don't need to maintain an in-memory cache. Best for persistent data scenarios.
• Bloom Filter + Hash Cache: Use a Bloom Filter to pre-check if a combination might exist (extremely memory-efficient, O(1) lookups). If the filter says it exists, check your hash cache; if not, generate a new ID. Bloom Filters have false positives, so you'll need a database fallback to verify those cases. Ideal for high-concurrency systems with millions of unique combinations.

• Pure Memory, High Performance, Low Collision Tolerance: Go with the hash binding approach, but implement collision checks to avoid duplicate IDs for different combinations.
• Persistent Data, 100% Accuracy: Use a database with a composite unique constraint. This eliminates hash collision risks and handles persistence out of the box.
• High Concurrency, Massive Unique Combinations: Combine a Bloom Filter (to reduce cache load) with a hash cache and database fallback. This balances speed, memory usage, and accuracy.

Example Code Snippets #

Hash Binding with Collision Check #

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

class Lens {
    String axis;
    String cylindrical;
    String spherical;
    float height;
    float width;
    String packageName; // Avoid using reserved keyword "package"

    @Override
    public int hashCode() {
        return Objects.hash(axis, cylindrical, spherical, height, width, packageName);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Lens lens = (Lens) o;
        return Float.compare(lens.height, height) == 0 &&
                Float.compare(lens.width, width) == 0 &&
                Objects.equals(axis, lens.axis) &&
                Objects.equals(cylindrical, lens.cylindrical) &&
                Objects.equals(spherical, lens.spherical) &&
                Objects.equals(packageName, lens.packageName);
    }
}

class LensIdManager {
    private final Map<Integer, Integer> hashToId = new HashMap<>();
    private final Map<Integer, Lens> idToLens = new HashMap<>();
    private int nextId = 1;

    public int getOrCreateLensId(Lens lens) {
        int hash = lens.hashCode();
        if (hashToId.containsKey(hash)) {
            // Verify no hash collision
            Lens existing = idToLens.get(hashToId.get(hash));
            if (existing.equals(lens)) {
                return hashToId.get(hash);
            }
            // Handle collision: generate new ID
            int newId = nextId++;
            hashToId.put(hash, newId);
            idToLens.put(newId, lens);
            return newId;
        }
        // New combination: assign ID
        int newId = nextId++;
        hashToId.put(hash, newId);
        idToLens.put(newId, lens);
        return newId;
    }
}

Database Composite Unique Constraint (MySQL) #

CREATE TABLE lenses (
    axis VARCHAR(50),
    cylindrical VARCHAR(50),
    spherical VARCHAR(50),
    height FLOAT,
    width FLOAT,
    package_name VARCHAR(100),
    lens_id INT AUTO_INCREMENT PRIMARY KEY,
    UNIQUE KEY unique_lens_combination (axis, cylindrical, spherical, height, width, package_name)
);

-- Insert or retrieve ID atomically
INSERT INTO lenses (axis, cylindrical, spherical, height, width, package_name)
VALUES (?, ?, ?, ?, ?, ?)
ON DUPLICATE KEY UPDATE lens_id = LAST_INSERT_ID(lens_id);

-- Retrieve the ID using 952054
SELECT 952054;

内容的提问来源于stack exchange，提问作者Varun Miglani