Java程序性能优化

74 阅读 0 评论 49 点赞

我是靠谱客的博主听话方盒，最近开发中收集的这篇文章主要介绍Java程序性能优化，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一、避免在循环条件中使用复杂表达式

import java.util.vector;
class cel {
void method (vector vector) {
for (int i = 0; i < vector.size (); i++)
// violation
; // ...
}
}

class cel_fixed {
void method (vector vector) {
int size = vector.size ()
for (int i = 0; i < size; i++)
; // ...
}
}

二、为'vectors' 和 'hashtables'定义初始大小

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

三、在finally块中关闭stream

import java.io.*;
public class cs {
public static void main (string args[]) {
cs cs = new cs ();
cs.method ();
}
public void method () {
try {
fileinputstream fis = new fileinputstream ("cs.java");
int count = 0;
while (fis.read () != -1)
count++;
system.out.println (count);
fis.close ();
} catch (filenotfoundexception e1) {
} catch (ioexception e2) {
}
}
}

四、使用'system.arraycopy ()'代替通过来循环复制数组

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.length; i++) {
array1 [i] = i;
}
int[] array2 = new int [100];
system.arraycopy(array1, 0, array2, 0, 100);
}
}

五、让访问实例内变量的getter/setter方法变成”final”

class maf {
public void setsize (int size) {
_size = size;
}
private int _size;
}

class daf_fixed {
final public void setsize (int size) {
_size = size;
}
private int _size;
}

六、避免不需要的instanceof操作

public class uiso {
public uiso () {}
}
class dog extends uiso {
void method (dog dog, uiso u) {
dog d = dog;
if (d instanceof uiso) // always true.
system.out.println("dog is a uiso");
uiso uiso = u;
if (uiso instanceof object) // always true.
system.out.println("uiso is an object");
}
}

class dog extends uiso {
void method () {
dog d;
system.out.println ("dog is an uiso");
system.out.println ("uiso is an uiso");
}
}

七、避免不需要的造型操作

class unc {
string _id = "unc";
}
class dog extends unc {
void method () {
dog dog = new dog ();
unc animal = (unc)dog;
// not necessary.
object o = (object)dog;
// not necessary.
}
}

class dog extends unc {
void method () {
dog dog = new dog();
unc animal = dog;
object o = dog;
}
}

八、如果只是查找单个字符的话，用charat()代替startswith()

public class pcts {
private void method(string s) {
if (s.startswith("a")) { // violation
// ...
}
}
}

public class pcts {
private void method(string s) {
if ('a' == s.charat(0)) {
// ...
}
}
}

九、使用移位操作来代替'a / b'操作

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

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;
// 不能转换成位移操作
}
}

十、使用移位操作代替'a * b'

public class smul {
public void calculate(int a) {
int mul = a * 4;
// should be replaced with "a << 2".
int mul2 = 8 * a;
// should be replaced with "a << 3".
int temp = a * 3;
}
}

package opt;
public class smul {
public void calculate(int a) {
int mul = a << 2;
int mul2 = a << 3;
int temp = a * 3;
// 不能转换
}
}

十一、在字符串相加的时候，使用 ' ' 代替 " "，如果该字符串只有一个字符的话

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'
}
}

十二、不要在循环中调用synchronized(同步)方法

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 < vector.size(); i++) {
method (vector.elementat(i));
}
}
}
private vector vector = new vector (5, 5);
}

十三、将try/catch块移出循环

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

 void method (fileinputstream fis) {
try {
for (int i = 0; i < size; i++) {
_sum += fis.read();
}
} catch (exception e) {}
}

十四、对于boolean值，避免不必要的等式判断

public class ueq
{
boolean method (string string) {
return string.endswith ("a") == true;
// violation
}
}

class ueq_fixed
{
boolean method (string string) {
return string.endswith ("a");
}
}

十五、对于常量字符串，用'string' 代替 'stringbuffer'

public class usc {
string method () {
stringbuffer s = new stringbuffer ("hello");
string t = s + "world!";
return t;
}
}

十六、用'stringtokenizer' 代替 'indexof()' 和'substring()'

public class ust {
void parsestring(string string) {
int index = 0;
while ((index = string.indexof(".", index)) != -1) {
system.out.println (string.substring(index, string.length()));
}
}
}

十七、使用条件操作符替代"if (cond) return; else return;" 结构

public class if {
public int method(boolean isdone) {
if (isdone) {
return 0;
} else {
return 10;
}
}
}

public class if {
public int method(boolean isdone) {
return (isdone ? 0 : 10);
}
}

十八、使用条件操作符代替"if (cond) a = b; else a = c;" 结构

public class ifas {
void method(boolean istrue) {
if (istrue) {
_value = 0;
} else {
_value = 1;
}
}
private int _value = 0;
}

