Lab 08: Hashmaps | CS 61B Spring 2024
 1/9
CS 61B
Labs / Lab 08: Hashmaps
The FAQ for this lab can be found here.
In this lab, you?ll work on MyHashMap , a hashtable-based implementation of the Map61B
interface. This will be very similar to Lab 06, except this time we?re building a HashMap rather
than a TreeMap .
After you?ve completed your implementation, you?ll compare the performance of your
implementation to a list-based Map implementation ULLMap as well as the built-in Java
HashMap class (which also uses a hash table). We?ll also compare the performance of
MyHashMap when it uses different data structures to be the buckets.
We?ve created a class MyHashMap in MyHashMap.java , with very minimal starter code. Your
goal is to implement all of the methods in the Map61B interface from which MyHashMap
inherits, except remove , keySet and iterator (optional for Lab 08). For these, feel free to
throw an UnsupportedOperationException .
Note that your code will not compile until you implement all the methods of Map61B . You can
implement methods one at a time by writing the method signatures of all the required
methods, but throwing UnsupportedOperationException s for the implementations until you
get around to actually writing them.
The following is a quick animation of how a hash table works. N refers to the number of items
in the hash table, and M refers to the number of buckets.
We use an object?s hashCode modulo?d (%) by the number of buckets to determine which
bucket the object (represented by a shape) falls into. When the load factor is reached, we
Lab 08: Hashmaps
FAQ
Introduction
MyHashMap
Overview
Refresher Animation
Lab 08: Hashmaps | CS 61B Spring 2024
 2/9
multiply the number of buckets by the resizing factor and rehash all of the items, modulo-ing
them by the new number of buckets.
For the video animation below, the hash function is arbitrary and outputs a random integer for
each shape (the object) that is inputted.
Quick Hashing Animation
Credits to Meshan Khosla for this animation!
You might recall from lecture that when we build a hash table, we can choose a number of
different data structures to be the buckets. The classic approach is to choose a LinkedList .
But we can also choose ArrayList s, TreeSet s, or even other crazier data structures like
PriorityQueue s or even other HashSet s!
Skeleton Code
Lab 08: Hashmaps | CS 61B Spring 2024
 3/9
During this lab, we will try out hash tables with different data structures for each of the
buckets, and see empirically if there is an asymptotic difference between using different data
structures as hash table buckets.
For this lab, we will be trying out LinkedList , ArrayList , HashSet , Stack , and
ArrayDeque (unfortunately, no TreeSet or PriorityQueue like the diagram above shows due
to excessive boilerplate, though you?re welcome to try it if you?d like). That?s a lot of classes!
You can imagine that if we implemented MyHashMap without much care, it would take a lot of
effort with Find + Replace to be able to change out the bucket type with a different bucket
type. For example, if we wanted to change all our ArrayList buckets to LinkedList buckets,
we would have to Find + Replace for all occurrences of ArrayList and replace that with
LinkedList . This is not ideal - for example, we may have a non-bucket component that relies
on some ArrayList methods. We wouldn?t want to ruin our code by changing that to a
LinkedList !
The purpose of the starter code is to have an easier way to try out different bucket types with
MyHashMap . It accomplishes this through polymorphism and inheritance, which we learned
about earlier this semester. It also makes use of factory methods and classes, which are
utility code used to create objects. This is a common pattern when working with more
advanced code, though the details are out-of-scope for 61B.
MyHashMap implements the Map61B interface through use of a hash table. In the starter code,
we give the instance variable private Collection<Node>[] buckets , which is the underlying
data structure of the hash table. Let?s unpack what this code means:
buckets is a private variable in the MyHashMap class.
It is an array (or table) of Collection<Node> objects, where each Collection of Node s
represents a single bucket in the hash table
Node is a private (nested) helper class we give that stores a single key-value mapping. The
starter code for this class should be straightforward to understand, and should not require
any modification.
?
private Collection<Node>[] buckets;
Copy
?
?
protected class Node {
K key;
V value;
Node(K k, V v) {
key = k;
value = v;
Copy
Lab 08: Hashmaps | CS 61B Spring 2024
 4/9
java.util.Collection is an interface which most data structures inherit from, and it
represents a group of objects. The Collection interface supports methods such as add ,
remove , and iterator . Many data structures in java.util implement Collection ,
including ArrayList , LinkedList , TreeSet , HashSet , PriorityQueue , and many
others. Note that because these data structures implement Collection , we can assign
them to a variable of static type Collection with polymorphism.
Therefore, our array of Collection<Node> objects can be instantiated by many different
types of data structures, e.g. LinkedList<Node> or ArrayList<Node> . Make sure your
buckets generalize to any Collection! See the below warning for how to do this.
When creating a new Collection<Node>[] to store in our buckets variable, be aware that
in Java, you cannot create an array of parameterized type. Collection<Node> is a
parameterized type, because we parameterize the Collection class with the Node class.
Therefore, Java disallows new Collection<Node>[size] , for any given size . If you try to
do this, you will get a   Generic array creation   error.
WARNING
To get around this, you should instead create a new Collection[size] , where size is
the desired size.
The elements of a Collection[] can be a collection of any type, like a
Collection<Integer> or a Collection<Node> . For our purposes, we will only add
elements of type Collection<Node> to our Collection[] .
The mechanism by which different implementations of the hash table implement different
buckets is through a factory method protected Collection<Node> createBucket() , which
simply returns a Collection . For MyHashMap.java , you can choose any data structure you?d
like. For example, if you choose LinkedList , the body of createBucket would simply be:
WARNING
Instead of creating new bucket data structures with the new operator, you must use
the createBucket method instead. This might seem useless at first, but it allows our
factory classes to override the createBucket method in order to provide different data
structures as each of the buckets.
}
}
?
?
?
?
protected Collection<Node> createBucket() {
return new LinkedList<>();
}
Copy
Lab 08: Hashmaps | CS 61B Spring 2024
 5/9
