blocks|key|1596910|text|有关渲染特定的性能提示，请参阅这些Google+I/O+2009演讲：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1596911|1596912|Make+your+Android+UI+Fast+and+Efficient|unordered-list-item|offset|length|1596913|Writing+Real-Time+Games+for+Android|1596914|1596915|entityMap|0|LINK|mutability|MUTABLE|url|http://www.youtube.com/watch?v=N6YdwzAvwOA|1|http://www.youtube.com/watch?v=U4Bk5rmIpic^0|0|0|0|13|0|0|0|Z|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|W|8|@]|9|@$F|X|G|Y|1|Z]]|A|$]]|$1|H|3|I|5|E|7|10|8|@]|9|@$F|11|G|12|1|13]]|A|$]]|$1|J|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

For rendering-specific performance tips, see these Google I/O 2009 talks:

<ul>
<li><a href="http://www.youtube.com/watch?v=N6YdwzAvwOA" rel="nofollow noreferrer">Make your Android UI Fast and Efficient</a></li>
<li><a href="http://www.youtube.com/watch?v=U4Bk5rmIpic" rel="nofollow noreferrer">Writing Real-Time Games for Android</a></li>
</ul>

blocks|key|1661052|text|他们希望你避免使用float的原因是因为它很少在手机cpu(可能是arm)上实现，而且必须在软件中实现，速度很慢。固定点通常在硬件中得到支持。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661053|一些手机确实在硬件中实现了浮点，但由于你不知道你的应用程序可能部署到什么手机上，所以他们不会冒险。|1661054|很多人也说要避免使用对象，在那些非常慢的电话和java+me的时代，人们习惯于用静态函数过程化地编写java。不过，我现在不建议这样做。|1661055|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The reason they want you to avoid using float is because it's rarely implemented on phone cpu's(Probbly arm), and has to be implemented in software which is slow. Fixed point is usally surported in hardware although.

Some phones do implement floating point in hardware, but since you don't what phone your app might be deployed to they don't risk it.

A lot of people also say avoid using objects, back in the days of really slow phones and java me people used to write java procedurally with static functions. I would not recommend that now though.

blocks|key|190874|text|在知道代码存在重大问题之前，不要担心性能问题。小的调整(整数而不是浮点数，使用迭代器而不是显式数组枚举)往往是非常微小的，你最好在你的应用程序关闭时查看它们。让5%25的慢代码变得更复杂，而不是让整个应用变得更复杂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|190875|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Don't worry about performance until you know the code has major issues. The little tweaks (ints instead of floats, using iterators instead of explict array enumeration) tend to be really minor and you are better off looking at them when your app is down. Make the 5% of the code that is slow more complex rather than making the whole app.

blocks|key|190909|text|根据Android人员的说法，您应该避免在集合中使用接口名称。例如，标准Java的标准最佳实践是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|190910|List<String>+strings+=+new+ArrayList<String>();|code-block|syntax|javascript|190911|而在Android中，他们说最好用它的运行时类型来声明它|190912|ArrayList<String>+strings+=+new+ArrayList<String>();|190913|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

According to the Android folks, you should avoid using the Interface names for collections. For instance, the standard best practice for standard Java would be to say

<pre><code>List&lt;String&gt; strings = new ArrayList&lt;String&gt;();
</code></pre>

Whereas in Android they say it's better to declare it with its runtime type

<pre><code>ArrayList&lt;String&gt; strings = new ArrayList&lt;String&gt;();
</code></pre>

