__repr__ - Java equivalente de Python repr()?

repr python

Question

¿Hay un método Java que funcione como la reproducción de Python? Por ejemplo, asumiendo que la función fue nombrada repr,

"foo/n/tbar".repr()

volvería

"foo/n/tbar"

no

foo bar

como lo hace toString.

Answer 1

En algunos proyectos, uso la siguiente función de ayuda para lograr algo similar a la reproducción de Python para cadenas:

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 aquí presentadas es que no filtra solo un conjunto limitado de caracteres no imprimibles (como las soluciones basadas en reemplazo ), sino simplemente todos los caracteres ASCII no imprimibles. Parte de esto podría haber sido escrito un poco mejor, pero en realidad hace su trabajo ...

Tenga en cuenta que, al igual que la función Python, esta rodeará la cadena con comillas. Si no desea eso, tendrá que eliminar las llamadas adjuntas (''"'') antes y después del bucle while.

Answer 2

En caso de que esté utilizando Groovy , proporciona una clase StringEscapeUtils similar a la de Apache Commons Lang:

StringEscapeUtils.escapeJava("foo/n/tbar")

Answer 3

Esto lo hará, pero es un poco StringUtils , usa StringUtils y replaceEach de Common Lang 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);

Answer 4

Java no tiene ninguna función repr, pero repr te tiene cubierto (divulgación completa: soy el autor de repr).

Answer 5

Parece que Jython ya hace esto. En teoría, podría incluir el jar de Jython, iniciar un intérprete y, en realidad, ejecutar repr (objeto) en el objeto en cuestión. Probablemente más gastos generales de los 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 .

Answer 6

Si existiera un método de este tipo, haría que escribir quines en Java sea realmente fácil, ya que resolvería el problema de escapar de las comillas. Al ver que las quines más simples de Java requieren la inserción manual del carácter de comillas manualmente con su código de caracteres, es poco probable que exista tal método.

Answer 7

Si solo va a utilizar esto en cadenas, en caso de necesidad, podría escribir un método que pase por la cadena y reemplace los caracteres especiales (para cualquier definición de "especial" que desee) con sus códigos de escape. Eso es lo que yo haría. (Hice una búsqueda rápida y no surgió nada en Google, por lo que podría ser más rápido simplemente escribir el método que buscar una implementación existente)

Answer 8

Utilice el método estático escapeJava de la clase Commons Lang StringEscapeUtils .

String repr = "/"" + StringEscapeUtils.escapeJava(myString) + "/"";

Answer 9

no creas que hay un método específico, pero esto lo resolverá sin el uso de 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;
}

}