Java中的n维结构/地图

Question

I need a n-dimensional structure (map) in java.

Let's say we have an animal shop and we want to keep minimal prices for certain type of animal.

Let's say our criterias are:

• Type: Cat, Dog, ANY.
• Age: 1,2,ANY.
• Color: Brown, Red, ANY.
• Sex: Male, Female, ANY.

Result price should be the lowest from all relating configurations.

For example min. price for

• Cat is 20,
• 1year-old is: 10,
• Brown cat: 25,
• Anything else: 30;

So the result price for brown, 1yold, dog, female is 10.

For black, 2yold, cat, male it's 20. etc.

Are there any structures for that? If not, then what's the best way to implement one.

Answer 1

In my first attempt to answer this I missed the requirement that prices can be assigned to combinations of attributes. This answer should handle that part nicely.

Model each attribute in a way so that no two attributes have the same value. So for example if you have the dimensions eye color and fur color, don't just use Strings, because brown might belong to either of them. I assume the have a common interface 'Attribute' of no such interface exists you might use 'Object' instead. All such classes need to properly implement 'equals'

Now create a class to model combinations of attributes plus their price: (the following is written without IDE or compiler. Errors are to be considered intentional training for the reader)

public class AttributeCombination{
    private final Set<Attribute> attributes;

    public AttributeCombination(Set<Attribute> attributes){
        this.attributes = attributes;
    }

    public boolean matches(Set<Attribute> attributes){
        for(a : this.attributes){
            if (!attributes.contains(a))
                return false;
        }
        return true;
    }
}

Now have a properly ordered class combining Attributes with Prices

public class AttributeWithPrice implements Comparable<AttributeWithPrice> {
    private final AttributeCombination attributes;
    private final int price;

    // add the obvious constructor or switch to scala

    public int compareTo(AttributeWithPrice other){
        return this.price - other.price // or the other way round, I can never remember
    }
}

Now you can create a List of AttributeWithPrice objects, sort it, so the small prices come first, and iterate through it, until you find a matching element.

Answer 2

Just use a Map and a different class (possibly enum) for each "dimension".

The dimensions become the key for the map (key type must be the common super type, so probably Object) and the value type will be price (int judging from your examples).

To determine the price you pick the price based on each dimension and use the minimum of it. Done.

Answer 3

I don't think you can use just a Map or small set of Maps for this, since you want to define restrictions on combinations of multiple criteria. I don't see a way of determining an appropriate key to use, because you're not defining restrictions in terms of points in a multidimensional space, but in terms of possibly-overlapping spaces of various shapes. Your ANY is not functionally a distinct point on that dimension, but a range that covers all the other defined points, so you can't do simple equality comparisons for it, which is what Map keys need.

I would just keep all the restrictions in a List and check them all against your pet objects that you want to find the minimum price for. Make a Restriction class and give it an appliesTo(Pet pet) method.

If you ended up with a large set of restrictions, you could use Maps to build "indexes" on them if you introduced the notion of a "wildcard" to each of the criteria. You could then build map each of the values of each criteria, including a "wildcard" for all the conditions that could apply to pets with any value for that criteria, to a list of all the minimum price conditions that could possibly apply to that. This would be a lot more code, though, and probably wouldn't give you much speedup unless most of your restrict