(Cadena) o .toString ()?

Tengo un método con un Object oparámetro.

En este método, sé exactamente que hay una String"o" que no es nula. No es necesario verificar ni hacer nada más. Tengo que tratarlo exactamente como un Stringobjeto.

Solo por curiosidad, ¿qué es más barato, lanzarlo Stringo usarlo Object.toString()? ¿O es lo mismo por tiempo- / cpu- / mem- precio?

Actualización: el método acepta Objectporque es la implementación de una interfaz. No hay forma de cambiar el tipo de parámetro.

Y no puede ser nullen absoluto. Solo quería decir que no necesito verificar si está nulo o vacío. En mi caso, siempre hay una cadena no vacía.

La conversión a String es más barata ya que no requiere una llamada de función externa, solo una verificación de tipo interna.

Usaría un yeso. Eso valida tu "conocimiento" de que es una cadena. Si por alguna razón termina con un error y alguien pasa algo que no sea una cadena, creo que sería mejor lanzar una excepción (lo que hará un elenco) que continuar ejecutando con datos defectuosos.

De acuerdo con las reflexiones de rendimiento tontas: x.toString () vs (String) x

Al final, los resultados son sorprendentemente claros: es al menos dos veces más rápido lanzar Object to String que llamar Object.toString ()

Si sabe que el Objeto o es una Cadena, diría que simplemente conviértalo en una Cadena y aplíquelo de esa manera. Llamar a toString () en un objeto que sabe con certeza que es una cadena podría agregar confusión.

Si Object o puede ser cualquier cosa que no sea String, deberá llamar a toString ().

No me preocuparía demasiado el rendimiento, si esta operación se realiza incluso 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 Objecty debe tratarlo como tal, es decir, no debe saber nada sobre el parámetro, aparte de que se adhiere a la Objectinterfaz, que tiene un toString()método. En este caso, sugeriría encarecidamente usar ese método en lugar de simplemente asumir algo.

Otoh, si la entrada es siempre bien Stringo null, simplemente cambiar el método de aceptar Strings, y comprobar de forma explícita nulls (que se debe hacer de todos modos al tratar con los no-primitivas ...)

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 código de bytes.
• La fundición es una operación cara frente a una llamada polimórfica.
• el elenco podría fallar.
• Use String.valueOf (object) que solo llama a object.toString () si no es nulo.

Si lo que tiene en "o" es una cadena, entonces no hay mucha diferencia (probablemente la transmisión sea más rápida, 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 desea (pero debe hacer que el método tome una Cadena en lugar de un Objeto).

Si "o" puede ser de cualquier tipo, entonces debe usar toString, pero asegúrese de verificar primero si es 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();
    }
}

Prefiero 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();
}

Encontré curiosamente que el lanzamiento fue más lento que la búsqueda de vtable implícita en la llamada tostring.

No puede haber una 'cadena nula en o'. Si o es nulo, no contiene una cadena nula, simplemente es nulo. Simplemente marque o para nulo primero. Si lanza o llama a ToString () en nulo, se bloqueará.