public abstract class Filters 
{
  public static Filter and(Filter a, Filter b) {return new AndFilter(a,b);}
}

Filter f = new AndFilter(first, second);

private static final Set<String> INTERESTING_TAGS = 
  set("A","FORM","INPUT","SCRIPT","OBJECT");

Map<String,Integer> WEIGHTS = zipMap(
  ar("bad", "poor", "average", "nice", "outstanding"),
  ar(-2,    -1,     0,         1,      3));

Map<String, Integer> WEIGHTS = zipMap(
        ar("bad", "poor", "average", "nice", "outstanding"),
        ar(-2, -1, 0, 1, 3));

public class CollectionFactory 
{
  public static <K,V> Map<K,V> newMap() 
  {
   return new HashMap<K,V>();
  }
}

package com.google.common.collect;

public final class Maps {
  public static <K, V> HashMap<K, V> newHashMap() {
    return new HashMap<K, V>();
  }

  public static <K, V> LinkedHashMap<K, V> newLinkedHashMap() {
    return new LinkedHashMap<K, V>();
  }

  public static <K extends Comparable, V> TreeMap<K, V> newTreeMap() {
    return new TreeMap<K, V>();
  }
}

      public <T> Set<T> set(T... ts) {
        return new HashSet<T>(Arrays.asList(ts));
      }

Map<Integer, List<String>> namesById = new HashMap();

Map<Integer, List<String>> namesById = new HashMap<Integer, List<String>>();

public class CollectionUtils {

  public static Set<T> set(T... ts) {
    return new HashSet<T>(Arrays.asList(ts));
  }

}

> public class CollectionUtils {
> 
>   public static Set<T> set(T... ts) {
>     return new HashSet<T>(Arrays.asList(ts));
>   }
> 
> }
>

    public static <T> Set<T> set(T... ts) {
        return new HashSet<T>(Arrays.asList(ts));
    }

Map map = CollectionUtils.map(mapEntry(CONSTANT_WITH_LONG_NAME,  "anotherStringConstant"),
                              mapEntry(CONSTANT_WITH_LONG_NAME1, "anotherStringConstant1"),
                              mapEntry(CONSTANT_WITH_LONG_NAME2, "anotherStringConstant2"),
                              mapEntry(CONSTANT_WITH_LONG_NAME3, "anotherStringConstant3"));

> Map map = CollectionUtils.map(mapEntry(CONSTANT_WITH_LONG_NAME,  "anotherStringConstant"),
>                               mapEntry(CONSTANT_WITH_LONG_NAME1, "anotherStringConstant1"),
>                               mapEntry(CONSTANT_WITH_LONG_NAME2, "anotherStringConstant2"),
>                               mapEntry(CONSTANT_WITH_LONG_NAME3, "anotherStringConstant3"));
>

Map<A,B> map = new HashMap<A,B>();
map.put(CONSTANT_WITH_LONG_NAME,  "anotherStringConstant");
map.put(CONSTANT_WITH_LONG_NAME1, "anotherStringConstant1");
map.put(CONSTANT_WITH_LONG_NAME2, "anotherStringConstant2");
map.put(CONSTANT_WITH_LONG_NAME3, "anotherStringConstant3");

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

public final class MapComposer<K,V> {

    private Map<K, V> map;

    private MapComposer(Map<K, V> map) {
        this.map = map;
    }

    public static <K,V> MapComposer<K,V> init(Map<K,V> map) {
        return new MapComposer<K,V>(map);
    }

    public static <K,V> MapComposer<K,V> initHashMap(Class<K> k,
Class<V> v) {
        return new MapComposer<K,V>(new HashMap<K,V>());
    }

    public Map<K, V> map() {
        return map;
    }

    public MapComposer<K,V> entry(K key, V value) {
        map.put(key, value);
        return this;
    }

}

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class Application {

    private Map<Integer, Long> map1 =
            MapComposer.initHashMap(Integer.class, Long.class).
            entry(1, 20L).
            entry(2, 30L).
            entry(3, 40L).
            map();

    private Map<String, Date> map2 =
            MapComposer.init(new HashMap<String, Date>()).
            entry("1", new Date(1)).
            entry("2", new Date(2)).
            entry("3", new Date(3)).
            map();

    public static void main(String[] args) throws Exception {
        Application application = new Application();
    }
}