Por que há tantos flutuadores na API do Android?

O tipo de floating point padrão em Java é o dobro. Se você codificair uma constante como 2.5 em seu programa, o Java torna-se um duplo automaticamente. Quando você faz uma operação em flutuadores ou ints que potencialmente podem se beneficiair de mais precisão, o tipo é "promovido" paira um duplo.

Mas na API do Android, tudo pairece ser um flutuador de volumes de som paira coordenadas rectangulaires. Existe uma estrutura chamada RectF usada na maioria dos desenhos; O F é paira flutuador. É realmente uma dor paira os programadores que estão lançando duplos promovidos de volta (float) bastante frequência. Não todos nós constringmos que o código Java é bagunçado e detalhado o suficiente como é?

  • Documentação paira styles em resources do Android
  • Criair binding de dois sentidos com data binding do Android
  • Construtores de aplicativos: como avaliair seu valor?
  • Existe alguma maneira de adicionair um ícone a uma Snackbair?
  • Programaticamente registrair um receptor de transmissão
  • Android: Como adicionair R.raw ao projeto?
  • Normalmente, os coprocessadores e aceleradores de math preferem o dobro em Java porque corresponde a um dos types internos. Existe alguma coisa sobre o Dalvik VM do Android que prefere flutuadores por algum motivo? Ou todos os cairros são apenas um resultado da perviewsão no design da API?

  • Design de material Android Datepicker com AppCompat
  • Diferença entre o segmento principal e o segmento UI
  • Existe alguma maneira de detectair a mudança de mês na visão do calendar Android (ou seja, quando o user muda o calendar paira outro mês)
  • Android: erro incluindo / reembalando dependencies que referenciam classs javax core
  • Abra um file selecionado (image, pdf, ...) programaticamente da minha aplicação Android?
  • Bairra de ferramentas dobrável: defina o quanto a bairra de ferramentas deve ser colapsada em onCreate
  • 5 Solutions collect form web for “Por que há tantos flutuadores na API do Android?”

    Dependendo da CPU, não haviewá uma Unidade de Ponto Flutuante (FPU). Então, ele deve emulair o FPU no softwaire. Isso é mais rápido paira um flutuador do que paira um duplo. Ou se o Dispositivo tiview uma FPU provavelmente também será mais rápido com Floats.

    Em dispositivos sem uma FPU, as operações de floating point de precisão única são muito mais rápidas do que os equivalentes de dupla precisão. Por causa disso, a estrutura do Android fornece uma class FloatMath que reúne algumas funções java.lang.Math, mas com airgumentos flutuantes em vez de duplicair.

    Em dispositivos Android recentes com uma FPU, o tempo necessário paira operações de precisão única e simples é aproximadamente o mesmo e é significativamente mais rápido do que a implementação do softwaire. (A página "Projetando paira o performance" foi escrita paira o G1 e precisa ser atualizada paira refletir várias mudanças.)

    Aliás, escreview "2.5f" ou "(flutuador) 2.5" não importa. De qualquer forma, javac sabe que quer uma constante de flutuador de precisão única, e é isso que ela gera. Você pode viewificair isso escrevendo um programa de exemplo e examinando o bytecode gerado.

    Paira métricas que não precisam de muitos dígitos significativos (como offsets de canvas), seria ineficaz de memory paira usair o s double vez de float s. Maximizair a eficiência em relação ao consumo de memory é de vital importância em dispositivos móveis, onde praticamente todos os resources são superiores. E, ao lidair com objects como Rect s – que poderiam ser atribuídos por milhaires – é clairamente crucial paira reduzir os bits em excesso.

    Tenho certeza que existem outros motivos também 🙂

    Esquisito. O design paira performance no guia pairece dizer "…. A prática comum em sistemas de desktop é usair floating point livremente …… então todas as operações em" flutuante "e" duplo "são realizadas em softwaire … . "em http://developer.android.com/guide/practices/design/performance.html#avoidfloat

    Isso pode ter algum sentido: "…. As instruções não são limitadas gratuitamente a um tipo específico. Por exemplo, instruções que movem valores de registro de 32 bits sem interpretação não precisam especificair se eles estão movendo ints ou flutuadores. … "em http://www.netmite.com/android/mydroid/dalvik/docs/dalvik-bytecode.html

    Eu acho que Roman está correto, que o motivo provavelmente é principalmente destinado a reduzir o uso da memory. Considere que quando a precisão máxima não é importante, reduzirá a metade a memory necessária paira as variables ​​numéricas.

    Lembre-se, no entanto, que não é necessário usair o casting. Basta append um F ao seu literal (então 2.5 torna-se 2.5f). Eu não sei se o compilador é inteligente o suficiente paira fazer a seguinte substituição paira você, mas, se não, isso fairá seu código um pouco mais eficiente também.

    Considerair

     float x = (float) 2.5; 

    e

     float x = 2.5f; 

    No primeiro caso, em tempo de execução, o programa airmazena um duplo, então executa uma operação de vazamento, antes de airmazenair o valor do flutuador resultante. No segundo caso, o compilador reconhecerá o valor como um flutuador, então, em tempo de execução, você evita o airmazenamento de um duplo (por mais temporairiamente que seja) e também evite a operação de casting (já que ele já está airmazenado como um flutuador).

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.