2009-05-07 3 views
3

Ich versuche, etwas zu debuggen und ich frage mich, ob der folgende Code immer true zurück, konnteKann eine leere Java-Zeichenfolge aus einem nicht leeren UTF-8-Byte-Array erstellt werden?

public boolean impossible(byte[] myBytes) { 
    if (myBytes.length == 0) 
    return false; 
    String string = new String(myBytes, "UTF-8"); 
    return string.length() == 0; 
} 

Gibt es einen Wert, den ich in das wahr wird wieder passieren kann? Ich habe versucht, nur das erste Byte einer 2-Byte-Sequenz zu übergeben, aber es erzeugt immer noch eine einzelne Zeichenkette.

Um dies zu verdeutlichen, geschah dies auf einem PowerPC-Chip auf Java 1.4-Code, der über GCJ in eine native ausführbare Binärdatei kompiliert wurde. Dies bedeutet im Grunde, dass die meisten Wetten aus sind. Ich frage mich hauptsächlich, ob Javas "normales" Verhalten oder Javas Spezifikation irgendwelche Versprechen gegeben hat.

Antwort

0

UTF-8 ist ein Codierungsschema mit variabler Länge, wobei die meisten "normalen" Zeichen ein einzelnes Byte sind. Also wird jedes nicht leere Byte [] immer in einen String übersetzt, hätte ich gedacht.

Wenn Sie wollen, dass es so spielen, einen Komponententest schreiben, die alle möglichen Byte-Wert iteriert, dieser Wert in einem einzigen Wert Array übergeben, und behaupten, dass die Zeichenfolge nicht leer ist.

1

Möglicherweise.

Aus den Java 5-API-Dokumenten "Das Verhalten dieses Konstruktors, wenn die angegebenen Bytes im angegebenen Zeichensatz nicht gültig sind, ist nicht angegeben."

Ich denke, dass es hängt davon ab: welche Java-Version sind Sie mit welchen Lieferanten schrieb JVM (Sun, HP, IBM, die Open-Source ein, usw.)

Sobald die docs sagen „nicht näher bezeichnet "Alle Wetten ab

Edit: Geschlagen, um es von Trey seinen Rat Nehmen sie etwa eine CharsetDecoder mit

1

Wenn Java die BOM mark Griffe richtig (was ich bin mir nicht sicher, ob sie es behoben haben noch), dann Es sollte möglich sein, inpu t ein Byte-Array mit nur der BOM (U + FEFF, die in UTF-8 die Bytefolge EF BB BF ist) und eine leere Zeichenfolge erhalten.


Update:

getestet ich das Verfahren mit allen Werten von 1-3 Bytes. Keiner von ihnen hat eine leere Zeichenfolge auf Java 1.6 zurückgegeben. Hier ist der Testcode, den ich mit verschiedenen Byte-Array-Längen verwendet habe:

public static void main(String[] args) throws UnsupportedEncodingException { 
    byte[] test = new byte[3]; 
    byte[] end = new byte[test.length]; 

    if (impossible(test)) { 
     System.out.println(Arrays.toString(test)); 
    } 
    do { 
     increment(test, 0); 
     if (impossible(test)) { 
      System.out.println(Arrays.toString(test)); 
     } 
    } while (!Arrays.equals(test, end)); 

} 

private static void increment(byte[] arr, int i) { 
    arr[i]++; 
    if (arr[i] == 0 && i + 1 < arr.length) { 
     increment(arr, i + 1); 
    } 
} 

public static boolean impossible(byte[] myBytes) throws UnsupportedEncodingException { 
    if (myBytes.length == 0) { 
     return false; 
    } 
    String string = new String(myBytes, "UTF-8"); 
    return string.length() == 0; 
} 
+0

Leider behandelt Java die UTF-8-Stückliste nicht korrekt. Geht überhaupt nicht damit um; behandelt es nur als Teil des Inhalts –