blocks|key|1661138|text|wrt浮点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661139|在G1上，将两个浮点数相加大约需要400+on。将两个整数相加大约需要250+two。|1661140|在nexus运行eclair+(pre-JIT)上，这两种操作都需要大约120+one。(int稍快一些，但您必须进行微基准测试才能注意到这一点。)int和long之间以及浮点数和双精度之间有一个很小的百分比差异，但基本上如果你能买得起一个，你可能就能买得起另一个。|1661141|其他当前的设备将介于这两个极端之间。(其他操作也会有所不同。乘法比加法/减法更昂贵，而除法更昂贵。当前没有设备具有硬件整数除法。)|1661142|但是，在你遇到问题之前，不要纠结于这些。很有可能，你的性能问题会归结为算法或数据结构的糟糕选择，就像每个人的性能问题一样。|1661143|大多数当前的(eclair)性能文档都是不正确的。在你所关心的设备上，自己进行基准测试。|1661144|1661145|但是如果你真的在问“桌面/服务器java程序员应该注意什么？”，我会建议:不必要的分配。您没有像在桌面/服务器上那样的备用核心来执行GC，您也没有像在桌面/服务器上那样拥有千兆字节的堆。如果你在做GC，你不是在做真正的工作，你的堆在当前设备上最多是24MiB。因此，您可能希望避免内部循环中不必要的分配。|1661146|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|V|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

wrt floating point:

on a G1, adding two floats takes about 400ns. adding two ints takes about 250ns.

on a nexus one running eclair (pre-JIT), both operations take around 120ns. (ints are slightly faster, but you'd have to be microbenchmarking to notice.) there's a small percentage difference between int and long, and float and double, but basically if you can afford one, you can probably afford the other.

other current devices will be somewhere between these extremes. (other operations will differ too. multiplication is more expensive than addition/subtraction, and division is more expensive still. no current devices have hardware integer division.)

but don't obsess about any of this until you have a problem. chances are, your performance problems will be down to a poor choice of algorithm or data structure, just like everyone's performance problems always are.

most of the current (eclair) performance documentation is incorrect. benchmark things yourself, on the device(s) you care about.

<hr>

but if you were really asking "what should a desktop/server java programmer watch out for?", i'd suggest: unnecessary allocation. you don't have a spare core to do your GC like you do on the desktop/server, and you don't have gigabytes of heap like you do on the desktop/server. if you're doing GC, you're not doing real work, and your heap will be at most 24MiB on current devices. so you might want to avoid unnecessary allocation in inner loops.

blocks|key|1661162|text|我发现AppInventor模拟器对于浮点操作非常慢，即使在2014i3/4+4Gb的机器上也是如此。我写了一个分形生成器来对仿真器进行基准测试，发现要计算一个像素，10次迭代只需要两秒钟-是的，2000毫秒。我还没有完全解开它来找出哪些特定的操作是如此缓慢，但我很快就会这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1661163|每次迭代包括四次乘法，两次加法和一次减法，五个变量。每次迭代后的测试涉及两次乘法、一次加法和两次比较-大约30次flops。我还没有通过为下一次迭代存储结果来优化代码。|1661164|显然，如果有一种方法可以强制使用定点或仅使用整数，这将有所帮助，但我在这个小项目中面临的问题的规模并不是一个好兆头。|1661165|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I have found that the AppInventor emulator is extremely slow for floating point ops, even on a 2014 i3/4Gb machine. I wrote a fractal generator to benchmark the emulator and found that to calculate a single pixel, to 10 iterations took just over two seconds - yes, 2,000ms. I haven't fully unpicked it to find which particular operations are so slow but I will be doing that soon. 

Each iteration involves four multiplications, two additions and one subtraction, five variables. Testing after each iteration involves two multiplications, one addition and two comparisons - roughly 30 flops. I haven't yet optimised the code by storing results for the next iteration.

Clearly, if there is a way to force fixed point or to use integers only that would help, but the magnitude of the problem I faced with this tiny project is not a good omen.

What are the most easy mistakes to make that can be performance sinks on Android?

The documentation mentions "some floating point operations" can be "on the order of milliseconds" - has someone tested this?

For the sake of discussion, let's assume its running on a G1/similar device.

Common performance pitfalls on Android?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么是最容易犯的错误，可能是Android的性能下沉？文档提到“一些浮点运算”可以是“毫秒级的”--有人测试过吗？为了便于讨论，让我们假设它在G1/类似设备上运行。

问Android上常见的性能陷阱？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Android上常见的性能陷阱？EN