src/java.base/share/classes/java/util/Collections.java

rev 48215 : 8060192: Add default method <A> A[] Collection.toArray(IntFunction<A[]> generator)
Reviewed-by: martin, forax, psandoz

*** 30,39 ****
--- 30,40 ----
  import java.lang.reflect.Array;
  import java.util.function.BiConsumer;
  import java.util.function.BiFunction;
  import java.util.function.Consumer;
  import java.util.function.Function;
+ import java.util.function.IntFunction;
  import java.util.function.Predicate;
  import java.util.function.UnaryOperator;
  import java.util.stream.IntStream;
  import java.util.stream.Stream;
  import java.util.stream.StreamSupport;
*** 1030,1039 ****
--- 1031,1041 ----
          public int size()                          {return c.size();}
          public boolean isEmpty()                   {return c.isEmpty();}
          public boolean contains(Object o)          {return c.contains(o);}
          public Object[] toArray()                  {return c.toArray();}
          public <T> T[] toArray(T[] a)              {return c.toArray(a);}
+         public <T> T[] toArray(IntFunction<T[]> f) {return c.toArray(f);}
          public String toString()                   {return c.toString();}
  
          public Iterator<E> iterator() {
              return new Iterator<E>() {
                  private final Iterator<? extends E> i = c.iterator();
*** 2017,2026 ****
--- 2019,2031 ----
              synchronized (mutex) {return c.toArray();}
          }
          public <T> T[] toArray(T[] a) {
              synchronized (mutex) {return c.toArray(a);}
          }
+         public <T> T[] toArray(IntFunction<T[]> f) {
+             synchronized (mutex) {return c.toArray(f);}
+         }
  
          public Iterator<E> iterator() {
              return c.iterator(); // Must be manually synched by user!
          }
  
*** 3051,3060 ****
--- 3056,3066 ----
          public int size()                          { return c.size(); }
          public boolean isEmpty()                   { return c.isEmpty(); }
          public boolean contains(Object o)          { return c.contains(o); }
          public Object[] toArray()                  { return c.toArray(); }
          public <T> T[] toArray(T[] a)              { return c.toArray(a); }
+         public <T> T[] toArray(IntFunction<T[]> f) { return c.toArray(f); }
          public String toString()                   { return c.toString(); }
          public boolean remove(Object o)            { return c.remove(o); }
          public void clear()                        {        c.clear(); }
  
          public boolean containsAll(Collection<?> coll) {
*** 5566,5579 ****
          public boolean contains(Object o) { return q.contains(o); }
          public boolean remove(Object o)   { return q.remove(o); }
          public Iterator<E> iterator()     { return q.iterator(); }
          public Object[] toArray()         { return q.toArray(); }
          public <T> T[] toArray(T[] a)     { return q.toArray(a); }
          public String toString()          { return q.toString(); }
!         public boolean containsAll(Collection<?> c) {return q.containsAll(c);}
!         public boolean removeAll(Collection<?> c)   {return q.removeAll(c);}
!         public boolean retainAll(Collection<?> c)   {return q.retainAll(c);}
          // We use inherited addAll; forwarding addAll would be wrong
  
          // Override default methods in Collection
          @Override
          public void forEach(Consumer<? super E> action) {q.forEach(action);}
--- 5572,5586 ----
          public boolean contains(Object o)           { return q.contains(o); }
          public boolean remove(Object o)             { return q.remove(o); }
          public Iterator<E> iterator()               { return q.iterator(); }
          public Object[] toArray()                   { return q.toArray(); }
          public <T> T[] toArray(T[] a)               { return q.toArray(a); }
+         public <T> T[] toArray(IntFunction<T[]> f)  { return q.toArray(f); }
          public String toString()                    { return q.toString(); }
!         public boolean containsAll(Collection<?> c) { return q.containsAll(c); }
!         public boolean removeAll(Collection<?> c)   { return q.removeAll(c); }
!         public boolean retainAll(Collection<?> c)   { return q.retainAll(c); }
          // We use inherited addAll; forwarding addAll would be wrong
  
          // Override default methods in Collection
          @Override
          public void forEach(Consumer<? super E> action) {q.forEach(action);}