You right.  However, the reference implementation of Arrays.fill() (I
mean the one from the Sun) is implemented as a simple loop filling an
array slot by slot.

A few years ago I wrote an alternative version of the array fill based
on System.arraycopy(), which without an extra optimizations normally
performed by the server JVM is even 5 times faster (sometimes more) than
the original Arrays.fill() implementation.  (The server JVM usually
still executes it faster, but it's not as significant as in a case of
the client JVM -- typically not faster than 2 times.)

The original algorithm is there:
<http://groups.google.com/group/pl.comp.lang.java/msg/99526c39faf0338c?>
The thread includes also a performance test driver, and some test
results.  (Sorry, the thread is in Polish.  But at least the code should
be clear for everyone, I hope...)

piotr

Not necessarily.  The maximum length limit may be quite easily
eliminated using longer string when needed.  Here is simple realization
of the idea:

public class FilledStringGenerator {
  private String source;

  public FilledStringGenerator(String initialSource) {
    if (initialSource == null
        || initialSource.length() == 0)
      throw new IllegalArgumentException();
    this.source = initialSource;
  }

  public String generate(int length) {
    if (length < 0)
      throw new IllegalArgumentException();
    String source = this.source;
    while (source.length() < length)
      this.source = source += source;
    return source.substring(0, length);
  }
}

Sample usage:

FilledStringGenerator fsg = new FilledStringGenerator("0");
fsg.generate(1);
fsg.generate(150);
fsg.generate(70);
...

Thanks to the substring() implementation it generates strings which all
shares the value array of a longer (or equal) string.  (Note however,
that substring() is not required to always work that way!).

piotr