diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99481ca..8ece77f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 1.14.1
+
+* Make `Equality` implementations accept `null` as argument to `hash`.
+
 ## 1.14.0
 
 * Add `CombinedListView`, a view of several lists concatenated together.
diff --git a/lib/src/equality.dart b/lib/src/equality.dart
index aa5effa..a970664 100644
--- a/lib/src/equality.dart
+++ b/lib/src/equality.dart
@@ -94,6 +94,10 @@
 /// Equality on iterables.
 ///
 /// Two iterables are equal if they have the same elements in the same order.
+///
+/// The [equals] and [hash] methods accepts `null` values,
+/// even if the [isValidKey] returns `false` for `null`.
+/// The [hash] of `null` is `null.hashCode`.
 class IterableEquality<E> implements Equality<Iterable<E>> {
   final Equality<E> _elementEquality;
   const IterableEquality(
@@ -114,6 +118,7 @@
   }
 
   int hash(Iterable<E> elements) {
+    if (elements == null) return null.hashCode;
     // Jenkins's one-at-a-time hash function.
     int hash = 0;
     for (E element in elements) {
@@ -138,29 +143,34 @@
 ///
 /// This is effectively the same as [IterableEquality] except that it
 /// accesses elements by index instead of through iteration.
+///
+/// The [equals] and [hash] methods accepts `null` values,
+/// even if the [isValidKey] returns `false` for `null`.
+/// The [hash] of `null` is `null.hashCode`.
 class ListEquality<E> implements Equality<List<E>> {
   final Equality<E> _elementEquality;
   const ListEquality([Equality<E> elementEquality = const DefaultEquality()])
       : _elementEquality = elementEquality;
 
-  bool equals(List<E> e1, List<E> e2) {
-    if (identical(e1, e2)) return true;
-    if (e1 == null || e2 == null) return false;
-    int length = e1.length;
-    if (length != e2.length) return false;
+  bool equals(List<E> list1, List<E> list2) {
+    if (identical(list1, list2)) return true;
+    if (list1 == null || list2 == null) return false;
+    int length = list1.length;
+    if (length != list2.length) return false;
     for (int i = 0; i < length; i++) {
-      if (!_elementEquality.equals(e1[i], e2[i])) return false;
+      if (!_elementEquality.equals(list1[i], list2[i])) return false;
     }
     return true;
   }
 
-  int hash(List<E> e) {
+  int hash(List<E> list) {
+    if (elements == null) return null.hashCode;
     // Jenkins's one-at-a-time hash function.
     // This code is almost identical to the one in IterableEquality, except
     // that it uses indexing instead of iterating to get the elements.
     int hash = 0;
-    for (int i = 0; i < e.length; i++) {
-      int c = _elementEquality.hash(e[i]);
+    for (int i = 0; i < list.length; i++) {
+      int c = _elementEquality.hash(list[i]);
       hash = (hash + c) & _HASH_MASK;
       hash = (hash + (hash << 10)) & _HASH_MASK;
       hash ^= (hash >> 6);
@@ -180,21 +190,21 @@
 
   const _UnorderedEquality(this._elementEquality);
 
-  bool equals(T e1, T e2) {
-    if (identical(e1, e2)) return true;
-    if (e1 == null || e2 == null) return false;
+  bool equals(T elements1, T elements2) {
+    if (identical(elements1, elements2)) return true;
+    if (elements1 == null || elements2 == null) return false;
     HashMap<E, int> counts = new HashMap(
         equals: _elementEquality.equals,
         hashCode: _elementEquality.hash,
         isValidKey: _elementEquality.isValidKey);
     int length = 0;
-    for (var e in e1) {
+    for (var e in elements1) {
       int count = counts[e];
       if (count == null) count = 0;
       counts[e] = count + 1;
       length++;
     }
-    for (var e in e2) {
+    for (var e in elements2) {
       int count = counts[e];
       if (count == null || count == 0) return false;
       counts[e] = count - 1;
@@ -203,9 +213,10 @@
     return length == 0;
   }
 
-  int hash(T e) {
+  int hash(T elements) {
+    if (elements == null) return null.hashCode;
     int hash = 0;
-    for (E element in e) {
+    for (E element in elements) {
       int c = _elementEquality.hash(element);
       hash = (hash + c) & _HASH_MASK;
     }
@@ -237,6 +248,10 @@
 ///
 /// This equality behaves the same as [UnorderedIterableEquality] except that
 /// it expects sets instead of iterables as arguments.
+///
+/// The [equals] and [hash] methods accepts `null` values,
+/// even if the [isValidKey] returns `false` for `null`.
+/// The [hash] of `null` is `null.hashCode`.
 class SetEquality<E> extends _UnorderedEquality<E, Set<E>> {
   const SetEquality([Equality<E> elementEquality = const DefaultEquality()])
       : super(elementEquality);
@@ -271,6 +286,10 @@
 ///
 /// Two maps are equal if they have the same number of entries, and if the
 /// entries of the two maps are pairwise equal on both key and value.
+///
+/// The [equals] and [hash] methods accepts `null` values,
+/// even if the [isValidKey] returns `false` for `null`.
+/// The [hash] of `null` is `null.hashCode`.
 class MapEquality<K, V> implements Equality<Map<K, V>> {
   final Equality<K> _keyEquality;
   final Equality<V> _valueEquality;
@@ -280,20 +299,20 @@
       : _keyEquality = keys,
         _valueEquality = values;
 
-  bool equals(Map<K, V> e1, Map<K, V> e2) {
-    if (identical(e1, e2)) return true;
-    if (e1 == null || e2 == null) return false;
-    int length = e1.length;
-    if (length != e2.length) return false;
+  bool equals(Map<K, V> map1, Map<K, V> map2) {
+    if (identical(map1, map2)) return true;
+    if (map1 == null || map2 == null) return false;
+    int length = map1.length;
+    if (length != map2.length) return false;
     Map<_MapEntry, int> equalElementCounts = new HashMap();
-    for (K key in e1.keys) {
-      _MapEntry entry = new _MapEntry(this, key, e1[key]);
+    for (K key in map1.keys) {
+      _MapEntry entry = new _MapEntry(this, key, map1[key]);
       int count = equalElementCounts[entry];
       if (count == null) count = 0;
       equalElementCounts[entry] = count + 1;
     }
-    for (K key in e2.keys) {
-      _MapEntry entry = new _MapEntry(this, key, e2[key]);
+    for (K key in map2.keys) {
+      _MapEntry entry = new _MapEntry(this, key, map2[key]);
       int count = equalElementCounts[entry];
       if (count == null || count == 0) return false;
       equalElementCounts[entry] = count - 1;
@@ -302,6 +321,7 @@
   }
 
   int hash(Map<K, V> map) {
+    if (map == null) return null.hashCode;
     int hash = 0;
     for (K key in map.keys) {
       int keyHash = _keyEquality.hash(key);
@@ -348,7 +368,7 @@
     for (Equality<E> eq in _equalities) {
       if (eq.isValidKey(e)) return eq.hash(e);
     }
-    return -1;
+    return 0;
   }
 
   bool isValidKey(Object o) {
diff --git a/pubspec.yaml b/pubspec.yaml
index 75104ff..4ba307d 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: collection
-version: 1.14.0+1
+version: 1.14.1
 author: Dart Team <misc@dartlang.org>
 description: Collections and utilities functions and classes related to collections.
 homepage: https://www.github.com/dart-lang/collection
diff --git a/test/equality_test.dart b/test/equality_test.dart
index f407fab..63399c1 100644
--- a/test/equality_test.dart
+++ b/test/equality_test.dart
@@ -202,6 +202,32 @@
       expect(firstObjectEquality.isValidKey([{}]), isFalse);
     });
   });
+
+  test("Equality accepts null", () {
+    var ie = new IterableEquality();
+    var le = new ListEquality();
+    var se = new SetEquality();
+    var me = new MapEquality();
+    expect(ie.equals(null, null), true);
+    expect(ie.equals([], null), false);
+    expect(ie.equals(null, []), false);
+    expect(ie.hash(null), null.hashCode);
+
+    expect(le.equals(null, null), true);
+    expect(le.equals([], null), false);
+    expect(le.equals(null, []), false);
+    expect(le.hash(null), null.hashCode);
+
+    expect(se.equals(null, null), true);
+    expect(se.equals(new Set(), null), false);
+    expect(se.equals(null, new Set()), false);
+    expect(se.hash(null), null.hashCode);
+
+    expect(me.equals(null, null), true);
+    expect(me.equals({}, null), false);
+    expect(me.equals(null, {}), false);
+    expect(me.hash(null), null.hashCode);
+  });
 }
 
 /// Wrapper objects for an `id` value.