In MyHashMap , you can just have this method return a new LinkedList or ArrayList .
You should implement the following constructors:
Some additional requirements for MyHashMap are below:
Your hash map should initially have a number of buckets equal to initialCapacity . You
should increase the size of your MyHashMap when the load factor exceeds the maximum
loadFactor threshold. Recall that the current load factor can be computed as
loadFactor = N/M , where N is the number of elements in the map and M is the number
of buckets. The load factor represents the amount of elements per bucket, on average. If
initialCapacity and loadFactor aren?t given, you should set defaults initialCapacity
= 16 and loadFactor = 0.75 (as Java?s built-in HashMap does).
You should handle collisions with separate chaining. You should not use any libraries other
than the bucket classes, Collection , Iterator , Set , and HashSet . For more detail on
how you should implement separate chaining, see the Skeleton Code section above.
Because we use a Collection<Node>[] for our buckets , when implementing MyHashMap ,
you are restricted to using methods that are specified by the Collection interface. When
you are searching for a Node in a Collection , iterate over the Collection , and find
the Node whose key is .equals() to the desired key.
If the same key is inserted more than once, the value should be updated each time (i.e., no
Node s should be added). You can assume null keys will never be inserted.
When resizing, make sure to multiplicatively (geometrically) resize, not additively
(arithmetically) resize. You are not required to resize down.
MyHashMap operations should all be constant amortized time, assuming that the hashCode
of any objects inserted spread things out nicely (recall: every Object in Java has its own
hashCode() method).
hashCode() can return a negative value! Java?s modulo operator % will return a negative
value for negative inputs, but we need to send items to a bucket in the range . There are
a myriad of ways to handle this:
Implementation Requirements
public MyHashMap();
public MyHashMap(int initialCapacity);
public MyHashMap(int initialCapacity, double loadFactor);
Copy
?
?
?
?
?
?
[0, M)
(Recommended) You can use Math.floorMod() in place of % for the modulo operation.
This has a non-negative range of values, similar to Python?s modulo.
1
Lab 08: Hashmaps | CS 61B Spring 2024
 6/9
TASK
Complete the MyHashMap class according to the specifications in Map61B and the
guidelines above.
You may find the following resources useful
Lecture slides:
Lecture 19
Lecture 20
The following may contain antiquated code or use unfamiliar techniques, but should still be
useful:
ULLMap.java (provided), a working unordered linked list based Map61B implementation
You can test your implementation using TestMyHashMap.java . Some of the tests are quite
tricky and do weird stuff we haven?t learned in 61B. The comments will prove useful to see
what the tests are actually doing.
If you?ve correctly implemented generic Collection buckets, you should also be passing the
tests in TestMyHashMapBuckets.java . The TestMyHashMapBuckets.java file simply calls
methods in TestMyHashMap.java for each of the different map subclasses that implement a
different bucket data structure. Make sure you?ve correctly implemented MyHashMap using the
factory methods provided (i.e., createBucket ) for TestHashMapBuckets.java to pass.
If you choose to implement the additional remove , keySet , and iterator methods, we
provide some tests in TestHashMapExtra.java .
If the resulting value after the % operation is negative, you can add the size of the array to
it.
2
You can use the Math.abs() function to convert the negative value to a positive value.
Note that , , and are not equivalent in general! We?re just
using the modulo operation here to make sure we have a valid index. We don?t necessarily
care too much about the exact bucket the item goes into, because a good hash function
should spread things out nicely over positive and negative numbers.
3
 Ox O mod m  Ox mod m O x mod m
