Wie lässt sich der String eines Unicode-Entitys in einen char konvertieren?

Ein Unicode-Entity wird immer mit einem Backslash eingeleitet, der das folgende 'u' maskiert, d.h. als Zeichen mit Sonderfunktion kennzeichnet. Trifft der Compiler auf ein derartiges Entity, so ersetzt er die gesamte Folge bis zum abschließenden Semikolon durch die entsprechende Character-Repräsentanz, da die Zeichenfolge '\u' angibt, dass die folgenden Stellen als Unicode-Hexadezimalwert zu interpretieren sind.

\u00FC → ü

Möchte man das Unicode-Entity als solches darstellen, so reicht es, den Backslash selbst wiederum mit einem Backslash zu maskieren, das Entity somit mit einem doppelten Backslash beginnen zu lassen:

\\u00FC → \u00FC

Hierdurch wird der Backslash selbst maskiert und dient nicht mehr zusammen mit dem nachfolgenden 'u' als Character-Repräsentanz.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.math.BigInteger;

public class CharAusUnicode {

    public static void main(String[] args) {

        System.out.println("Entity-String: \u00FC"); // ü

        System.out.println("String aus CharArray: " + stringFromCharArray()); // \u00FC

        System.out
                .println("Entity-String aus Datei: " + stringFromFileString()); // \u00FC

        System.out.println("Konvertierter Entity-String aus Datei: "
                + convertUnicode(stringFromFileString())); // ü
    }

    private static String stringFromFileString() {
        String s = "", str = "";
        BufferedReader buff = null;
        try {
            buff = new BufferedReader(new FileReader(new File(
                    "test.txt")));
            while ((s = buff.readLine()) != null) {
                str += s;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }

    private static String stringFromCharArray() {
        char[] c = { '\\', 'u', '0', '0', 'F', 'C' };
        return new String(c);
    }

    private static String convertUnicode(String s) {
        if (s.startsWith("\\u")) {
            String numberStr = s.substring(2);
            char c = (char) new BigInteger(numberStr, 16).intValue();
            return new Character(c).toString();
        }
        return s;
    }
}

Bei der Entwicklung der Transformation von fremdsprachigen Zeichensätzen in HTML-Entities in Cent stand ich vor der Aufgabe, die Stringrepräsentationen der jeweiligen Zeichen aus einer Datei einzulesen. Das Problem hierbei besteht darin, dass der Entity-String in der Datei aus einer Folge von Einzelzeichen besteht, denen ihrerseits jeweils eine hexadezimale Entity-Form zugeordnet werden kann. Der in der Datei lesbare Entity-String besteht also selbst aus einer Folge von Entity-Strings, bzw. deren Zeichenform. Vorstellen kann man sich das Ganze ähnlich einem Character-Array. Um hieraus ein einziges Zeichen zu erzeugen, muss der numerische Anteil des Entity-Strings in seine hexadezimale Form überführt werden. Dies ist durch die Klasse java.math.BigInteger möglich, die zwei Konstruktoren bereit stellt, die String-Repräsentationen eines BigInteger in einen BigInteger-Wert wandeln. Bei dem hier verwendeten Konstruktor wird als zweiter Parameter die Basis 16 des gewünschten hexadezimalen Zahlensystems übergeben. Das gebildete BigInteger-Objekt wird anschließend zunächst in den primitiven Datentyp char gecastet und dann als String zurück gegeben.
Die Methode convertUnicode(String s) im Beispiel demonstriert das Gesagte.