¿Hay algún método de Java que funcione como la réplica de Python? Por ejemplo, asumiendo la función repr fueron nombrados,equivalente de Java de Python repr()?
"foo\n\tbar".repr()
volvería
"foo\n\tbar"
no
foo
bar
como toString hace.
Si solo vas a utilizar esto en cadenas, en un apuro podrías simplemente escribir un método que pase por la cadena y reemplaza los caracteres especiales (para cualquier definición de "especial" que desees) con sus códigos de escape . Eso es lo que yo haría. (Hice una búsqueda rápida y no apareció nada en Google, por lo que podría ser más rápido escribir el método que buscar una implementación existente)
Esto lo hará, pero es un truco, utiliza StringUtils y replaceEach de Lang común para lograr un reemplazo simple:
String hello = "hello\n\tworld\n\n\t";
String replaced = StringUtils.replaceEach(hello, new String[] {"\n", "\t", "\r", "\f"},
new String[] {"\\n", "\\t", "\\r", "\\f"});
System.out.println("Replaced " + replaced);
Si hubiera un procedimiento de este tipo, que haría quines escritura en Java muy fácil, ya que resolvería el problema de escapar de las comillas. Como todas las quines más simples en Java requieren insertar manualmente el carácter de cita manualmente con su código de carácter, es poco probable que exista dicho método.
no creo que hay un método específico - pero esto resolvería sin Commons lang:
public class test {
public test() throws Exception {
byte[] hello = "hello\n\tworld\n\n\t".getBytes();
System.out.println(new String(hexToByte(stringToHex(hello).replaceAll("0a", "5c6e")
.replaceAll("09", "5c74"))));
}
public static void main(String[] args) throws Exception {
new test();
}
public static String stringToHex(byte[] b) throws Exception {
String result = "";
for (int i = 0; i < b.length; i++) {
result += Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1);
}
return result;
}
public static byte[] hexToByte(String s) {
int len = s.length();
byte[] data = new byte[len/2];
for (int i = 0; i < len; i += 2) {
data[i/2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
}
return data;
}
}
En algunos proyectos, utilizo la siguiente función auxiliar para lograr algo semejante a repr de Python para cuerdas:
private static final char CONTROL_LIMIT = ' ';
private static final char PRINTABLE_LIMIT = '\u007e';
private static final char[] HEX_DIGITS = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
public static String toPrintableRepresentation(String source) {
if(source == null) return null;
else {
final StringBuilder sb = new StringBuilder();
final int limit = source.length();
char[] hexbuf = null;
int pointer = 0;
sb.append('"');
while(pointer < limit) {
int ch = source.charAt(pointer++);
switch(ch) {
case '\0': sb.append("\\0"); break;
case '\t': sb.append("\\t"); break;
case '\n': sb.append("\\n"); break;
case '\r': sb.append("\\r"); break;
case '\"': sb.append("\\\""); break;
case '\\': sb.append("\\\\"); break;
default:
if(CONTROL_LIMIT <= ch && ch <= PRINTABLE_LIMIT) sb.append((char)ch);
else {
sb.append("\\u");
if(hexbuf == null)
hexbuf = new char[4];
for(int offs = 4; offs > 0;) {
hexbuf[--offs] = HEX_DIGITS[ch & 0xf];
ch >>>= 4;
}
sb.append(hexbuf, 0, 4);
}
}
}
return sb.append('"').toString();
}
}
Su principal ventaja sobre muchas de las otras soluciones dadas aquí es, que doe s no filtra solo un conjunto limitado de caracteres no imprimibles (como los reemplazan las soluciones basadas en), sino simplemente todos los caracteres ASCII no imprimibles. Algunos de ellos podrían haberse escrito un poco mejor, pero en realidad hace su trabajo ...
Tenga en cuenta que, al igual que la función de Python, ésta rodeará la cadena con comillas. Si no quieres eso, tendrá que eliminar la modo de adición ('"') llamadas antes y después de la mientras bucle.
Parece que Jython ya lo hace. Se podría, en teoría, incluir el jar Jython, iniciar un intérprete y ejecutar repr (objeto) en el objeto en cuestión. Probablemente más sobrecarga de la que desea, pero hace exactamente lo que describe.
Si desea incrustar el intérprete Jython en su aplicación , considere http://wiki.python.org/jython/JythonFaq/EmbeddingJython.
Java no tiene ninguna función adicional, pero repr tiene su cala rojo (Divulgación completa: soy el autor de repr).
Utilice el método estático escapeJava de la clase Commons Lang StringEscapeUtils.
String repr = "\"" + StringEscapeUtils.escapeJava(myString) + "\"";
En caso de que utilice maravilloso, proporciona una StringEscapeUtils class similares como Apache Commons Lang:
StringEscapeUtils.escapeJava("foo\n\tbar")
¿Es publicado el Maven? – Tobia
Aún no. Usted es el primero en preguntar – llogiq