langref.org - java and clojure

View Category

Maps

Declaration

Define an empty map

java

Map map = new HashMap();

clojure

(def m {})

Define an unmodifiable empty map

java

Map empty = Collections.EMPTY_MAP;

SortedMap empty = MapUtils.EMPTY_SORTED_MAP;

clojure

; Clojure maps are immutable
(def m {})

Define an initial map

Define the map {circle:1, triangle:3, square:4}

java

Map shapes = new HashMap();
shapes.put("circle", 1);
shapes.put("triangle", 3);
shapes.put("square", 4);

Map shapes = new HashMap() {{ put("circle",1); put("triangle",3); put("square",4); }}

clojure

(def m '{circle 1 triangle 1 square 4})

Access

Check if a key exists in a map

Given a map pets {joe:cat,mary:turtle,bill:canary} print "ok" if an pet exists for "mary"

java

if (pets.containsKey("mary")) System.out.println("ok");

clojure

(if (contains? '{joe cat mary turtle bill canary} 'mary)
(println "ok"))

Retrieve a value from a map

Given a map pets {joe:cat,mary:turtle,bill:canary} print the pet for "joe" ("cat")

java

String pet = pets.get("joe");

clojure

(def pets '{joe cat mary turtle bill canary})

(println (get pets 'joe))

Add an entry to a map

Given an empty pets map, add the mapping from "rob" to "dog"

java

pets.put("rob", "dog");

clojure

(assoc {} 'rob 'dog)

Remove an entry from a map

Given a map pets {joe:cat,mary:turtle,bill:canary} remove the mapping for "bill" and print "canary"

java

System.out.println(pets.remove("bill"))

clojure

; Maps are immutable
; The following expression will return a new map without the 'bill key
(let [pets '{joe cat mary turtle bill canary}]
(println (get pets 'bill))
(dissoc pets 'bill))

Algorithms

Create a histogram map from a list

Given the list [a,b,a,c,b,b], produce a map {a:2, b:3, c:1} which contains the count of each unique item in the list

java

Map map = new HashMap();
for (Iterator it = list.iterator(); it.hasNext();) {
String s = (String) it.next();
if (!map.containsKey(s)) {
map.put(s, new Integer(1));
} else {
map.put(s, new Integer(((Integer)map.get(s)).intValue() + 1));
}
}

LinkedMap histogram = new LinkedMap();

for (Object letter : list)
histogram.put(letter, !histogram.containsKey(letter) ? 1 : MapUtils.getIntValue(histogram, letter) + 1);

clojure

(let [l '[a b a c b b]]
(loop [m {}
d (distinct l)]
(let [item (first d)]
(if (zero? (count d))
m
(recur
(assoc m
item
(count
(filter #(= item %) l)))
(rest d))))))

(->> [:a :b :a :c :b :b]
(group-by identity)
(reduce (fn [m e] (assoc m (first e) (count (second e)))) {}))

(reduce conj {} (for [[x xs] (group-by identity "abacbb")] [x (count xs)]))

(frequencies ["a","b","a","c","b","b"])

(frequencies '[a b a c b b])

Categorise a list

Given the list [one, two, three, four, five] produce a map {3:[one, two], 4:[four, five], 5:[three]} which sorts elements into map entries based on their length

java

SortedMap<Integer, List<String> > map = new TreeMap<Integer, List<String> >(); int key; List<String> vlist;

for (String item : list)
{
key = item.length(); vlist = map.containsKey(key) ? map.get(key) : new ArrayList<String>();
vlist.add(item); map.put(key, vlist);
}

MultiValueMap map = new MultiValueMap();
for (Object item : list) map.put(((String) item).length(), item);

clojure

(loop [m {}
l ["one" "two" "three" "four" "five"]]
(if (zero? (count l))
m
(let [item (first l)
key (count item)]
(recur
(assoc m key (cons item (get m key [])))
(rest l)))))

(group-by count ["one" "two" "three" "four" "five"])