IndexedSeqOps overrides iterator to provide a fast indexed iterator (presumably; I didn't test anything or research it).

Obviously a tight loop with array indexing must be faster, but how much faster (IRL) and at what cost in code?

I agree, but I want it as fast as Java's ArrayList

Do you know that it is slower?

@Ichoran I don't think Java's ArrayList is slower; Java's ArrayList overrides the forEach method

I think the question is: did you test that your change makes foreach faster than the current version based on iterator?

There's an existing benchmark class: https://github.com/scala/scala/blob/2.13.x/test/benchmarks/src/main/scala/scala/collection/mutable/ArrayBufferBenchmark.scala. You could add some benchmarks to compare before/after, and also compare to Java's ArrayList.

I got the number with numbers:

jmh:run -i 10 -wi 5 -f2 -t1 scala.collection.mutable.ArrayBufferBenchmark

old --

[info] Benchmark                     (size)  Mode  Cnt     Score    Error  Units
[info] ArrayBufferBenchmark.foreach   10000  avgt   10  6198.500 ± 68.184  ns/op

--- array

[info] Benchmark                     (size)  Mode  Cnt     Score    Error  Units
[info] ArrayBufferBenchmark.foreach   10000  avgt   10  3293.280 ± 45.680  ns/op

for 10000 elements only

Okay, that looks pretty compelling! I guess the JIT compiler is not doing a good job eliding the extra work in this case.

With this numbers, adding some overrides looks worthwhile indeed.

Questions:

• how can we come up with a selection of methods to override that is not arbitrary?
• there are more array-based collections, the same overrides should be applied to all of them: mutable.ArraySeq, immutable.ArraySeq, mutable.ArrayDeque (-> Queue / Stack). They are all classes (not traits), so adding overrides should be possible in a binary compatible manner.
• how can we share code (implementations, overriding signatures)?

Probably it's worth looking at ArrayOps. Can we re-use these implementations?

I totally missed other types, because I wanted to use the ArrayBuffer as an ArrayDeque.

Maybe we should add these optimizations in StrictOptimizedSeqOps/StrictOptimizedIterableOps?

I don't think the StrictOptimized traits are the right place, for example ArraySeq.foreach is not overridden at all, it's inherited from IterableOnceOps.