Mit dem abschneiden von Strings von Bytes

Warum nicht konvertieren in bytes und geht voran--gehorchen UTF8-Zeichen Grenzen, wie Sie es tun-bis Sie haben die maximale Anzahl, dann konvertieren Sie diese bytes wieder in einen string?

Oder Sie könnten nur ein Ausschneiden der original-string, wenn Sie verfolgen, wo der Schnitt auftreten sollten:

//Assuming that Java will always produce valid UTF8 from a string, so no error checking!
//(Is this always true, I wonder?)
public class UTF8Cutter {
  public static String cut(String s, int n) {
    byte[] utf8 = s.getBytes();
    if (utf8.length < n) n = utf8.length;
    int n16 = 0;
    int advance = 1;
    int i = 0;
    while (i < n) {
      advance = 1;
      if ((utf8[i] & 0x80) == 0) i += 1;
      else if ((utf8[i] & 0xE0) == 0xC0) i += 2;
      else if ((utf8[i] & 0xF0) == 0xE0) i += 3;
      else { i += 4; advance = 2; }
      if (i <= n) n16 += advance;
    }
    return s.substring(0,n16);
  }
}

^{Hinweis: bearbeitet werden, um Fehler zu beheben, auf 2014-08-25}

Ich denke, Rex Kerr-Lösung hat 2 bugs.

• Zuerst, es abschneiden zu begrenzen,+1, wenn ein nicht-ASCII-Zeichen kurz vor der Grenze. Mit dem abschneiden von "123456789á1" führt "123456789á", vertreten in 11 Zeichen in UTF-8.
• Zweite, ich denke, er interpretiert die UTF-standard. https://en.wikipedia.org/wiki/UTF-8#Description zeigt, dass ein 110xxxxx am Anfang einer UTF-Sequenz sagt uns, dass die Vertretung ist 2 Zeichen lang sein (im Gegensatz zu 3). Das ist der Grund, seine Umsetzung in der Regel nicht verwenden Sie alle verfügbaren Speicherplatz (wie Nissim Avitan erwähnt).

Bitte meine korrigierte version unten:

public String cut(String s, int charLimit) throws UnsupportedEncodingException {
    byte[] utf8 = s.getBytes("UTF-8");
    if (utf8.length <= charLimit) {
        return s;
    }
    int n16 = 0;
    boolean extraLong = false;
    int i = 0;
    while (i < charLimit) {
        //Unicode characters above U+FFFF need 2 words in utf16
        extraLong = ((utf8[i] & 0xF0) == 0xF0);
        if ((utf8[i] & 0x80) == 0) {
            i += 1;
        } else {
            int b = utf8[i];
            while ((b & 0x80) > 0) {
                ++i;
                b = b << 1;
            }
        }
        if (i <= charLimit) {
            n16 += (extraLong) ? 2 : 1;
        }
    }
    return s.substring(0, n16);
}

Dachte ich noch, das war weit aus effektiver. Also, wenn Sie nicht wirklich brauchen, die String-Darstellung des Ergebnis-und das byte-array haben, können Sie dieses verwenden:

private byte[] cutToBytes(String s, int charLimit) throws UnsupportedEncodingException {
    byte[] utf8 = s.getBytes("UTF-8");
    if (utf8.length <= charLimit) {
        return utf8;
    }
    if ((utf8[charLimit] & 0x80) == 0) {
        //the limit doesn't cut an UTF-8 sequence
        return Arrays.copyOf(utf8, charLimit);
    }
    int i = 0;
    while ((utf8[charLimit-i-1] & 0x80) > 0 && (utf8[charLimit-i-1] & 0x40) == 0) {
        ++i;
    }
    if ((utf8[charLimit-i-1] & 0x80) > 0) {
        //we have to skip the starter UTF-8 byte
        return Arrays.copyOf(utf8, charLimit-i-1);
    } else {
        //we passed all UTF-8 bytes
        return Arrays.copyOf(utf8, charLimit-i);
    }
}

Lustige an der Sache ist, dass mit einer realistischen 20-500 byte-Grenze, die Sie ausführen, so ziemlich das gleiche WENN erstellen Sie einen string aus dem byte-array wieder.

Bitte beachten Sie, dass beide Methoden gehen von einem gültigen utf-8-Eingabe ist eine gültige Annahme, nach der Verwendung von Java mit der getBytes () - Funktion.

Zweite Ansatz funktioniert hier gut
http://www.jroller.com/holy/entry/truncating_utf_string_to_the

s = new String(s.getBytes("UTF-8"), 0, MAX_LENGTH - 2, "UTF-8");

Durch die Verwendung unter Regulärer Ausdruck Sie können auch entfernen Sie führende und nachfolgende Leerzeichen von double-byte-Zeichen.

stringtoConvert = stringtoConvert.replaceAll("^[\\s　]*", "").replaceAll("[\\s　]*$", "");

Diese könnte man nicht die effizientere Lösung, aber Sie funktioniert

public static String substring(String s, int byteLimit) {
    if (s.getBytes().length <= byteLimit) {
        return s;
    }

    int n = Math.min(byteLimit-1, s.length()-1);
    do {
        s = s.substring(0, n--);
    } while (s.getBytes().length > byteLimit);

    return s;
}