Option (3) but with a bitmask (don?t worry if you don?t know what this means). This is out?of-scope for 61B, but some of the resources do this, which is why we?ve put it here.
4
Resources
?
?
?
?
Testing
Lab 08: Hashmaps | CS 61B Spring 2024
 7/9
There are two interactive speed tests provided in InsertRandomSpeedTest.java and
InsertInOrderSpeedTest.java . Do not attempt to run these tests before you?ve completed
MyHashMap . Once you?re ready, you can run the tests in IntelliJ.
The InsertRandomSpeedTest class performs tests on element-insertion speed of your
MyHashMap , ULLMap (provided), and Java?s built-in HashMap. It works by asking the user for
an input size N , then generates N Strings of length 10 and inserts them into the maps as
<String, Integer> pairs.
Try it out and see how your data structure scales with N compared to the naive and industrial?strength implementations. Record your results in the provided file named src/results.txt .
There is no standard format required for your results, and there is no required number of data
points. We expect you to write at least a sentence or two with your observations, though.
Now try running InsertInOrderSpeedTest , which behaves similarly to
InsertRandomSpeedTest , except this time the String s in <String, Integer> key-value
pairs are inserted in lexicographically-increasing order. Your code should be in the rough
ballpark of Java?s built in solution  C say, within a factor of 10 or so. What this tells us is that
state-of-the-art HashMaps are relatively easy to implement compared to state-of-the-art
TreeMaps . Consider this relation with BSTMap / TreeMap and other data structures - are there
certain instances where a Hashmap might be better? Discuss this with your peers, and add
your answer to results.txt .
If you?ve correctly implemented generic Collection buckets, most of the work is done! We
can directly compare the different data structures used to implement buckets. We provide
speed/BucketsSpeedTest.java , which is an interactive test that queries the user for an
integer L for the length of string to use on subsequent operations. Then, in a loop, it queries
the user for an integer N , and runs a speed test on your MyHashMap using different types of
buckets.
Try it out and compare how the different implementations scale with N . Discuss your results
with your peers, and record your responses in results.txt .
You might notice that our implementation using HashSet s as buckets searches for a Node by
iterating over the entire data structure. But we know hash tables support more efficient
lookups than that. Would our hash table speed up asymptotically if we were able to use a
constant-time search over the HashSet ? You do not need to implement anything new here,
just discuss with your peers, and record your ideas in results.txt .
Speed Testing
Different Bucket Types
Lab 08: Hashmaps | CS 61B Spring 2024
 8/9
TASK
Run the above speed tests in the speed directory and record your results in
results.txt .
The lab is out of 5 points. There is one hidden test on Gradescope (that checks your
results.txt ). The rest of the tests are local. If you pass all the local tests and fill out the
results.txt file sufficiently, you will get full credit on Gradescope.
Each of the following is worth points and corresponds to a unit test:
Generics
clear
containsKey
get
size
put
Functionality
Resizing
Edge cases
Buckets (all of TestMyHashMapBuckets )
results.txt (not tested locally, but on the Gradescope autograder)
As mentioned, if you are not implementing the optional exercises, throw an
UnsupportedOperationException , like below:
Just as you did for the previous assignments, add, commit, then push your Lab 08 code to
GitHub. Then, submit to Gradescope to test your code.
These will not be graded, but you can still receive feedback with the given tests.
Implement the methods remove(K key) and remove(K key, V value) , in your MyHashMap
class. For an extra challenge, implement keySet() and iterator() without using a second
Deliverables and Scoring

throw new UnsupportedOperationException();
Copy
Submission
Optional Exercises
Lab 08: Hashmaps | CS 61B Spring 2024
 9/9
instance variable to store the set of keys.
For remove , you should return null if the argument key does not exist in the MyHashMap .
Otherwise, delete the key-value pair (key, value) and return the associated value.

請(qǐng)加QQ：99515681  郵箱：99515681@qq.com   WX：codinghelp