Special-case primitive WrappedArray types when creating Streams

This was already done for `Array` in the same way. Streams produced by
`Arrays.stream` can be faster than going through a `Stepper`.

Author: szeiger

src/main/scala/scala/compat/java8/StreamConverters.scala

@@ -292,6 +292,24 @@ with converterImpl.Priority1AccumulatorConverters
     def parStream: LongStream = seqStream.parallel
   }
 
+  implicit final class EnrichDoubleWrappedArrayWithStream(private val a: collection.mutable.WrappedArray[Double])
+    extends AnyVal with MakesSequentialStream[java.lang.Double, DoubleStream] with MakesParallelStream[java.lang.Double, DoubleStream] {
+    def seqStream: DoubleStream = java.util.Arrays.stream(a.array)
+    def parStream: DoubleStream = seqStream.parallel
+  }
+
+  implicit final class EnrichIntWrappedArrayWithStream(private val a: collection.mutable.WrappedArray[Int])
+    extends AnyVal with MakesSequentialStream[java.lang.Integer, IntStream] with MakesParallelStream[java.lang.Integer, IntStream] {
+    def seqStream: IntStream = java.util.Arrays.stream(a.array)
+    def parStream: IntStream = seqStream.parallel
+  }
+
+  implicit final class EnrichLongWrappedArrayWithStream(private val a: collection.mutable.WrappedArray[Long])
+    extends AnyVal with MakesSequentialStream[java.lang.Long, LongStream] with MakesParallelStream[java.lang.Long, LongStream] {
+    def seqStream: LongStream = java.util.Arrays.stream(a.array)
+    def parStream: LongStream = seqStream.parallel
+  }
+
   implicit val primitiveAccumulateDoubleStream = new PrimitiveStreamAccumulator[Stream[Double], DoubleAccumulator] {
     def streamAccumulate(stream: Stream[Double]): DoubleAccumulator = 
       stream.collect(DoubleAccumulator.supplier, DoubleAccumulator.boxedAdder, DoubleAccumulator.merger)

src/test/scala/scala/compat/java8/StreamConvertersTest.scala

@@ -255,7 +255,7 @@ class StreamConvertersTest {
   def streamMaterialization(): Unit = {
     val coll = collection.mutable.WrappedArray.make[Int](Array(1,2,3))
     val streamize = implicitly[collection.mutable.WrappedArray[Int] => MakesSequentialStream[java.lang.Integer, IntStream]]
-    assertTrue(streamize(coll).getClass.getName.contains("EnrichScalaCollectionWithSeqIntStream"))
+    assertTrue(streamize(coll).getClass.getName.contains("EnrichIntWrappedArrayWithStream"))
     val steppize = implicitly[collection.mutable.WrappedArray[Int] => MakesStepper[IntStepper]]
     assertTrue(steppize(coll).getClass.getName.contains("RichArrayIntCanStep"))
   }