Arrays methods

[Brian Goetz]

I did a pruning pass on the Arrays methods, and we're down to:

     public static <T> Spliterator<T> spliterator(T[] array)
     public static <T> Spliterator<T> spliterator(T[] array, int 
fromIndex, int toIndex)

     public static Spliterator.OfInt spliterator(int[] array)
     public static Spliterator.OfInt spliterator(int[] array, int 
fromIndex, int toIndex)

     public static <T> Stream<T> stream(T[] array)
     public static <T> Stream<T> stream(T[] array, int fromIndex, int 
toIndex)

     public static IntStream stream(int[] source)
     public static IntStream stream(int[] source, int fromIndex, int 
toIndex)

     public static <T> Stream<T> parallelStream(T[] array)
     public static <T> Stream<T> parallelStream(T[] array, int 
fromIndex, int toIndex)

     public static IntStream parallelStream(int[] array)
     public static IntStream parallelStream(int[] array, int fromIndex, 
int toIndex)

(and Double/Long versions when those are ready.)

The remaining one on my to-do list is something to enable parallel 
updating/filling of arrays.  The "obvious" thing is something like:

   fill(array, int -> T)
   replaceAll(array, (int, T) -> T)

There's a combinatorial explosion here:
  array types  x  (whole array, from-to)  x  (parallel, sequential)
               x  op kind (fill, replace, replace-if, etc)

and what feels like a perennial game of whack-a-mole.


I think a better option is just adding a small number of methods to take 
an array and produce a stream of valid indexes:

   IntStream indexes(T[])
   IntStream indexes(int[])
   ...

Because then the user can mix and match his own:

   // generate
   Arrays.indexes(array).forEach(i -> { array[i] = f(i) });

   // replace-all
   Arrays.indexes(array).forEach(i -> { array[i] = f(i, array[i]) });

   // replace-all-conditional
   Arrays.indexes(array).filter(...)
                        .forEach(i -> { array[i] = ... });

It also works on arrays of bytes, shorts, etc (because the array indexes 
are always an IntStream), whereas the more specific forms above would 
likely be restricted to int/long/double.