--- a/src/java.base/share/classes/java/util/Collections.java	Fri Dec 28 15:19:14 2018 -0800
+++ b/src/java.base/share/classes/java/util/Collections.java	Sun Dec 30 08:57:24 2018 +0700
@@ -459,7 +459,7 @@
             for (int i=size; i>1; i--)
                 swap(list, i-1, rnd.nextInt(i));
         } else {
-            Object arr[] = list.toArray();
+            Object[] arr = list.toArray();
 
             // Shuffle array
             for (int i=size; i>1; i--)
@@ -5101,6 +5101,53 @@
             return new CopiesList<>(toIndex - fromIndex, element);
         }
 
+        @Override
+        public int hashCode() {
+            if (n == 0) return 1;
+            // hashCode of n repeating elements is 31^n + elementHash * Sum(31^k, k = 0..n-1)
+            // this implementation completes in O(log(n)) steps taking advantage of
+            // 31^(2*n) = (31^n)^2 and Sum(31^k, k = 0..(2*n-1)) = Sum(31^k, k = 0..n-1) * (31^n + 1)
+            int pow = 31;
+            int sum = 1;
+            for (int i = Integer.numberOfLeadingZeros(n) + 1; i < Integer.SIZE; i++) {
+                sum *= pow + 1;
+                pow *= pow;
+                if ((n << i) < 0) {
+                    pow *= 31;
+                    sum = sum * 31 + 1;
+                }
+            }
+            return pow + sum * (element == null ? 0 : element.hashCode());
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == this)
+                return true;
+            if (o instanceof CopiesList) {
+                CopiesList<?> other = (CopiesList<?>) o;
+                return n == other.n && (n == 0 || eq(element, other.element));
+            }
+            if (!(o instanceof List))
+                return false;
+
+            int remaining = n;
+            E e = element;
+            Iterator<?> itr = ((List<?>) o).iterator();
+            if (e == null) {
+                while (itr.hasNext() && remaining-- > 0) {
+                    if (itr.next() != null)
+                        return false;
+                }
+            } else {
+                while (itr.hasNext() && remaining-- > 0) {
+                    if (!e.equals(itr.next()))
+                        return false;
+                }
+            }
+            return remaining == 0 && !itr.hasNext();
+        }
+
         // Override default methods in Collection
         @Override
         public Stream<E> stream() {

--- a/test/jdk/java/util/Collections/NCopies.java	Fri Dec 28 15:19:14 2018 -0800
+++ b/test/jdk/java/util/Collections/NCopies.java	Sun Dec 30 08:57:24 2018 +0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,8 +28,11 @@
  * @author  Martin Buchholz
  */
 
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.AbstractList;
 import java.util.List;
+import java.util.Objects;
 
 public class NCopies {
     static volatile int passed = 0, failed = 0;
@@ -82,6 +85,56 @@
             checkEmpty(x.subList(x.size()/2, x.size()/2));
     }
 
+    private static <T> List<T> referenceNCopies(int n, T o) {
+        // A simplest correct implementation of nCopies to compare with the actual optimized implementation
+        return new AbstractList<>() {
+            public int size() { return n; }
+
+            public T get(int index) {
+                Objects.checkIndex(index, n);
+                return o;
+            }
+        };
+    }
+
+    private static void checkHashCode() {
+        int[] sizes = {0, 1, 2, 3, 5, 10, 31, 32, 100, 1000};
+        String[] elements = {null, "non-null"};
+        for (int size : sizes) {
+            for (String element : elements) {
+                int expectedHashCode = referenceNCopies(size, element).hashCode();
+                int actualHashCode = Collections.nCopies(size, element).hashCode();
+                check(expectedHashCode == actualHashCode,
+                        "Collections.nCopies(" + size + ", " + element + ").hashCode()");
+            }
+        }
+    }
+
+    private static void checkEquals() {
+        int[][] sizePairs = {{0, 0}, {0, 1}, {1, 0}, {1, 1}, {1, 2}, {2, 1}};
+        String[] elements = {null, "non-null"};
+        for (int[] pair : sizePairs) {
+            for (String element : elements) {
+                boolean equal = pair[0] == pair[1];
+                String msg = "[" + pair[0] + ", " + element + "] <=> [" + pair[1] + ", " + element + "]";
+                check(equal == Collections.nCopies(pair[0], element).equals(Collections.nCopies(pair[1], element)), msg);
+                check(equal == Collections.nCopies(pair[0], element).equals(referenceNCopies(pair[1], element)), msg);
+                check(equal == referenceNCopies(pair[0], element).equals(Collections.nCopies(pair[1], element)), msg);
+            }
+        }
+        List<String> nulls = Collections.nCopies(10, null);
+        List<String> nonNulls = Collections.nCopies(10, "non-null");
+        List<String> nullsButOne = new ArrayList<>(nulls);
+        nullsButOne.set(9, "non-null");
+        List<String> nonNullsButOne = new ArrayList<>(nonNulls);
+        nonNullsButOne.set(9, null);
+        check(!nulls.equals(nonNulls));
+        check(!nulls.equals(nullsButOne));
+        check(!nulls.equals(nonNullsButOne));
+        check(!nonNulls.equals(nonNullsButOne));
+        check(Collections.nCopies(0, null).equals(Collections.nCopies(0, "non-null")));
+    }
+
     public static void main(String[] args) {
         try {
             List<String> empty = Collections.nCopies(0, "foo");
@@ -92,6 +145,10 @@
             check(foos.size() == 42);
             checkFoos(foos.subList(foos.size()/2, foos.size()-1));
 
+            checkHashCode();
+
+            checkEquals();
+
         } catch (Throwable t) { unexpected(t); }
 
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);