public class ifas {
void method(boolean istrue) {
_value = (istrue ? 0 : 1);
// compact expression.
}
private int _value = 0;
}

十九、不要在循环体中实例化变量

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<v.size();i++) {
o = v.elementat(i);
}
}
}

二十、确定 stringbuffer的容量

public class rsbc {
void method () {
stringbuffer buffer = new stringbuffer(); // violation
buffer.append ("hello");
}
}

public class rsbc {
void method () {
stringbuffer buffer = new stringbuffer(max);
buffer.append ("hello");
}
private final int max = 100;
}

二十一、尽可能的使用栈变量

public class usv {
void getsum (int[] values) {
for (int i=0; i < value.length; i++) {
_sum += value[i];
// violation.
}
}
void getsum2 (int[] values) {
for (int i=0; i < value.length; i++) {
_staticsum += value[i];
}
}
private int _sum;
private static int _staticsum;
}

void getsum (int[] values) {
int sum = _sum;
// temporary local variable.
for (int i=0; i < value.length; i++) {
sum += value[i];
}
_sum = sum;
}

二十二、不要总是使用取反操作符(!)

public class dun {
boolean method (boolean a, boolean b) {
if (!a)
return !a;
else
return !b;
}
}

二十三、与一个接口进行instanceof操作

public class insof {
private void method (object o) {
if (o instanceof interfacebase) { }
// better
if (o instanceof classbase) { }
// worse.
}
}
class classbase {}
interface interfacebase {}

17:26
浏览 (26)
评论 (0)
分类: java

2010 - 05 - 12

缩略显示

Java性能优化技巧

文章分类:Java编程

转载：http://blog.csdn.net/kome2000/archive/2010/04/28/5537591.aspx
1. 尽量使用final修饰符。
2.尽量重用对象。
3. 尽量使用局部变量。
4.不要重复初始化变量。
5.在java+Oracle的应用系统开发中，java中内嵌的SQL语言应尽量使用大写形式，以减少Oracle解析器的解析负担。
6.java编程过程中，进行数据库连接，I/O流操作，在使用完毕后，及时关闭以释放资源。因为对这些大对象的操作会造成系统大的开销。

过分的创建对象会消耗系统的大量内存，严重时，会导致内存泄漏，因此，保证过期的对象的及时回收具有重要意义。
8.在使用同步机制时，应尽量使用方法同步代替代码块同步。

for(int i=0;i<list.size();i++)
for(int i=0,len=list.size();i<len;i++)

String str="abc";
if(i==1){ list.add(str);}

if(i==1){String str="abc"; list.add(str);}

13.通过StringBuffer的构造函数来设定他的初始化容量，可以明显提升性能。

16.代码重构，增加代码的可读性。
17.不用new关键字创建对象的实例。

public static Credit getNewCredit()
{
return new Credit();
}

private static Credit BaseCredit = new Credit();
public static Credit getNewCredit()
{
return (Credit)BaseCredit.clone();
}

18. 乘除法如果可以使用位移，应尽量使用位移，但最好加上注释，因为位移操作不直观，难于理解。

Map<String, String[]> paraMap = new HashMap<String, String[]>();
for( Entry<String, String[]> entry : paraMap.entrySet() )
{
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
}

21.array(数组)和ArrayList的使用。

除非必要，否则不推荐使用HashTable,Vector，她们使用了同步机制，而降低了性能。

.StringBuffer,StringBuilder 的区别在于：java.lang.StringBuffer 线程安全的可变字符序列。一个类似于String的字符串缓冲区，但不能修改。StringBuilder与该类相比，通常应该优先使用 StringBuilder类，因为她支持所有相同的操作，但由于她不执行同步，所以速度更快。为了获得更好的性能，在构造StringBuffer或 StringBuilder时应尽量指定她的容量。当然如果不超过16个字符时就不用了。
24. 尽量使用基本数据类型代替对象。

26.使用具体类比使用接口效率高，但结构弹性降低了，但现代IDE都可以解决这个问题。

28.应尽可能避免使用内在的GET,SET方法。
29. 避免枚举，浮点数的使用。
30.二维数组比一维数组占用更多的内存空间，大概是10倍计算。
31.SQLite数据库读取整张表的全部数据很快，但有条件的查询就要耗时30-50MS,大家做这方面的时候要注意，尽量少用，尤其是嵌套查找！ [/size][align=left][/align]

16:39
浏览 (27)
评论 (0)
分类: java

2010 - 05 - 12

缩略显示

《java解惑》转

文章分类:Java编程

转载于: http://jiangzhengjun.javaeye.com/blog/652623
数值表达式
1. 奇偶判断

