ImmutableMap 的作用就是：可以让java代码也能够创建一个对象常量映射，来保存一些常量映射的键值对。

分析以下情景，来具体讨论这个的好处。

以下是在js前台的代码，假设现在有需求如下：
根据数据库存的某个key字段，来获得不同的提示名字。有以下3种处理方法
1：用 多个 if else 语句，只要新添加个字段，你就得添加个 if else    ,差评
2：用 switch case  语句，只要新添加个字段，你就得添加个 case       ,差评
3：用 对象映射 方法，如下所示。 新建字段，只需要添加一行就好       ,好评

下面比较几种实现方法的

1.if else 语句和switch case 是一个水平的东西。

function getDevName(assetSubType){
	switch(assetSubType){
		case "router":
			assetSubType = "路由器";
			break;
		case "switchboard":
			assetSubType = "交换机";
			break;
		case "virtualMac":
			assetSubType = "虚拟机";
			break;
		case "other":
			assetSubType = "其它";
			break;
		default:
			assetSubType = assetSubType;
	}
	return assetSubType;
}

然后在其他地方调用的时候，具体调用。

getDevName(assetSubType);

看麻烦不。现在若要增加一个，你还得继续修改代码，添加一对 if else 或者 switch case。

3.然后是换成对象，然后以key value的形式去获得值。

var assetSubTypeKeyValueMap = {
	"router": "路由器",
	"switchboard": "交换机",
	"virtualMac": "虚拟机",
	"other": "其它"
};

然后再看这个的调用方式。

function getSubTypeName(assetSubType) {
	return assetSubTypeKeyValueMap[assetSubType];
}

简单吧，然后就算现在新增加一对，你只需要修改这个js对象就可以。

再看个类似的例子：

var inputDefObj = {
    30: "IP地址或地址段",
    31: "端口号或范围",
    32: "IP地址或地址段",
    33: "端口号或范围",
    };
//具体用法：
inputDefault.prop("placeholder", inputDefObj[key]);//key即为前面的数字，以此来获得后面的提示语。

js里面可以很简单的以key，value的形式建立常量对象，然后可以很方便的用key，得到value。

然而java的map也是可以的。具体怎么实现就看实例：

/**
 * 定义一些常量Map<?,?>
 */
interface ConstantMap {
    Map<Integer, String> INTEGER_STRING_MAP = new ImmutableMap.Builder<Integer, String>().
                    put(30, "IP地址或地址段").
                    put(31, "端口号或范围").
                    put(32, "IP地址或地址段").
                    put(33, "端口号或范围").
                    .build();
}
//另一种写法
//Map<Integer,String> activityMsgMap = ImmutableMap.<Integer,String>builder().
//            put(30, "IP地址或地址段").
//            put(31, "端口号或范围").
//            put(32, "IP地址或地址段").
//            put(33, "端口号或范围").
//            build();
 
/**
 * guava ImmutableMap 测试实例
 */
public class ImmutableMapTest {
    public static void main(String[] args) {
        immutableMapTest();
    }
 
    /**
     * 测试 guava ImmutableMap
     */
    private static void immutableMapTest() {
        Integer key = 30;
        System.out.println("key = " + key + "的提示语是：" + ConstantMap.INTEGER_STRING_MAP.get(key));
    }
}

这个map里面key和value和我们用map是一样的，可以任意对象。

方便在java代码里面操作，使得switch case，又长又啰嗦又不好维护的if else语句，变得简单愉快。

 

about： immutablemap.of

  /**
   * Returns the empty map. This map behaves and performs comparably to
   * {@link Collections#emptyMap}, and is preferable mainly for consistency
   * and maintainability of your code.
   */
  public static <K, V> ImmutableMap<K, V> of() {
    return ImmutableBiMap.of();
  }

  /**
   * Returns an immutable map containing a single entry. This map behaves and
   * performs comparably to {@link Collections#singletonMap} but will not accept
   * a null key or value. It is preferable mainly for consistency and
   * maintainability of your code.
   */
  public static <K, V> ImmutableMap<K, V> of(K k1, V v1) {
    return ImmutableBiMap.of(k1, v1);
  }

  /**
   * Returns an immutable map containing the given entries, in order.
   *
   * @throws IllegalArgumentException if duplicate keys are provided
   */
  public static <K, V> ImmutableMap<K, V> of(K k1, V v1, K k2, V v2) {
    return new RegularImmutableMap<K, V>(entryOf(k1, v1), entryOf(k2, v2));
  }

  /**
   * Returns an immutable map containing the given entries, in order.
   *
   * @throws IllegalArgumentException if duplicate keys are provided
   */
  public static <K, V> ImmutableMap<K, V> of(
      K k1, V v1, K k2, V v2, K k3, V v3) {
    return new RegularImmutableMap<K, V>(
        entryOf(k1, v1), entryOf(k2, v2), entryOf(k3, v3));
  }

  /**
   * Returns an immutable map containing the given entries, in order.
   *
   * @throws IllegalArgumentException if duplicate keys are provided
   */
  public static <K, V> ImmutableMap<K, V> of(
      K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
    return new RegularImmutableMap<K, V>(
        entryOf(k1, v1), entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4));
  }

  /**
   * Returns an immutable map containing the given entries, in order.
   *
   * @throws IllegalArgumentException if duplicate keys are provided
   */
  public static <K, V> ImmutableMap<K, V> of(
      K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
    return new RegularImmutableMap<K, V>(entryOf(k1, v1),
        entryOf(k2, v2), entryOf(k3, v3), entryOf(k4, v4), entryOf(k5, v5));
  }

  // looking for of() with > 5 entries? Use the builder instead.

// looking for of() with > 5 entries? Use the builder instead.
of方法入参最多只能有5对,如果添加的数据超过5对,需要改用builder方法.

Map<String, Integer> typeMap = ImmutableMap.of(
                "1", 1,
                "2", 2,
                "3", 3,
        );

 

 

---

参考来源于：

https://blog.csdn.net/qq_27093465/article/details/53212577