只要有异常被抛出，VM就必须调整调用堆栈。
1、避免使用异常来控制程序流程
如果可以用if、while等逻辑语句来处理，那么就尽可能的不用try／catch语句。抛出异常首先要创建一个新的对象。
Throwable 接口的构造函数调用名为 fillInStackTrace()的本地方法，fillInStackTrace()方法检查栈，收集调用跟踪信息。
只要有异常被抛出，VM 就必须调整调用栈，因为在处理过程中创建了一个新的对象。 异常只能用于错误处理，不应该用来控制程序流程。
2、尽可能重用异常
在必须要进行异常的处理时，要尽可能的重用已经存在的异常对象。因为在异常的处理中，生成个异常对象要消耗掉大部分的时间。
3、将try/catch 块移出循环
把try/catch块放入循环体内，会极大的影响性能，如果编译 jit 被关闭或者你所使用的是一个不带 jit 的jvm，性能会将下降21%之多! 例子：
import java.io.fileinputstream;
public class try {
void method (fileinputstream fis) {
for (int i = 0; i
try { // violation
_sum += fis.read();
} catch (exception e) {}
}
}
private int _sum;
}
import java.io.fileinputstream;
public class try {
void method (fileinputstream fis) {
for (int i = 0; i < size; i++) {
try { // violation
_sum += fis.read();
} catch (exception e) {}
}
}
private int _sum;
}
更正：将 try/catch块移出循环
void method (fileinputstream fis) {
try {
for (int i = 0; i
}
} catch (exception e) {}
}
void method (fileinputstream fis) {
try {
for (int i = 0; i < size; i++) { _sum += fis.read();
}
} catch (exception e) {}
}
四、线程使用技巧
1、在使用大量线程(Threading)的场合使用线程池管理
生成和启动新线程是个相对较慢的过程，生成人量新线程会严重影响应J_}j程序性能。
通过使用线程池，由线程池管理器(thread pool manager)来生成新线程或分配现有线程，柏省生成线程的叫间。
2、防止过多的同步
不必要的同步常常会造成程序性能的下降，调用同步方法比调用非同步方法要花费更多的时间。如果程序是单线程，则没有必要使用同步。
3、同步方法而不要同步整个代码段
对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
4、在追求速度的场合，用ArrayList和HashMap代替Vector和Hashtable
Vector和Hashtable实现了同步以提高线程安全性，但速度较没有实现同步的ArrayList和Ha shMap要慢，可以根据需要选择使用的类。
5、使用notify()而不是notifyAll()
使用哪个方法要取决于程序的没计，但应尽可能使用notify()，因为notify()只唤醒等待指定对象的线程，比唤醒所有等待线稃的notifyAll0速度更快。
6、不要在循环中调用 synchronized(同步)方法
方法的同步需要消耗相当大的资料，在一个循环中调用它绝对不是一个好主意。 例子：
import java.util.vector;
public class syn {
public synchronized void method (object o) {
}
private void test () {
for (int i = 0; i
method (vector.elementat(i)); // violation
}
}
private vector vector = new vector (5, 5);
}
import java.util.vector;
public class syn {
public synchronized void method (object o) {
}
private void test () {
for (int i = 0; i < vector.size(); i++) {
method (vector.elementat(i)); // violation
}
}
private vector vector = new vector (5, 5);
}
更正：不要在循环体中调用同步方法，如果必须同步的话，推荐以下方式：
import java.util.vector;
public class syn {
public void method (object o) {
}
private void test () {
synchronized{//在一个同步块中执行非同步方法
for (int i = 0; i
method (vector.elementat(i));
}
}
}
private vector vector = new vector (5, 5);
}
import java.util.vector;
public class syn {
public void method (object o) {
}
private void test () {
synchronized{//在一个同步块中执行非同步方法
for (int i = 0; i < vector.size(); i++) {
method (vector.elementat(i));
}
}
}
private vector vector = new vector (5, 5);
}
7、单线程应尽量使用 HashMap, ArrayList。
除非必要，否则不推荐使用 HashTable,Vector，她们使用了同步机制，而降低了性能。
五、其它常用技巧
1、使用移位操作替代乘除法操作可以极大地提高性能
"/"是一个很“昂贵”的操作，使用移位操作将会更快更有效。 例子：
public class sdiv {
public static final int num = 16;
public void calculate(int a) {
int div = a / 4; // should be replaced with "a >> 2".
int div2 = a / 8; // should be replaced with "a >> 3".
int temp = a / 3;
int mul = a * 4; // should be replaced with "a <
int mul2 = 8 * a; // should be replaced with "a <
int temp2 = a * 3;
}
}
public class sdiv {
public static final int num = 16;
public void calculate(int a) {
int div = a / 4; // should be replaced with "a >> 2".
int div2 = a / 8; // should be replaced with "a >> 3".
int temp = a / 3;
int mul = a * 4; // should be replaced with "a << 2".
int mul2 = 8 * a; // should be replaced with "a << 3".
int temp2 = a * 3;
}
}
更正：
public class sdiv {
public static final int num = 16;
public void calculate(int a) {
int div = a >> 2;
int div2 = a >> 3;
int temp = a / 3; // 不能转换成位移操作
int mul = a <
int mul2 = a <
int temp = a * 3; // 不能转换
}
}
public class sdiv {
public static final int num = 16;
public void calculate(int a) {
int div = a >> 2;
int div2 = a >> 3;
int temp = a / 3; // 不能转换成位移操作
int mul = a << 2;
int mul2 = a << 3;
int temp = a * 3; // 不能转换
}
}
PS：除非是在一个非常大的循环内，性能非常重要，而且你很清楚你自己在做什么，方可使用这种方法。
否则提高性能所带来的程序晚读性的降低将是不合算的。
2、对Vector中最后位置的添加、删除操作要远远快于埘第一个元素的添加、删除操作
3、当复制数组时，使用System.arraycop()方法
例子：
public class irb
{
void method () {
int[] array1 = new int [100];
for (int i = 0; i
array1 [i] = i;
}
int[] array2 = new int [100];
for (int i = 0; i
array2 [i] = array1 [i]; // violation
}
}
}
public class irb
{
void method () {
int[] array1 = new int [100];
for (int i = 0; i < array1.length; i++) {
array1 [i] = i;
}
int[] array2 = new int [100];
for (int i = 0; i < array2.length; i++) {
array2 [i] = array1 [i]; // violation
}
}
}
更正：
public class irb
{
void method () {
int[] array1 = new int [100];
for (int i = 0; i
array1 [i] = i;
}
int[] array2 = new int [100];
system.arraycopy(array1, 0, array2, 0, 100);
}
}
public class irb
{
void method () {
int[] array1 = new int [100];
for (int i = 0; i < array1.length; i++) {
array1 [i] = i;
}
int[] array2 = new int [100];
system.arraycopy(array1, 0, array2, 0, 100);
}
}
4、使用复合赋值运算符
a=a+b和a+b住编译时会产生不同JAVA字奇码，后者回快于前者。冈此，使用+=、-=、+=、／=等复台赋值运算符会使运算速度稍有提升。
5、用int而不用其它基本类型
对int类犁的操作通常比其它基本类型要快，因此尽量使用int类型。
6、在进行数据库连接和网络连接时使用连接池
这类连接往往会耗费大量时间，应尽量避免。可以使用连接池技术，复用现有连接。
7、用压缩加快网络传输速度一种常用方法是把相关文件打包到一个jar文件中。
用一个Jar文件发送多个文件还叫以避免每个文件打开和关闭网络连接所造成的开销。
8、在数据库应用程序中使用批处理功能
可以利用Statement类的addBatch()氟l exexuteBatch法成批地提交sql语句，以节省网络传输开销。
在执行大量相似语句时，可以使用PreParedState—类，它可以一次性编译语句并多次执行，用参数最后执行的sql语句。
9、消除循环体中不必要的代码
这似乎是每个程序员都知道的基本原则，没有必出，但很多人往往忽略一些细节。如下列代码：
Vector aVector= ...；
for(int i=0；i
System out printlll(aVector elementAt(i)toStringO)；
}
Vector aVector= ...；
for(int i=0；i
System out printlll(aVector elementAt(i)toStringO)；
}
这段代码中没循环一次就要调用aVector.size()方法，aVector的长度不变的话，可以改为一下代码：
Vector aVector= ...：
int length=aVector size()；
for(int i=0；i
System out println(aVector elememAt(i)toStringO)；
)
Vector aVector= ...：
int length=aVector size()；
for(int i=0；i
System out println(aVector elememAt(i)toStringO)；
)
这样消除了每次调用aVector.size()方法的开销。
10、为'vectors' 和 'hashtables'定义初始大小
jvm 为 vector 扩充大小的时候需要重新创建一个更大的数组，将原原先数组中的内容复制过来，最后，原先的数组再被回收。
可见 vector 容量的扩大是一个颇费时间的事。 通常，默认的 10 个元素大小是不够的。你最好能准确的估计你所需要的最佳大小。
例子：
import java.util.vector;
public class dic {
public void addobjects (object[] o) {
// if length > 10, vector needs to expand
for (int i = 0; i
v.add(o); // capacity before it can add more elements.
}
}
public vector v = new vector(); // no initialcapacity.
}
import java.util.vector;
public class dic {
public void addobjects (object[] o) {
// if length > 10, vector needs to expand
for (int i = 0; i< o.length;i++) {
v.add(o); // capacity before it can add more elements.
}
}
public vector v = new vector(); // no initialcapacity.
}
更正： 自己设定初始大小。
更正： 自己设定初始大小。
public vector v = new vector(20);
public hashtable hash = new hashtable(10);
public vector v = new vector(20);
public hashtable hash = new hashtable(10);
11、如果只是查找单个字符的话，用charat()代替startswith()
用一个字符作为参数调用 startswith()也会工作的很好，但从性能角度上来看，调用用 string api 无疑是错误的! 例子：
public class pcts {
private void method(string s) {
if (s.startswith("a")) { // violation
// ...
}
}
}
public class pcts {
private void method(string s) {
if (s.startswith("a")) { // violation
// ...
}
}
}
更正 ：将'startswith()' 替换成'charat()'.
public class pcts {
private void method(string s) {
if ('a' == s.charat(0)) {
// ...
}
}
}
public class pcts {
private void method(string s) {
if ('a' == s.charat(0)) {
// ...
}
}
}
12、在字符串相加的时候，使用 ' ' 代替 " "，如果该字符串只有一个字符的话
例子：
public class str {
public void method(string s) {
string string = s + "d" // violation.
string = "abc" + "d" // violation.
}
}
public class str {
public void method(string s) {
string string = s + "d" // violation.
string = "abc" + "d" // violation.
}
}
更正： 将一个字符的字符串替换成' '
public class str {
public void method(string s) {
string string = s + 'd'
string = "abc" + 'd'
}
}
public class str {
public void method(string s) {
string string = s + 'd'
string = "abc" + 'd'
}
}
13、对于 boolean 值，避免不必要的等式判断
将一个 boolean 值与一个 true 比较是一个恒等操作(直接返回该 boolean 变量的值). 移走对于boolean 的不必要操作至少会带来 2 个好处：
1)代码执行的更快 (生成的字节码少了 5 个字节)； 2)代码也会更加干净 。
例子：
public class ueq {
boolean method (string string) {
return string.endswith ("a") == true; // violation
}
}
public class ueq {
boolean method (string string) {
return string.endswith ("a") == true; // violation
}
}
更正：
class ueq_fixed {
boolean method (string string) {
return string.endswith ("a");
}
}
class ueq_fixed {
boolean method (string string) {
return string.endswith ("a");
}
}
14、对于常量字符串，用'string' 代替 'stringbuffer'
常量字符串并不需要动态改变长度。
例子：
public class usc {
string method () {
stringbuffer s = new stringbuffer ("hello");
string t = s + "world!";
return t;
}
}
public class usc {
string method () {
stringbuffer s = new stringbuffer ("hello");
string t = s + "world!";
return t;
}
}
更正： 把 stringbuffer 换成 string，如果确定这个 string 不会再变的话，这将会减少运行开销提高性能。
15、用'stringtokenizer' 代替 'indexof()' 和'substring()'
字符串的分析在很多应用中都是常见的。使用 indexof()和 substring()来分析字符串容易导致 stringindexoutofboundsexception。
而使用 stringtokenizer 类来分析字符串则会容易一些，效率也会高一些。
例子：
public class ust {
void parsestring(string string) {
int index = 0;
while ((index = string.indexof(".", index)) != -1) {
system.out.println (string.substring(index, string.length()));
}
}
}
public class ust {
void parsestring(string string) {
int index = 0;
while ((index = string.indexof(".", index)) != -1) {
system.out.println (string.substring(index, string.length()));
}
}
}
16、使用条件操作符替代"if (cond) else " 结构
条件操作符更加的简捷 例子：
public class if {
public int method(boolean isdone) {
if (isdone) {
return 0;
} else {
return 10;
}
void method2(boolean istrue) {
if (istrue) {
_value = 0;
} else {
_value = 1;
}
}
}
public class if {
public int method(boolean isdone) {
if (isdone) {
return 0;
} else {
return 10;
}
void method2(boolean istrue) {
if (istrue) {
_value = 0;
} else {
_value = 1;
}
}
}
更正：
public class if {
public int method(boolean isdone) {
return (isdone ? 0 : 10);
}
void method(boolean istrue) {
_value = (istrue ? 0 : 1); // comp
}
private int _value = 0;
}
public class if {
public int method(boolean isdone) {
return (isdone ? 0 : 10);
}
void method(boolean istrue) {
_value = (istrue ? 0 : 1); // comp
}
private int _value = 0;
}
17、不要在循环体中实例化变量
在循环体中实例化临时变量将会增加内存消耗
例子：
import java.util.vector;
public class loop {
void method (vector v) {
for (int i=0;i
object o = new object();
o = v.elementat(i);
}
}
}
import java.util.vector;
public class loop {
void method (vector v) {
for (int i=0;i < v.size();i++) {
object o = new object();
o = v.elementat(i);
}
}
}
更正：
在循环体外定义变量，并反复使用
import java.util.vector;
public class loop {
void method (vector v) {
object o;
for (int i=0;i
o = v.elementat(i);
}
}
}
import java.util.vector;
public class loop {
void method (vector v) {
object o;
for (int i=0;i
o = v.elementat(i);
}
}
}
18、确定 stringbuffer的容量
stringbuffer 的构造器会创建一个默认大小(通常是 16)的字符数组。
在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。
在大多数情况下，你可以在创建 stringbuffer 的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。 例子：
public class rsbc {
void method () {
stringbuffer buffer = new stringbuffer(); // violation
buffer.append ("hello");
}
}
public class rsbc {
void method () {
stringbuffer buffer = new stringbuffer(); // violation
buffer.append ("hello");
}
}
更正：为 stringbuffer 提供大小。
public class rsbc {
void method () {
stringbuffer buffer = new stringbuffer(max);
buffer.append ("hello");
}
private final int max = 100;
}
public class rsbc {
void method () {
stringbuffer buffer = new stringbuffer(max);
buffer.append ("hello");
}
private final int max = 100;
}
19、不要总是使用取反操作符(!)
取反操作符(!)降低程序的可读性，所以不要总是使用。
例子：
public class dun {
boolean method (boolean a, boolean b) {
if (!a)
return !a;
else
return !b;
}
}
public class dun {
boolean method (boolean a, boolean b) {
if (!a)
return !a;
else
return !b;
}
}
更正：如果可能不要使用取反操作符(!)
20、与一个接口 进行instanceof 操作
基于接口的设计通常是件好事，因为它允许有不同的实现，而又保持灵活。
只要可能，对一个对象进行 instanceof 操作，以判断它是否某一接口要比是否某一个类要快。
例子：
public class insof {
private void method (object o) {
if (o instanceof interfacebase) { } // better
if (o instanceof classbase) { } // worse.
}
}
class classbase {}
interface interfacebase {}
public class insof {
private void method (object o) {
if (o instanceof interfacebase) { } // better
if (o instanceof classbase) { } // worse.
}
}
class classbase {}
interface interfacebase {}
21、采用在需要的时候才开始创建的策略。
例如：
String str="abc";
if(i==1){ list.add(str);}
String str="abc";
if(i==1){ list.add(str);}
应修改为：
if(i==1){String str="abc"; list.add(str);}
if(i==1){String str="abc"; list.add(str);}
22、通过 StringBuffer 的构造函数来设定他的初始化容量，可以明显提升性能。
StringBuffer 的默认容量为 16，当 StringBuffer 的容量达到最大容量时，她会将自身容量增加到当前的 2 倍+2，也就是 2*n+2。
无论何时，只要 StringBuffer 到达她的最大容量，她就不得不创建一个新的对象数组，然后复制旧的对象数组，这会浪费很多时间。
所以给StringBuffer 设置一个合理的初始化容量值，是很有必要的！
23、合理使用 java.util.Vector
Vector 与 StringBuffer 类似，每次扩展容量时，所有现有元素都要赋值到新的存储空间中。
Vector 的默认存储能力为 10个元素，扩容加倍。 vector.add(index,obj) 这个方法可以将元素 obj 插入到index 位置，
但 index 以及之后的元素依次都要向下移动一个位置(将其索引加 1)。 除非必要，否则对性能不利。
同样规则适用于 remove(int index)方法，移除此向量中指定位置的元素。将所有后续元素左移(将其索引减 1)。
返回此向量中移除的元素。所以删除 vector 最后一个元素要比删除第1 个元素开销低很多。删除所有元素最好用 removeAllElements()方法。
如果要删除 vector 里的一个元素可以使用 vector.remove(obj)；而不必自己检索元素位置，再删除，如 int index = indexOf(obj);vector.remove(index)；
24、不要将数组声明为：public static final
25、HaspMap 的遍历
Map paraMap = new HashMap();
for( Entry entry : paraMap.entrySet() )
{
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
}
Map paraMap = new HashMap();
for( Entry entry : paraMap.entrySet() )
{
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
}
利用散列值取出相应的 Entry 做比较得到结果，取得 entry的值之后直接取 key和 value。
26、array(数组)和 ArrayList 的使用。
array 数组效率最高，但容量固定，无法动态改变，ArrayList 容量可以动态增长，但牺牲了效率。
27、StringBuffer,StringBuilder 的区别
StringBuffer,StringBuilder 的区别在于：java.lang.StringBuffer 线程安全的可变字符序列。
一个类似于 String 的字符串缓冲区，但不能修改。StringBuilder 与该类相比，通常应该优先使用 StringBuilder 类，
因为她支持所有相同的操作，但由于她不执行同步，所以速度更快。为了获得更好的性能，
在构造 StringBuffer 或 StringBuilder 时应尽量指定她的容量。当然如果不超过 16 个字符时就不用了。
相同情况下，使用 StringBuilder 比使用 StringBuffer 仅能获得 10%~15%的性能提升，但却要冒多线程不安全的风险。
综合考虑还是建议使用 StringBuffer。
28、 尽量使用基本数据类型代替对象。
29、用简单的数值计算代替复杂的函数计算，比如查表方式解决三角函数问题。
30、使用具体类比使用接口效率高，但结构弹性降低了，但现代 IDE 都可以解决这个问题。
31、考虑使用静态方法
如果你没有必要去访问对象的外部，那么就使你的方法成为静态方法。她会被更快地调用，因为她不需要一个虚拟函数导向表。
这同事也是一个很好的实践，因为她告诉你如何区分方法的性质，调用这个方法不会改变对象的状态。
32.应尽可能避免使用内在的GET,SET 方法
android 编程中，虚方法的调用会产生很多代价，比实例属性查询的代价还要多。
我们应该在外包调用的时候才使用 get，set方法，但在内部调用的时候，应该直接调用。
33、避免枚举，浮点数的使用。34、二维数组比一维数组占用更多的内存空间，大概是 10 倍计算。
35、SQLite
SQLite 数据库读取整张表的全部数据很快，但有条件的查询就要耗时 30-50MS,大家做这方面的时候要注意，尽量少用，尤其是嵌套查找！
36、奇偶判断
不要使用 i % 2 == 1 来判断是否是奇数，因为 i为负奇数时不成立，请使用 i % 2 != 0 来判断是否是奇数，或使用 高效式 (i & 1) != 0 来判断。
扫一扫
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