2. 小数精确计算
System.out.println(2.00 -1.10);//0.8999999999999999
System.out.println(200-110);//90

System.out.println(new BigDecimal("2.0").subtract(new BigDecimal("1.10")));// 0.9

3. int整数相乘溢出

long microsPerDay = 24 * 60 * 60 * 1000 * 1000;// 正确结果应为：86400000000
System.out.println(microsPerDay);// 实际上为：500654080

long microsPerDay = 24L * 60 * 60 * 1000 * 1000;

4. 负的十六进制与八进制字面常量

System.out.println(0x80);//128
//0x81看作是int型，最高位(第32位)为0，所以是正数
System.out.println(0x81);//129
System.out.println(0x8001);//32769
System.out.println(0x70000001);//1879048193
//字面量0x80000001为int型，最高位(第32位)为1，所以是负数
System.out.println(0x80000001);//-2147483647
//字面量0x80000001L强制转为long型，最高位（第64位）为0，所以是正数
System.out.println(0x80000001L);//2147483649
//最小int型
System.out.println(0x80000000);//-2147483648
//只要超过32位，就需要在字面常量后加L强转long，否则编译时出错
System.out.println(0x8000000000000000L);//-9223372036854775808

System.out.println(Long.toHexString(0x100000000L + 0xcafebabe));// cafebabe

System.out.println(Long.toHexString(0x100000000L + 0xcafebabeL));// 1cafebabe

5. 窄数字类型提升至宽类型时使用符号位扩展还是零扩展
System.out.println((int)(char)(byte)-1);// 65535
int i = c & 0xffff;//实质上等同于：int i = c ;
int i = (short)c;
char c = (char)(b & 0xff);// char c = (char) b;为有符号扩展
[size=medium]
6. ((byte)0x90 == 0x90)?

((byte)0x90 & 0xff)== 0x90

7. 三元表达式（?:）

char x = 'X';
int i = 0;
System.out.println(true ? x : 0);// X
System.out.println(false ? i : x);// 88

final int i = 0;
System.out.println(false ? i : x);// X

public class T {
public static void main(String[] args) {
System.out.println(f());
}
public static T f() {
// !!1.4不能编译，但1.5可以
// !!return true?new T1():new T2();
return true ? (T) new T1() : new T2();// T1
}
}
class T1 extends T {
public String toString() {
return "T1";
}
}
class T2 extends T {
public String toString() {
return "T2";
}
}

在JAVA程序中，性能问题的大部分原因并不在于JAVA语言，而是程序本身。养成良好的编码习惯非常重要，能够显著地提升程序性能。
1. 尽量使用final修饰符。
2.尽量重用对象。
3. 尽量使用局部变量。
4.不要重复初始化变量。
5.在java+Oracle的应用系统开发中，java中内嵌的SQL语言应尽量使用大写形式，以减少Oracle解析器的解析负担。
6.java编程过程中，进行数据库连接，I/O流操作，在使用完毕后，及时关闭以释放资源。因为对这些大对象的操作会造成系统大的开销。

过分的创建对象会消耗系统的大量内存，严重时，会导致内存泄漏，因此，保证过期的对象的及时回收具有重要意义。
8.在使用同步机制时，应尽量使用方法同步代替代码块同步。

Java代码

for(int i=0;i<list.size();i++)

for(int i=0;i<list.size();i++)

Java代码

for(int i=0,len=list.size();i<len;i++)

for(int i=0,len=list.size();i<len;i++)

Java代码

String str="abc";
if(i==1){ list.add(str);}

String str="abc";
if(i==1){ list.add(str);}

Java代码

if(i==1){String str="abc"; list.add(str);}

if(i==1){String str="abc"; list.add(str);}

13.通过StringBuffer的构造函数来设定他的初始化容量，可以明显提升性能。

16.代码重构，增加代码的可读性。
17.不用new关键字创建对象的实例。

Java代码

public static Credit getNewCredit()
{
return new Credit();
}

public static Credit getNewCredit()
{
return new Credit();
}

Java代码

private static Credit BaseCredit = new Credit();
public static Credit getNewCredit()
{
return (Credit)BaseCredit.clone();
}

private static Credit BaseCredit = new Credit();
public static Credit getNewCredit()
{
return (Credit)BaseCredit.clone();
}

18. 乘除法如果可以使用位移，应尽量使用位移，但最好加上注释，因为位移操作不直观，难于理解。

Java代码

Map<String, String[]> paraMap = new HashMap<String, String[]>();
for( Entry<String, String[]> entry : paraMap.entrySet() )
{
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
}

Map<String, String[]> paraMap = new HashMap<String, String[]>();
for( Entry<String, String[]> entry : paraMap.entrySet() )
{
String appFieldDefId = entry.getKey();
String[] values = entry.getValue();
}