(String) ou .toString ()?

Eu tenho um método com um Object oparâmetro.

Nesse método, eu sei exatamente que existe um Stringem "o" que não é nulo. Não há necessidade de verificar ou fazer outra coisa. Tenho que tratá-lo exatamente como um Stringobjeto.

Só por curiosidade - o que é mais barato - lance Stringou use Object.toString()? Ou é o mesmo por tempo- / cpu- / mem- preço?

Update: O método aceita Objectporque é a implementação de uma interface. Não há como alterar o tipo de parâmetro.

E não pode ser de nulltodo. Só queria dizer que não preciso verificar se há nulo ou vazio. No meu caso, sempre há uma string não vazia.

converter para uma String é mais barato, pois não requer uma chamada de função externa, apenas verificação de tipo interna.

Eu usaria um gesso. Isso valida seu "conhecimento" de que é uma string. Se por algum motivo você acabar com um bug e alguém passar algo diferente de uma string, acho que seria melhor lançar uma exceção (o que um elenco fará) do que continuar a executar com dados defeituosos.

De acordo com as reflexões de desempenho do Silly: x.toString () vs (String) x

No final, os resultados são surpreendentemente claros: é pelo menos duas vezes mais rápido lançar Object em String do que chamar Object.toString ()

Se você sabe que o objeto o é uma string, eu diria apenas lançá-lo em uma string e aplicá-lo dessa forma. Chamar toString () em um objeto que você sabe com certeza é uma String pode apenas adicionar confusão.

Se Object o pode ser qualquer coisa diferente de String, você precisará chamar toString ().

Eu não ficaria muito preocupado com o desempenho, se essa operação fosse feita apenas alguns milhares de vezes por segundo - não há diferença tangível.

Eu, entretanto, estaria preocupado em "conhecer" a entrada. Você tem um método que aceita um Objecte deve tratá-lo como tal, ou seja, você não deve saber nada sobre o parâmetro, a não ser que ele adere à Objectinterface, que por acaso tem um toString()método. Nesse caso, eu sugiro fortemente usar esse método em vez de apenas assumir qualquer coisa.

OTOH, se a entrada é sempre quer Stringou null, basta alterar o método de aceitar Strings, e verificar explicitamente para nulls (o que você deve fazer de qualquer maneira sempre que lidar com não-primitivos ...)

Dado que o tipo de referência é um objeto e todos os objetos têm um toString (), basta chamar object.toString (). String.toString () apenas retorna isso.

• toString () é menos código para digitar.
• toString () é menos bytecode.
• fundir é uma operação cara VS uma chamada polimórfica.
• o elenco pode falhar.
• Use String.valueOf (object) que apenas chama object.toString () se não for nulo.

Se o que você tem em "o" é uma String, então não há muita diferença (provavelmente a conversão é mais rápida, mas isso é uma coisa de implementação de VM / Biblioteca).

Se "o" pode não ser uma String, mas é suposto ser uma String, então a conversão é o que você deseja (mas você deve fazer o método tomar uma String em vez de um Objeto).

Se "o" puder ser de qualquer tipo, você terá que usar toString - mas certifique-se de verificar primeiro se há 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;
    }    
}

ou

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

Prefiro codificar o último como:

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

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

    str = o.toString();
}

Achei estranhamente que o elenco foi mais lento do que a pesquisa vtable sugerida pela chamada tostring.

Não pode haver uma 'string nula em o'. Se o for nulo, não contém uma string nula, é apenas nulo. Basta verificar o nulo primeiro. Se você lançar ou chamar ToString () em null, você travará.