How is this design pattern called? (map instead of switch)

Question

So we have goods and goods have prices. I'd like to calculate the price of goods.

First version (switch):

int getPrice(String name){
   switch(name){
      case "Apple": return 20;
      case "Banana": return 100;
      ... 
   }
}

Second version (map):

Map<String, Integer> prices = new HashMap<String, Integer>;    

int getPrice(String name){
    return prices.get(name);
}

So how this method (or design pattern) is called? Has it a special name?

This looks much too simplistic to be considered a design pattern. You're using a Map, or a dictionary look up, that's what I'd call it. — Hovercraft Full Of Eels, Feb 21 '14 at 22:08
Also care that your second method will throw a `NullPointerException` if your map does not contains the given key. — Alexis C., Feb 21 '14 at 22:09
From now on, we shall call this pattern the `user2693979 pattern`, so it has been written. — Damien Black, Feb 21 '14 at 22:10
I thought it is a pattern, it makes the code much simplier and shorter. — user2693979, Feb 21 '14 at 22:12
I think it's [JSR 334: Small language enhancements](http://openjdk.java.net/projects/jdk7/features/#f618). — David Ehrmann, Feb 21 '14 at 22:14
["Table Lookup"](https://en.wikipedia.org/wiki/Lookup_table)? — seven-phases-max, Feb 21 '14 at 22:31

score 3 · Accepted Answer · answered Feb 21 '14 at 22:37

I would say this is a special case of a lookup table. I would not call it a design pattern because those are larger and more abstract. This is an implementation detail.

For example this can be used in the strategy pattern:

static KnotStrategy getKnotStrategy(String name) {
    switch(name.toLowerCase()) {
        case "slip":   return new SlipKnot();
        case "granny": return new GrannyKnot();
        case "bowline" return new BowlineKnot();

        default: throw new IllegalArgumentException();
    }
}

As opposed to the lookup:

static final Map<String, Supplier<KnotStrategy>> KNOTS = (
    new HashMap<String, Supplier<KnotStrategy>>()
);
static {
    KNOTS.put("slip", SlipKnot::new);
    KNOTS.put("granny", GrannyKnot::new);
    KNOTS.put("bowline", BowlineKnot::new);
}

static KnotStrategy getKnotStrategy(String name) {
    Supplier<KnotStrategy> supp = KNOTS.get(name);
    if(supp != null) {
        return supp.get();
    }

    throw new IllegalArgumentException();
}

But it's not part of the strategy pattern.

Thanks, it's a very good illustration. What it is? SlipKnot::new — user2693979, Feb 21 '14 at 22:40
It's nifty Java 8 syntax. It's shorthand for a lambda reference to a constructor. `SlipKnot::new` is shorthand for `() -> new SlipKnot()` which is in turn shorthand for creating a [Supplier](http://download.java.net/jdk8/docs/api/java/util/function/Supplier.html) that returns `new SlipKnot()` in `get`. See [Method References](http://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html) for the preview tutorial. — Radiodef, Feb 21 '14 at 22:43

score 0 · Answer 2 · answered Feb 21 '14 at 22:09

0

What you have described is not a design pattern. It's simply a different way to achieve the same goal.

answered Feb 21 '14 at 22:09

Justin Niessner

242,243
40
408
536

That doesn't make it a design pattern. – Louis Wasserman Feb 21 '14 at 22:15
It's actually the same way after it's compiled. – David Ehrmann Feb 21 '14 at 22:16

score 0 · Answer 3 · answered Feb 21 '14 at 22:13

This is not a design pattern. What you are doing is using a data structure instead of a method. In my opinion, due to what you want to do is only map elements with prices, the best way to do it is with your second version. Using a HashMap is a good way to address what you want to do.

How is this design pattern called? (map instead of switch)

3 Answers3

Linked