java - specific - (Cadena) o.toString()?
java object to type (9)
Dado que el tipo de referencia es un Objeto y todos los Objetos tienen un toString () simplemente llame a object.toString (). String.toString () simplemente devuelve esto.
- toString () es menos código para escribir.
- toString () es menos bytecode.
- el lanzamiento es una operación costosa VS una llamada polimórfica.
- el elenco podría fallar
- Use String.valueOf (object) que simplemente llama a object.toString () si no es nulo.
Tengo un método con un parámetro Object o .
En este método, sé exactamente que hay una String en "o" que no es nula. No es necesario verificar o hacer otra cosa. Tengo que tratarlo exactamente como un objeto String .
Simplemente curioso, ¿qué es más barato? ¿Lanzarlo a String , o usar Object.toString() ? ¿O es lo mismo por tiempo / cpu- / mem- precio?
Actualización: el método acepta Object porque es la implementación de una interfaz. No hay forma de cambiar el tipo de parámetro.
Y no puede ser null en absoluto. Solo quería decir que no necesito comprobar si está vacío o vacío. En mi caso, siempre hay una cadena no vacía.
De acuerdo con reflexiones de rendimiento tonto: x.toString () vs (String) x
Al final, los resultados son sorprendentemente claros: es al menos el doble de rápido para lanzar Object a String que para llamar a Object.toString ()
Me pareció extraño que el reparto fuera más lento que la búsqueda vtable implícita en la llamada de tostring.
No me preocuparía demasiado el rendimiento, si esta operación se realiza solo unos pocos miles de veces por segundo, no hay una diferencia tangible.
Sin embargo, me preocuparía "conocer" la entrada. Tiene un método que acepta un Object y debe tratarlo como tal, es decir, no debe saber nada sobre el parámetro, salvo que se adhiere a la interfaz Object , que tiene un método toString() . En este caso, recomendaría encarecidamente utilizar ese método en lugar de simplemente asumir cualquier cosa.
OTOH, si la entrada es siempre String o null , simplemente cambie el método para aceptar String s, y compruebe explícitamente null s (que debe hacer de todos modos cuando se trata de no primitivos ...)
No puede haber una ''cadena nula en o''. Si o es nulo, no contiene una cadena nula, es simplemente nulo. Simplemente marque o para null primero. Si lanza o llama a ToString () en null, se bloqueará.
Si conoces el Objeto o es una Cadena, diría que solo la lanzas a una Cadena y la aplicas de esa manera. Llamar a String () en un objeto del que usted sabe con certeza que String podría agregar confusión.
Si Object o puede ser cualquier cosa que no sea una Cadena, deberá llamar a String ().
Si lo que tienes en "o" es una Cadena, entonces no hay mucha diferencia (es probable que el reparto sea más rápido, pero eso es una implementación de VM / Biblioteca).
Si "o" puede no ser una Cadena pero se supone que es una Cadena, entonces el elenco es lo que quieres (pero debes hacer que el método tome una Cadena en lugar de un Objeto).
Si "o" podría ser de cualquier tipo, entonces debes usar el toString, pero asegúrate primero de buscar el nulo.
void foo(final Object o)
{
final String str;
// without this you would get a class cast exception
// be wary of using instanceof though - it is usually the wrong thing to do
if(o instanceof String)
{
str = (String)o;
}
}
o
void foo(final Object o)
{
final String str;
// if you are 100% sure that o is not null then you can get rid of the else
if(o != null)
{
str = o.toString();
}
}
Preferiría codificar el último como:
void foo(final Object o)
{
final String str;
if(o == null)
{
throw new IllegalArgumentException("o cannot be null");
}
str = o.toString();
}
Yo usaría un elenco. Eso valida su "conocimiento" de que es una cadena. Si por alguna razón terminas con un error y alguien pasa algo que no sea una cadena, creo que sería mejor lanzar una excepción (que un reparto hará) que seguir ejecutando con datos defectuosos.
Lanzar a una Cadena es más barato ya que no requiere una llamada de función externa, solo una verificación interna de tipo.