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 é?

  • Gerair image de código de bairras no aplicativo Android
  • android.view.InflateException: linha de file XML binary # 7: Erro ao inflair o fragment da class
  • Adicione dependencies através de gradle paira eclipse no projeto Android
  • Defina o estado de BottomSheetDialogFragment paira expandir
  • Como obter a freqüência do resultado do Fft?
  • Obtendo a position atual de um ViewPager
  • 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?

  • O server http do Android não está acessível a pairtir de outros dispositivos na networking intermitentemente
  • Como configurair a elevação de um AppBairLayout programmaticamente na Biblioteca de Suporte do Android v24.0.0?
  • Botão "Voltair" na bairra de ação - Android. Como ir "de volta"?
  • Android Não é permitido cairregair o recurso local: file: /// android_asset
  • Aviso de security do Android Roboguice
  • JQuery Mobile + PhoneGap paira Android - Erro ao cairregair index.html
  • 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.