Comment décompresser un littéral de chaîne Java en Java?
Je traite du code source Java à l'aide de Java. J'extrais les littéraux de chaîne et les transmettais à une fonction prenant une chaîne. Le problème est que je dois passer la version non échappée de String à la fonction (c'est-à-dire que cela signifie que vous convertissez \n en newline, et \\ en un \, etc.).
Existe-t-il une fonction dans l'API Java qui effectue cela? Si non, puis-je obtenir une telle fonctionnalité d'une bibliothèque? De toute évidence, le compilateur Java doit effectuer cette conversion.
Au cas où quelqu'un voudrait le savoir, j'essaie de ne pas obscurcir les littéraux de chaîne dans des fichiers Java obfusqués décompilés.
Le problème
Le org.Apache.commons.lang.StringEscapeUtils.unescapeJava() donné ici comme autre réponse est vraiment très peu utile du tout.
- Il oublie à propos de
\0pour null. - Il ne gère pas octal du tout .
- Il ne peut pas gérer les types d’évasions admises par
Java.util.regex.Pattern.compile()et tout ce qui l’utilise, y compris\a,\eet surtout\cX. - Il ne prend pas en charge les points de code Unicode logiques par numéro, uniquement pour UTF-16.
- Cela ressemble au code UCS-2, pas au code UTF-16: ils utilisent l'interface
charAtdépréciée au lieu de l'interfacecodePoint, proclamant ainsi le délire que Javacharcontient un caractère Unicode. Ce n'est pas. Ils ne font que s'en tirer parce que les substituts de UTF-16 ne chercheront jamais ce qu’ils recherchent.
La solution
J’ai écrit un string non résilient qui résout la question du PO sans toutes les irritations du code Apache.
/*
*
* unescape_Perl_string()
*
* Tom Christiansen <[email protected]>
* Sun Nov 28 12:55:24 MST 2010
*
* It's completely ridiculous that there's no standard
* unescape_Java_string function. Since I have to do the
* damn thing myself, I might as well make it halfway useful
* by supporting things Java was too stupid to consider in
* strings:
*
* => "?" items are additions to Java string escapes
* but normal in Java regexes
*
* => "!" items are also additions to Java regex escapes
*
* Standard singletons: ?\a ?\e \f \n \r \t
*
* NB: \b is unsupported as backspace so it can pass-through
* to the regex translator untouched; I refuse to make anyone
* doublebackslash it as doublebackslashing is a Java idiocy
* I desperately wish would die out. There are plenty of
* other ways to write it:
*
* \cH, \12, \012, \x08 \x{8}, \u0008, \U00000008
*
* Octal escapes: \0 \0N \0NN \N \NN \NNN
* Can range up to !\777 not \377
*
* TODO: add !\o{NNNNN}
* last Unicode is 4177777
* maxint is 37777777777
*
* Control chars: ?\cX
* Means: ord(X) ^ ord('@')
*
* Old hex escapes: \xXX
* unbraced must be 2 xdigits
*
* Perl hex escapes: !\x{XXX} braced may be 1-8 xdigits
* NB: proper Unicode never needs more than 6, as highest
* valid codepoint is 0x10FFFF, not maxint 0xFFFFFFFF
*
* Lame Java escape: \[IDIOT Java PREPROCESSOR]uXXXX must be
* exactly 4 xdigits;
*
* I can't write XXXX in this comment where it belongs
* because the damned Java Preprocessor can't mind its
* own business. Idiots!
*
* Lame Python escape: !\UXXXXXXXX must be exactly 8 xdigits
*
* TODO: Perl translation escapes: \Q \U \L \E \[IDIOT Java PREPROCESSOR]u \l
* These are not so important to cover if you're passing the
* result to Pattern.compile(), since it handles them for you
* further downstream. Hm, what about \[IDIOT Java PREPROCESSOR]u?
*
*/
public final static
String unescape_Perl_string(String oldstr) {
/*
* In contrast to fixing Java's broken regex charclasses,
* this one need be no bigger, as unescaping shrinks the string
* here, where in the other one, it grows it.
*/
StringBuffer newstr = new StringBuffer(oldstr.length());
boolean saw_backslash = false;
for (int i = 0; i < oldstr.length(); i++) {
int cp = oldstr.codePointAt(i);
if (oldstr.codePointAt(i) > Character.MAX_VALUE) {
i++; /****WE HATES UTF-16! WE HATES IT FOREVERSES!!!****/
}
if (!saw_backslash) {
if (cp == '\\') {
saw_backslash = true;
} else {
newstr.append(Character.toChars(cp));
}
continue; /* switch */
}
if (cp == '\\') {
saw_backslash = false;
newstr.append('\\');
newstr.append('\\');
continue; /* switch */
}
switch (cp) {
case 'r': newstr.append('\r');
break; /* switch */
case 'n': newstr.append('\n');
break; /* switch */
case 'f': newstr.append('\f');
break; /* switch */
/* PASS a \b THROUGH!! */
case 'b': newstr.append("\\b");
break; /* switch */
case 't': newstr.append('\t');
break; /* switch */
case 'a': newstr.append('\007');
break; /* switch */
case 'e': newstr.append('\033');
break; /* switch */
/*
* A "control" character is what you get when you xor its
* codepoint with '@'==64. This only makes sense for ASCII,
* and may not yield a "control" character after all.
*
* Strange but true: "\c{" is ";", "\c}" is "=", etc.
*/
case 'c': {
if (++i == oldstr.length()) { die("trailing \\c"); }
cp = oldstr.codePointAt(i);
/*
* don't need to grok surrogates, as next line blows them up
*/
if (cp > 0x7f) { die("expected ASCII after \\c"); }
newstr.append(Character.toChars(cp ^ 64));
break; /* switch */
}
case '8':
case '9': die("illegal octal digit");
/* NOTREACHED */
/*
* may be 0 to 2 octal digits following this one
* so back up one for fallthrough to next case;
* unread this digit and fall through to next case.
*/
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7': --i;
/* FALLTHROUGH */
/*
* Can have 0, 1, or 2 octal digits following a 0
* this permits larger values than octal 377, up to
* octal 777.
*/
case '0': {
if (i+1 == oldstr.length()) {
/* found \0 at end of string */
newstr.append(Character.toChars(0));
break; /* switch */
}
i++;
int digits = 0;
int j;
for (j = 0; j <= 2; j++) {
if (i+j == oldstr.length()) {
break; /* for */
}
/* safe because will unread surrogate */
int ch = oldstr.charAt(i+j);
if (ch < '0' || ch > '7') {
break; /* for */
}
digits++;
}
if (digits == 0) {
--i;
newstr.append('\0');
break; /* switch */
}
int value = 0;
try {
value = Integer.parseInt(
oldstr.substring(i, i+digits), 8);
} catch (NumberFormatException nfe) {
die("invalid octal value for \\0 escape");
}
newstr.append(Character.toChars(value));
i += digits-1;
break; /* switch */
} /* end case '0' */
case 'x': {
if (i+2 > oldstr.length()) {
die("string too short for \\x escape");
}
i++;
boolean saw_brace = false;
if (oldstr.charAt(i) == '{') {
/* ^^^^^^ ok to ignore surrogates here */
i++;
saw_brace = true;
}
int j;
for (j = 0; j < 8; j++) {
if (!saw_brace && j == 2) {
break; /* for */
}
/*
* ASCII test also catches surrogates
*/
int ch = oldstr.charAt(i+j);
if (ch > 127) {
die("illegal non-ASCII hex digit in \\x escape");
}
if (saw_brace && ch == '}') { break; /* for */ }
if (! ( (ch >= '0' && ch <= '9')
||
(ch >= 'a' && ch <= 'f')
||
(ch >= 'A' && ch <= 'F')
)
)
{
die(String.format(
"illegal hex digit #%d '%c' in \\x", ch, ch));
}
}
if (j == 0) { die("empty braces in \\x{} escape"); }
int value = 0;
try {
value = Integer.parseInt(oldstr.substring(i, i+j), 16);
} catch (NumberFormatException nfe) {
die("invalid hex value for \\x escape");
}
newstr.append(Character.toChars(value));
if (saw_brace) { j++; }
i += j-1;
break; /* switch */
}
case 'u': {
if (i+4 > oldstr.length()) {
die("string too short for \\u escape");
}
i++;
int j;
for (j = 0; j < 4; j++) {
/* this also handles the surrogate issue */
if (oldstr.charAt(i+j) > 127) {
die("illegal non-ASCII hex digit in \\u escape");
}
}
int value = 0;
try {
value = Integer.parseInt( oldstr.substring(i, i+j), 16);
} catch (NumberFormatException nfe) {
die("invalid hex value for \\u escape");
}
newstr.append(Character.toChars(value));
i += j-1;
break; /* switch */
}
case 'U': {
if (i+8 > oldstr.length()) {
die("string too short for \\U escape");
}
i++;
int j;
for (j = 0; j < 8; j++) {
/* this also handles the surrogate issue */
if (oldstr.charAt(i+j) > 127) {
die("illegal non-ASCII hex digit in \\U escape");
}
}
int value = 0;
try {
value = Integer.parseInt(oldstr.substring(i, i+j), 16);
} catch (NumberFormatException nfe) {
die("invalid hex value for \\U escape");
}
newstr.append(Character.toChars(value));
i += j-1;
break; /* switch */
}
default: newstr.append('\\');
newstr.append(Character.toChars(cp));
/*
* say(String.format(
* "DEFAULT unrecognized escape %c passed through",
* cp));
*/
break; /* switch */
}
saw_backslash = false;
}
/* weird to leave one at the end */
if (saw_backslash) {
newstr.append('\\');
}
return newstr.toString();
}
/*
* Return a string "U+XX.XXX.XXXX" etc, where each XX set is the
* xdigits of the logical Unicode code point. No bloody brain-damaged
* UTF-16 surrogate crap, just true logical characters.
*/
public final static
String uniplus(String s) {
if (s.length() == 0) {
return "";
}
/* This is just the minimum; sb will grow as needed. */
StringBuffer sb = new StringBuffer(2 + 3 * s.length());
sb.append("U+");
for (int i = 0; i < s.length(); i++) {
sb.append(String.format("%X", s.codePointAt(i)));
if (s.codePointAt(i) > Character.MAX_VALUE) {
i++; /****WE HATES UTF-16! WE HATES IT FOREVERSES!!!****/
}
if (i+1 < s.length()) {
sb.append(".");
}
}
return sb.toString();
}
private static final
void die(String foa) {
throw new IllegalArgumentException(foa);
}
private static final
void say(String what) {
System.out.println(what);
}
Si cela aide les autres, vous êtes le bienvenu - aucune condition. Si vous l'améliorez, j'aimerais que vous m'envoyiez vos améliorations par la poste, mais ce n'est certainement pas nécessaire.
Vous pouvez utiliser String unescapeJava(String) méthode de StringEscapeUtils from Apache Commons Lang .
Voici un exemple d'extrait de code:
String in = "a\\tb\\n\\\"c\\\"";
System.out.println(in);
// a\tb\n\"c\"
String out = StringEscapeUtils.unescapeJava(in);
System.out.println(out);
// a b
// "c"
La classe utilitaire a des méthodes pour échapper et dissiper les chaînes pour Java, Script Java, HTML, XML et SQL. Il y a aussi des surcharges qui écrivent directement dans un Java.io.Writer .
Mises en garde
Il semble que StringEscapeUtils gère les échappements Unicode avec un u, mais pas les échappements octaux, ou Unicode échappe avec des us superflus.
/* Unicode escape test #1: PASS */
System.out.println(
"\u0030"
); // 0
System.out.println(
StringEscapeUtils.unescapeJava("\\u0030")
); // 0
System.out.println(
"\u0030".equals(StringEscapeUtils.unescapeJava("\\u0030"))
); // true
/* Octal escape test: FAIL */
System.out.println(
"\45"
); // %
System.out.println(
StringEscapeUtils.unescapeJava("\\45")
); // 45
System.out.println(
"\45".equals(StringEscapeUtils.unescapeJava("\\45"))
); // false
/* Unicode escape test #2: FAIL */
System.out.println(
"\uu0030"
); // 0
System.out.println(
StringEscapeUtils.unescapeJava("\\uu0030")
); // throws NestableRuntimeException:
// Unable to parse unicode value: u003
Une citation du JLS:
Les échappements octaux sont fournis pour des raisons de compatibilité avec C, mais ne peuvent exprimer que les valeurs Unicode
\u0000à\u00FF. Les échappées Unicode sont donc généralement préférées.
Si votre chaîne peut contenir des échappements octaux, vous pouvez d'abord les convertir en échappées Unicode ou utiliser une autre approche.
La variable u est également documentée comme suit:
Le langage de programmation Java spécifie un moyen standard de transformer un programme écrit en Unicode en ASCII afin de transformer un programme en un formulaire pouvant être traité par des outils ASCII. La transformation implique la conversion de tous les caractères d'échappement Unicode du texte source du programme en ASCII en ajoutant un
usupplémentaire. Par exemple,\uxxxxdevient\uuxxxx- tout en convertissant simultanément des caractères non-ASCII du texte source en échappements Unicode u chacun.Cette version transformée est également acceptable pour un compilateur pour le langage de programmation Java et représente exactement le même programme. La source Unicode exacte peut être restaurée ultérieurement à partir de cette forme ASCII en convertissant chaque séquence d'échappement contenant plusieurs
uen une séquence de caractères Unicode avec un moins deu, tout en convertissant simultanément chaque séquence d'échappement avec un seuluen le correspondant correspondant. caractère Unicode unique.
Si votre chaîne peut contenir des échappements Unicode avec un u étranger, vous devrez peut-être également le prétraiter avant d'utiliser StringEscapeUtils.
Sinon, vous pouvez essayer d'écrire votre propre unescaper littéral de chaîne Java à partir de zéro, en vous assurant de respecter les spécifications JLS exactes.
Références
Je suis tombé sur un problème similaire, je n'étais pas satisfait des solutions présentées et je l'ai mis en œuvre moi-même.
Aussi disponible en Gist sur Github :
/**
* Unescapes a string that contains standard Java escape sequences.
* <ul>
* <li><strong>\b \f \n \r \t \" \'</strong> :
* BS, FF, NL, CR, TAB, double and single quote.</li>
* <li><strong>\X \XX \XXX</strong> : Octal character
* specification (0 - 377, 0x00 - 0xFF).</li>
* <li><strong>\uXXXX</strong> : Hexadecimal based Unicode character.</li>
* </ul>
*
* @param st
* A string optionally containing standard Java escape sequences.
* @return The translated string.
*/
public String unescapeJavaString(String st) {
StringBuilder sb = new StringBuilder(st.length());
for (int i = 0; i < st.length(); i++) {
char ch = st.charAt(i);
if (ch == '\\') {
char nextChar = (i == st.length() - 1) ? '\\' : st
.charAt(i + 1);
// Octal escape?
if (nextChar >= '0' && nextChar <= '7') {
String code = "" + nextChar;
i++;
if ((i < st.length() - 1) && st.charAt(i + 1) >= '0'
&& st.charAt(i + 1) <= '7') {
code += st.charAt(i + 1);
i++;
if ((i < st.length() - 1) && st.charAt(i + 1) >= '0'
&& st.charAt(i + 1) <= '7') {
code += st.charAt(i + 1);
i++;
}
}
sb.append((char) Integer.parseInt(code, 8));
continue;
}
switch (nextChar) {
case '\\':
ch = '\\';
break;
case 'b':
ch = '\b';
break;
case 'f':
ch = '\f';
break;
case 'n':
ch = '\n';
break;
case 'r':
ch = '\r';
break;
case 't':
ch = '\t';
break;
case '\"':
ch = '\"';
break;
case '\'':
ch = '\'';
break;
// Hex Unicode: u????
case 'u':
if (i >= st.length() - 5) {
ch = 'u';
break;
}
int code = Integer.parseInt(
"" + st.charAt(i + 2) + st.charAt(i + 3)
+ st.charAt(i + 4) + st.charAt(i + 5), 16);
sb.append(Character.toChars(code));
i += 5;
continue;
}
i++;
}
sb.append(ch);
}
return sb.toString();
}
Voir ceci depuis http://commons.Apache.org/lang/ :
StringEscapeUtils.unescapeJava(String str)
Je sais que cette question était ancienne, mais je voulais une solution qui n'implique pas les bibliothèques autres que celles incluses dans JRE6 (c.-à-d. Apache Commons n'est pas acceptable), et j'ai proposé une solution simple en utilisant le code Java.io.StreamTokenizer :
import Java.io.*;
// ...
String literal = "\"Has \\\"\\\\\\\t\\\" & isn\\\'t \\\r\\\n on 1 line.\"";
StreamTokenizer parser = new StreamTokenizer(new StringReader(literal));
String result;
try {
parser.nextToken();
if (parser.ttype == '"') {
result = parser.sval;
}
else {
result = "ERROR!";
}
}
catch (IOException e) {
result = e.toString();
}
System.out.println(result);
Sortie:
Has "\ " & isn't
on 1 line.
Je suis un peu en retard, mais je pensais proposer ma solution car j'avais besoin de la même fonctionnalité. J'ai décidé d'utiliser l'API du compilateur Java, ce qui le ralentit, mais rend les résultats précis. Fondamentalement, je crée une classe puis retourne les résultats. Voici la méthode:
public static String[] unescapeJavaStrings(String... escaped) {
//class name
final String className = "Temp" + System.currentTimeMillis();
//build the source
final StringBuilder source = new StringBuilder(100 + escaped.length * 20).
append("public class ").append(className).append("{\n").
append("\tpublic static String[] getStrings() {\n").
append("\t\treturn new String[] {\n");
for (String string : escaped) {
source.append("\t\t\t\"");
//we escape non-escaped quotes here to be safe
// (but something like \\" will fail, oh well for now)
for (int i = 0; i < string.length(); i++) {
char chr = string.charAt(i);
if (chr == '"' && i > 0 && string.charAt(i - 1) != '\\') {
source.append('\\');
}
source.append(chr);
}
source.append("\",\n");
}
source.append("\t\t};\n\t}\n}\n");
//obtain compiler
final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
//local stream for output
final ByteArrayOutputStream out = new ByteArrayOutputStream();
//local stream for error
ByteArrayOutputStream err = new ByteArrayOutputStream();
//source file
JavaFileObject sourceFile = new SimpleJavaFileObject(
URI.create("string:///" + className + Kind.SOURCE.extension), Kind.SOURCE) {
@Override
public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
return source;
}
};
//target file
final JavaFileObject targetFile = new SimpleJavaFileObject(
URI.create("string:///" + className + Kind.CLASS.extension), Kind.CLASS) {
@Override
public OutputStream openOutputStream() throws IOException {
return out;
}
};
//file manager proxy, with most parts delegated to the standard one
JavaFileManager fileManagerProxy = (JavaFileManager) Proxy.newProxyInstance(
StringUtils.class.getClassLoader(), new Class[] { JavaFileManager.class },
new InvocationHandler() {
//standard file manager to delegate to
private final JavaFileManager standard =
compiler.getStandardFileManager(null, null, null);
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("getJavaFileForOutput".equals(method.getName())) {
//return the target file when it's asking for output
return targetFile;
} else {
return method.invoke(standard, args);
}
}
});
//create the task
CompilationTask task = compiler.getTask(new OutputStreamWriter(err),
fileManagerProxy, null, null, null, Collections.singleton(sourceFile));
//call it
if (!task.call()) {
throw new RuntimeException("Compilation failed, output:\n" +
new String(err.toByteArray()));
}
//get the result
final byte[] bytes = out.toByteArray();
//load class
Class<?> clazz;
try {
//custom class loader for garbage collection
clazz = new ClassLoader() {
protected Class<?> findClass(String name) throws ClassNotFoundException {
if (name.equals(className)) {
return defineClass(className, bytes, 0, bytes.length);
} else {
return super.findClass(name);
}
}
}.loadClass(className);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
//reflectively call method
try {
return (String[]) clazz.getDeclaredMethod("getStrings").invoke(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
Il faut un tableau pour que vous puissiez vous évader par lots. Donc, le test simple suivant réussit:
public static void main(String[] meh) {
if ("1\02\03\n".equals(unescapeJavaStrings("1\\02\\03\\n")[0])) {
System.out.println("Success");
} else {
System.out.println("Failure");
}
}
J'ai rencontré le même problème, mais aucune des solutions que j'ai trouvées ici ne m'a séduit. Alors, j’en ai écrit un qui parcourt les caractères de la chaîne en utilisant un matcher pour trouver et remplacer les séquences d’échappement. Cette solution suppose une entrée correctement formatée. Autrement dit, il saute heureusement les échappements insensés et décode les échappements Unicode pour les sauts de ligne et les retours à la ligne (qui ne peuvent sinon pas apparaître dans un littéral de caractère ou un littéral de chaîne, en raison de la définition de tels littéraux et de l'ordre des phases de traduction pour Java la source). Excuses, le code est un peu emballé pour la brièveté.
import Java.util.Arrays;
import Java.util.regex.Matcher;
import Java.util.regex.Pattern;
public class Decoder {
// The encoded character of each character escape.
// This array functions as the keys of a sorted map, from encoded characters to decoded characters.
static final char[] ENCODED_ESCAPES = { '\"', '\'', '\\', 'b', 'f', 'n', 'r', 't' };
// The decoded character of each character escape.
// This array functions as the values of a sorted map, from encoded characters to decoded characters.
static final char[] DECODED_ESCAPES = { '\"', '\'', '\\', '\b', '\f', '\n', '\r', '\t' };
// A pattern that matches an escape.
// What follows the escape indicator is captured by group 1=character 2=octal 3=Unicode.
static final Pattern PATTERN = Pattern.compile("\\\\(?:(b|t|n|f|r|\\\"|\\\'|\\\\)|((?:[0-3]?[0-7])?[0-7])|u+(\\p{XDigit}{4}))");
public static CharSequence decodeString(CharSequence encodedString) {
Matcher matcher = PATTERN.matcher(encodedString);
StringBuffer decodedString = new StringBuffer();
// Find each escape of the encoded string in succession.
while (matcher.find()) {
char ch;
if (matcher.start(1) >= 0) {
// Decode a character escape.
ch = DECODED_ESCAPES[Arrays.binarySearch(ENCODED_ESCAPES, matcher.group(1).charAt(0))];
} else if (matcher.start(2) >= 0) {
// Decode an octal escape.
ch = (char)(Integer.parseInt(matcher.group(2), 8));
} else /* if (matcher.start(3) >= 0) */ {
// Decode a Unicode escape.
ch = (char)(Integer.parseInt(matcher.group(3), 16));
}
// Replace the escape with the decoded character.
matcher.appendReplacement(decodedString, Matcher.quoteReplacement(String.valueOf(ch)));
}
// Append the remainder of the encoded string to the decoded string.
// The remainder is the longest suffix of the encoded string such that the suffix contains no escapes.
matcher.appendTail(decodedString);
return decodedString;
}
public static void main(String... args) {
System.out.println(decodeString(args[0]));
}
}
Je dois noter que Apache Commons Lang3 ne semble pas souffrir des faiblesses indiquées dans la solution acceptée. C'est-à-dire que StringEscapeUtils semble gérer les échappements octaux et plusieurs caractères u d'échappements Unicode. Cela signifie que, sauf si vous avez une raison impérieuse d'éviter Apache Commons, vous devriez probablement l'utiliser plutôt que ma solution (ou toute autre solution ici).
Pour mémoire, si vous utilisez Scala, vous pouvez faire:
StringContext.treatEscapes(escaped)
org.Apache.commons.lang3.StringEscapeUtils de commons-lang3 est marqué comme obsolète maintenant. Vous pouvez utiliser org.Apache.commons.text.StringEscapeUtils#unescapeJava(String) à la place. Il nécessite une dépendance supplémentaire Maven :
<dependency>
<groupId>org.Apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>1.4</version>
</dependency>
et semble traiter certains cas plus spéciaux, par exemple unescapes:
- des barres obliques inverses, des guillemets simples et doubles
- valeurs octales et unicodes échappées
\\b,\\n,\\t,\\f,\\r
Vous voudrez peut-être jeter un coup d'œil à l'implémentation Eclipse de Stringliteral .
Si vous lisez des caractères d'échappement unicode dans un fichier, vous aurez du mal à le faire, car la chaîne sera lue littéralement avec un échap pour la barre oblique inverse:
mon_fichier.txt
Blah blah...
Column delimiter=;
Word delimiter=\u0020 #This is just unicode for whitespace
.. more stuff
Ici, lorsque vous lisez la ligne 3 du fichier, la chaîne/ligne aura:
"Word delimiter=\u0020 #This is just unicode for whitespace"
et le caractère [] dans la chaîne montrera:
{...., '=', '\\', 'u', '0', '0', '2', '0', ' ', '#', 't', 'h', ...}
Commons StringUnescape n'échappera pas cela pour vous (j'ai essayé unescapeXml ()). Vous devrez le faire manuellement en tant que décrit ici .
Ainsi, la sous-chaîne "\ u0020" devrait devenir 1 seul caractère '\ u0020'
Mais si vous utilisez ce "\ u0020" pour faire String.split("... ..... ..", columnDelimiterReadFromFile) qui utilise réellement regex en interne, cela fonctionnera directement car la chaîne lue à partir du fichier a été échappée et est parfaite pour être utilisée dans le motif regex !! (Confus?)