How to determine the maximum prefix of two CharSequences efficiently?

Question

I have the following problem. I need a unicode friendly mechanism for determining the maximum prefix of 2 CharacterSequences. I've come up with the following code which appears to do the job, but which requires up to ([number of codepoints in smaller sequence] * 2) + 1 memory allocations. These memory allocations are rather irksome since I plan on calling this method extremely many times. The code I came up with looks like:
private static int getLengthOfMaxCommonPrefix(CharSequence str1, CharSequence str2, Collator collator) {
    if ((str1 == null) || (str2 == null)) { return 0; }
    if (Character.codePointCount(str1, 0, str1.length()) > Character.codePointCount(str2, 0, str2.length())) {
      CharSequence tmp = str1;
      str1 = str2;
      str2 = tmp;
    // @todo get rid of memory allocation
    char[] charArray = new char[4];
    int i = 0;
    for (int size = Character.codePointCount(str1, 0, str1.length()); i < size; i++) {
      Character.toChars(Character.codePointAt(str1, i), charArray, 0);
      Character.toChars(Character.codePointAt(str2, i), charArray, 2);
       // @todo get rid of memory allocation
      String char1Str = new String(charArray, 0, 2);
      // @todo get rid of memory allocation
      String char2Str = new String(charArray, 2, 2);
      if (collator.compare(char1Str, char2Str) != 0) {
        return i;
    return i;
  }Am I overlooking an API that would allow me have this same functionality without memory allocations? If not, would it be reasonable to request that the Java Collator API be updated to have:
Collator.compare(int codepoint1, int codepoint2)which would eliminate the need for these memory allocations. The only reason I would suggest this change is that more than a few pieces of my other code involving unicode has the same problem. Also, when looking over the API it seems that
static Character.toString(char c)exists, but the following method doesn't:
static Character.toString(int codepoint)which would at least minimize some of the ugliness in the above code and be in keeping with the other APIs under Character.
Edited by: APBrusseau on Feb 10, 2008 11:23 PM
Edited by: APBrusseau on Feb 10, 2008 11:24 PM
Edited by: APBrusseau on Feb 10, 2008 11:29 PM
Edited by: APBrusseau on Feb 10, 2008 11:45 PM
Edited by: APBrusseau on Feb 10, 2008 11:46 PM
Edited by: APBrusseau on Feb 10, 2008 11:48 PM

Answer 1

But still, surely just walking character by character through the strings and comparing them (using your collator) will do?
    char[] c1 = new char[1];
    char[] c2 = new char[1];
    // swap longest/shortest string, etc.
    // for each char {
        c1[0] = cs1.charAt(n);
        c2[0] = cs2.charAt(n);
        s1 = new String(c1);
        s2 = new String(c2);
        // use collator to compare
    // }The only thing I don't know is whether there are collators which look at sequences of characters. For example, I think in Unicode, you can have an 'a' followed by a 'add an accent to the previous character' character, which would obviously impact on the collation order.
In which case, something like
    // for n = 1 .. length of shortest {
        int result = collator.compare(cs1.subSequence(0, n).toString(), cs2.subSequence(0, n).toString());
        if (result != 0) {
            return result;
    // equal to length of shortest string. Make decision based on length.This might be efficient, or not, depending on the implementation of CharSequence. String, for example, has a very efficient subSequence() method.