(String) o .toString ()?

Ho un metodo con un Object oparametro.

In questo metodo, so esattamente che c'è una String"o" che non è nulla. Non è necessario controllare o fare qualcos'altro. Devo trattarlo esattamente come un Stringoggetto.

Solo curioso - cosa è più economico - lanciarlo Stringo usarlo Object.toString()? O è lo stesso per tempo- / cpu- / mem- prezzo?

Aggiornamento: il metodo accetta Objectperché è l'implementazione di un'interfaccia. Non è possibile modificare il tipo di parametro.

E non può essere nullaffatto. Volevo solo dire che non ho bisogno di controllarlo per null o vuoto. Nel mio caso, c'è sempre una stringa non vuota.

il casting su una stringa è più economico poiché non richiede una chiamata di funzione esterna, ma solo il controllo del tipo interno.

Userei un cast. Ciò convalida la tua "conoscenza" che è una stringa. Se per qualsiasi motivo ti ritrovi con un bug e qualcuno passa qualcosa di diverso da una stringa, penso che sarebbe meglio lanciare un'eccezione (cosa che farà un cast) piuttosto che continuare a eseguire con dati difettosi.

Secondo Silly performance musings: x.toString () vs (String) x

Alla fine, i risultati sono sorprendentemente chiari: è almeno due volte più veloce lanciare Object su String che chiamare Object.toString ()

Se sai che Object o è una stringa, direi di lanciarlo su una stringa e applicarlo in questo modo. Chiamare toString () su un oggetto che conosci per certo è una stringa potrebbe semplicemente aggiungere confusione.

Se Object o potrebbe essere qualcosa di diverso da una String, dovrai chiamare toString ().

Non sarei troppo preoccupato per le prestazioni, se questa operazione fosse eseguita anche solo poche migliaia di volte al secondo, non c'è differenza tangibile.

Tuttavia, mi preoccuperei di "conoscere" l'input. Hai un metodo che accetta un Objecte dovresti trattarlo come tale, cioè non dovresti sapere nulla del parametro, a parte il fatto che aderisce Objectall'interfaccia, che ha untoString() metodo. In questo caso, suggerirei caldamente di utilizzare quel metodo invece di assumere qualsiasi cosa.

OTOH, se l'ingresso è sempre uno Stringo null, semplicemente modificare il metodo di accettare Strings, e controllare in modo esplicito per la nulls (che si dovrebbe fare comunque ogni volta che fare con i non-primitive ...)

Dato che il tipo di riferimento è un Object e tutti gli oggetti hanno toString (), basta chiamare object.toString (). String.toString () restituisce solo questo.

• toString () è meno codice da digitare.
• toString () è meno bytecode.
• il casting è un'operazione costosa VS una chiamata polimorfica.
• il cast potrebbe fallire.
• Usa String.valueOf (object) che chiama solo object.toString () se non è nullo.

Se quello che hai in "o" è una stringa, non c'è molta differenza (probabilmente il cast è più veloce, ma questa è una cosa di implementazione VM / libreria).

Se "o" potrebbe non essere una stringa ma dovrebbe essere una stringa, il cast è ciò che desideri (ma dovresti fare in modo che il metodo prenda una stringa invece di un oggetto).

Se "o" può essere di qualsiasi tipo, devi usare toString, ma assicurati di controllare prima la presenza di null.

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

Preferisco codificare l'ultimo come:

void foo(final Object o)
{
    final String str;

    if(o == null)
    {
        throw new IllegalArgumentException("o cannot be null");
    }

    str = o.toString();
}

Ho scoperto stranamente che il cast era più lento della ricerca vtable implicita nella chiamata tostring.

Non può esserci una "stringa nulla in o". Se o è nullo, non contiene una stringa nulla, è solo nullo. Prima controlla o per null. Se esegui il cast o chiami ToString () su null, andrai in crash.