How to improve the speed of creating multiple strings from a char[]?

Question

Hi,
I have a char[] and I want to create multiple Strings from the contents of this char[] at various offsets and of various lengths, without having to reallocate memory (my char[] is several tens of megabytes large). And the following function (from java/lang/String.java) would be perfect apart from the fact that it was designed so that only package-private classes may benefit from the speed improvements it offers:
    // Package private constructor which shares value array for speed.
    String(int offset, int count, char value[]) {
     this.value = value;
     this.offset = offset;
     this.count = count;
    }My first thought was to override the String class. But java.lang.String is final, so no good there. Plus it was a really bad idea to start with.
My second thought was to make a java.lang.FastString which would then be package private, and could access the string's constructor, create a new string and then return it (thought I was real clever here) but no, apparently you cannot create a class within the package java.lang. Some sort of security issue.
I am just wondering first if there is an easy way of forcing the compiler to obey me, or forcing it to allow me to access a package private constructer from outside the package. Either that, or some sort of security overrider, somehow.

Answer 1

My laptop can create and garbage collect 10,000,000 Strings per second from char[] "hello world". That creates about 200 MB of strings per second (char = 2B). Test program below.
A char[] "tens of megabytes large" shouldn't take too large a fraction of a second to convert to a bunch of Strings. Except, say, if the computer is memory-starved and swapping to disk. What kind of times do you get? Is it at all possible that there is something else slowing things down?
using (literally) millions of charAt()'s would be
suicide (code-wise) for me and my program."java -server" gives me 600,000,000 charAt()'s per second (actually more, but I put in some addition to prevent Hotspot from optimizing everything away). Test program below. A million calls would be 1.7 milliseconds. Using char[n] instead of charAt(n) is faster by a factor of less than 2. Are you sure millions of charAt()'s is a huge problem?
public class t1
    public static void main(String args[])
     char hello[] = "hello world".toCharArray();
     for (int n = 0; n < 10; n++) {
         long start = System.currentTimeMillis();
         for (int m = 0; m < 1000 * 1000; m++) {
          String s1 = new String(hello);
          String s2 = new String(hello);
          String s3 = new String(hello);
          String s4 = new String(hello);
          String s5 = new String(hello);
         long end = System.currentTimeMillis();
         System.out.println("time " + (end - start) + " ms");
public class t2
    static int global;
    public static void main(String args[])
     String hello = "hello world";
     for (int n = 0; n < 10; n++) {
         long start = System.currentTimeMillis();
         for (int m = 0; m < 10 * 1000 * 1000; m++) {
          global +=
              hello.charAt(0) + hello.charAt(1) + hello.charAt(2) +
              hello.charAt(3) + hello.charAt(4) + hello.charAt(5) +
              hello.charAt(6) + hello.charAt(7) + hello.charAt(8) +
              hello.charAt(9);
          global +=
              hello.charAt(0) + hello.charAt(1) + hello.charAt(2) +
              hello.charAt(3) + hello.charAt(4) + hello.charAt(5) +
              hello.charAt(6) + hello.charAt(7) + hello.charAt(8) +
              hello.charAt(9);
         long end = System.currentTimeMillis();
         System.out.println("time " + (end - start) + " ms");
}