--- old/src/java.base/share/classes/java/util/Collections.java	2018-12-03 13:48:37.616008000 +0700
+++ new/src/java.base/share/classes/java/util/Collections.java	2018-12-03 13:48:37.216008000 +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,25 @@
             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 default methods in Collection
         @Override
         public Stream<E> stream() {
--- old/test/jdk/java/util/Collections/NCopies.java	2018-12-03 13:48:38.480008000 +0700
+++ new/test/jdk/java/util/Collections/NCopies.java	2018-12-03 13:48:38.120008000 +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
@@ -29,7 +29,9 @@
  */
 
 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;
@@ -81,6 +83,31 @@
             check(x.get(x.size()/2).equals("foo"));
             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()");
+            }
+        }
+    }
 
     public static void main(String[] args) {
         try {
@@ -92,6 +119,8 @@
             check(foos.size() == 42);
             checkFoos(foos.subList(foos.size()/2, foos.size()-1));
 
+            checkHashCode();
+
         } catch (Throwable t) { unexpected(t); }
 
         System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);