让JAVA代码更高效的技巧

1,将一些系统资源放在池中，如数据库连接,线程等.在standalone的应用中，数据库连接池可以使用一些开源的连接池实现，如C3P0,proxool和DBCP等，在运行在容器中的应用这可以使用服务器提供的DataSource.线程池可以使用JDK本身就提供的java.util.concurrent.ExecutorService.

importjava.util.concurrent.Executors;importjava.util.concurrent.ExecutorService;publicclassJavaThreadPool{publicstaticvoidmain(String[]args){ExecutorServicepool=Executors.newFixedThreadPool(2);Threadt1=newMyThread();Threadt2=newMyThread();Threadt3=newMyThread();Threadt4=newMyThread();Threadt5=newMyThread();pool.execute(t1);pool.execute(t2);pool.execute(t3);pool.execute(t4);pool.shutdown();}}classMyThreadextendsThread{publicvoidrun(){System.out.println(Thread.currentThread().getName()+"running....");}}

2,减少网络开销,在和数据库或者远程服务交互的时候,尽量将多次调用合并到一次调用中。

3,将经常访问的外部资源cache到内存中,简单的可以使用static的hashmap在应用启动的时候加载,也可以使用一些开源的cache框架,如OSCache和Ehcache等.和资源的同步可以考虑定期轮询和外部资源更新时候主动通知.或者在自己写的代码中留出接口(命令方式或者界面方式)共手动同步。

4,优化IO*作,JAVA*作文件的时候分InputStreamandOutputStream,ReaderandWriter两类,stream的方式要快,后者主要是为了*作字符而用的,在字符仅仅是ASCII的时候可以用stream的方式提高效率.JDK1.4之后的nio比io的效率更好。

OutputStreamout=newBufferedOutputStream(newFileOutputStream(newFile("d:/temp/test.txt")));out.write("abcde".getBytes());out.flush();out.close();

利用BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter减少对磁盘的直接访问次数。

FileReaderfr=newFileReader(f);BufferedReaderbr=newBufferedReader(fr);while(br.readLine()!=null)count++;

5不要频繁的new对象,对于在整个应用中只需要存在一个实例的类使用单例模式.对于String的连接*作,使用StringBuffer或者StringBuilder.对于utility类型的类通过静态方法来访问。

6,避免使用错误的方式,如Exception可以控制方法推出,但是Exception要保留stacktrace消耗*能,除非必要不要使用instanceof做条件判断,尽量使用比的条件判断方式.使用JAVA中效率高的类,比如ArrayList比Vector*能好。

7,对*能的考虑要在系统分析和设计之初就要考虑。

总之，一个系统运行时的*能,无非是从CPU，Memory和IO这三个主要方面来考虑优化.减少不必要的CPU消耗，减少不必要的IO*作，增加Memory利用效率。

第2篇：PHP代码优化技巧

PHP是一种通用开源脚本语言。语法吸收了C语言、Java和Perl的特点，入门门槛较低，易于学习，使用广泛，主要适用于Web开发领域。PHP的文件后缀名为php。下面小编为大家介绍PHP代码优化技巧，欢迎阅读参考！

1.echo比print快。

2.使用echo的多重参数代替字符串连接。

3.在执行for循环之前确定最大循环数，不要每循环一次都计算最大值，最好运用foreach代替。

4.对global变量，应该用完就unset()掉。

5.用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，单引号则不会。

6.函数代替正则表达式完成相同功能。

7.当执行变量$i的递增或递减时，$i++会比++$i慢一些。这种差异是PHP特有的，并不适用于其他语言，++$i更快是因为它只需要3条指令(opcodes)，$i++则需要4条指令。后置递增实际上会产生一个临时变量，这个临时变量随后被递增。而前置递增直接在原值上递增。

8.使用选择分支语句(switchcase)好于使用多个if，elseif语句。

9.利用var_dump进行PHP代码调试。如果你在寻找php调试技术，我必须说var_dump应该是你要找的目标，在显示php信息方面这个命令可以满足你的所有需要，而调试代码的多数情况与得到PHP中的数值有关。

10.在包含文件时使用完整路径，解析*作系统路径所需的时间会更少。

11.动辄创建全局数值是一种糟糕的做法，不过有时候实际情况的确又需要这么做。对于数据库表或数据库连接信息使用全局数值是一个不错的想法，但不要在你的PHP代码中频繁使用全局数值。另外，更好的一种做法是把你的全局变量存放在一个config.php文件中。

12.如果你想知道脚本开始执行的时刻，使用$_SERVER[‘REQUEST_TIME']要好于time()。

13.打开apache的mod_deflate模块。

14.用@屏蔽错误消息的做法非常低效。

15.尽量采用大量的PHP内置函数。

16.递增一个未预定义的局部变量要比递增一个预定义的局部变量慢9至10倍。

17.派生类中的方法运行起来要快于在基类中定义的同样的方法。

18.仅定义一个局部变量而没在函数中调用它，同样会减慢速度(其程度相当于递增一个局部变量)

19.Apache解析一个PHP脚本的时间要比解析一个静态HTML页面慢2至10倍。尽量多用静态HTML页面，少用脚本。

20.正如之前提到的，任何php网站中最重要的部分有99%的可能是数据库。因此，你需要非常熟悉如何正确的使用sql，学会关联表和更多高级的数据库技术。

21.调用带有一个参数的空函数，其花费的时间相当于执行7至8次的局部变量递增*作。

22.当*作字符串并需要检验其长度是否满足某种要求时，你想当然地会使用strlen()函数。此函数执行起来相当快，因为它不做任何计算，只返回zval结构(C的内置数据结构，用于存储PHP变量)中存储的已知字符串长度。

23.并不是所有情况都必须使用面向对象开发，面向对象往往开销很大，每个方法和对象调用都会消耗很多内存。

24.除非脚本可以缓存，否则每次调用时都会重新编译一次。引入一套PHP缓存机制通常可以提升25%至100%的*能，以免除编译开销。

第3篇：PHP代码优化技巧

PHP优化的目的是花最少的代价换来最快的运行速度与最容易维护的代码。本文给大家提供全面的优化技巧。以下仅供参考！

具体方法如下：

1、echo比print快。

2、使用echo的多重参数代替字符串连接。

3、在执行for循环之前确定最大循环数，不要每循环一次都计算最大值，最好运用foreach代替。

4、对global变量，应该用完就unset()掉。

5、用单引号代替双引号来包含字符串，这样做会更快一些。因为PHP会在双引号包围的字符串中搜寻变量，单引号则不会。

6、函数代替正则表达式完成相同功能。

7、当执行变量$i的递增或递减时，$i++会比++$i慢一些。这种差异是PHP特有的，并不适用于其他语言，++$i更快是因为它只需要3条指令(opcodes)，$i++则需要4条指令。后置递增实际上会产生一个临时变量，这个临时变量随后被递增。而前置递增直接在原值上递增。

8、使用选择分支语句（switchcase）好于使用多个if，elseif语句。

9、利用var_dump进行PHP代码调试。如果你在寻找php调试技术，我必须说var_dump应该是你要找的目标，在显示php信息方面这个命令可以满足你的所有需要，而调试代码的多数情况与得到PHP中的数值有关。

10、在包含文件时使用完整路径，解析*作系统路径所需的时间会更少。

11、动辄创建全局数值是一种糟糕的做法，不过有时候实际情况的确又需要这么做。对于数据库表或数据库连接信息使用全局数值是一个不错的想法，但不要在你的PHP代码中频繁使用全局数值。另外，更好的一种做法是把你的全局变量存放在一个config.php文件中。

12、如果你想知道脚本开始执行的时刻，使用$_SERVER[‘REQUEST_TIME’]要好于time()。

13、打开apache的mod_deflate模块。

14、用@屏蔽错误消息的做法非常低效。

15、尽量采用大量的PHP内置函数。

16、递增一个未预定义的局部变量要比递增一个预定义的局部变量慢9至10倍。

17、派生类中的方法运行起来要快于在基类中定义的同样的方法。

18、仅定义一个局部变量而没在函数中调用它，同样会减慢速度（其程度相当于递增一个局部变量）

19、Apache解析一个PHP脚本的时间要比解析一个静态HTML页面慢2至10倍。尽量多用静态HTML页面，少用脚本。

20、正如之前提到的，任何php网站中最重要的部分有99%的可能是数据库。因此，你需要非常熟悉如何正确的使用sql，学会关联表和更多高级的数据库技术。

21、调用带有一个参数的空函数，其花费的时间相当于执行7至8次的局部变量递增*作。

22、当*作字符串并需要检验其长度是否满足某种要求时，你想当然地会使用strlen()函数。此函数执行起来相当快，因为它不做任何计算，只返回zval结构（C的内置数据结构，用于存储PHP变量）中存储的已知字符串长度。

23、并不是所有情况都必须使用面向对象开发，面向对象往往开销很大，每个方法和对象调用都会消耗很多内存。

24、除非脚本可以缓存，否则每次调用时都会重新编译一次。引入一套PHP缓存机制通常可以提升25%至100%的*能，以免除编译开销。

第4篇：JAVA代码优化总结

通过使用一些辅助*工具来找到程序中的瓶颈，然后就可以对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程序的*能。而一个设计良好的程序能够精简代码，从而提高*能。

下面将提供一些在JAVA程序的设计和编码中，为了能够提高JAVA程序的*能，而经常采用的一些方法和技巧。

1.对象的生成和大小的调整。

JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象(或实例)。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的*能带来很大的影响。

例1：关于String,StringBuffer，+和append

JAVA语言提供了对于String类型变量的*作。但如果使用不当，会给程序的*能带来影响。如下面的语句：

Stringname=newString("HuangWeiFeng");

System.out.println(name+"ismyname");

看似已经很精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和*作：

(1)生成新的字符串newString(STR_1);

(2)复制该字符串;

(3)加载字符串常量"HuangWeiFeng"(STR_2);

(4)调用字符串的构架器(Constructor);

(5)保存该字符串到数组中(从位置0开始);

(6)从java.io.PrintStream类中得到静态的out变量;

(7)生成新的字符串缓冲变量newStringBuffer(STR_BUF_1);

(8)复制该字符串缓冲变量;

(9)调用字符串缓冲的构架器(Constructor);

(10)保存该字符串缓冲到数组中(从位置1开始);

(11)以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法;

(12)加载字符串常量"ismyname"(STR_3);

(13)以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法;

(14)对于STR_BUF_1执行toString命令;

(15)调用out变量中的println方法，输出结果。

由此可以看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些*作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。

经修改，上面的代码可以用如下的代码来替换。

StringBuffername=newStringBuffer("HuangWeiFeng");

System.out.println(name.append("ismyname.").toString());

系统将进行如下的*作：

(1)生成新的字符串缓冲变量newStringBuffer(STR_BUF_1);

(2)复制该字符串缓冲变量;

(3)加载字符串常量"HuangWeiFeng"(STR_1);

(4)调用字符串缓冲的构架器(Constructor);

(5)保存该字符串缓冲到数组中(从位置1开始);

(6)从java.io.PrintStream类中得到静态的out变量;

(7)加载STR_BUF_1;

(8)加载字符串常量"ismyname"(STR_2);

(9)以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法;

(10)对于STR_BUF_1执行toString命令(STR_3);

(11)调用out变量中的println方法，输出结果。

由此可以看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的*能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。

代码段1：

Stringname=newStringBuffer("HuangWeiFeng");

name+="ismy";

name+="name";

代码段2：

StringBuffername=newStringBuffer("HuangWeiFeng");

name.append("ismy");

name.append("name.").toString();

因此，充分的利用JAVA提供的库函数来优化程序，对提高JAVA程序的*能时非常重要的.其注意点主要有如下几方面;

(1)尽可能的使用静态变量(StaticClassVariables)

如果类中的变量不会随他的实例而变化，就可以定义为静态变量，从而使他所有的实例都共享这个变量。

例：

publicclassfoo

{

SomeObjectso=newSomeObject();

}

就可以定义为：

publicclassfoo

{

staticSomeObjectso=newSomeObject();

}

(2)不要对已生成的对象作过多的改变。

对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已经生成的对象实例。

例：

Stringname="Huang";

name="Wei";

name="Feng";

上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的*作，*能将得更差，因为系统将不得为此生成更多得临时变量，如上例1所示。

(3)生成对象时，要分配给它合理的空间和大小JAVA中的很多类都有它的默认的空间分配大小。对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程序中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。

(4)避免生成不太使用或生命周期短的对象或变量。对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。

(5)只在对象作用范围内进行初始化。JAVA允许在代码的任何地方定义和初始化对象。这样，就可以只在对象作用的范围内进行初始化。从而节约系统的开销。

例：

SomeObjectso=newSomeObject();

If(x==1)then

{

Foo=so.getXX();

}

可以修改为：

if(x==1)then

{

SomeObjectso=newSomeObject();

Foo=so.getXX();

}

2.异常(Exceptions)

JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。但是如果使用不当，也会给JAVA程序的*能带来影响。因此，要注意以下两点：

(1)避免对应用程序的逻辑使用try/catch

如果可以用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句。

(2)重用异常

在必须要进行异常的处理时，要尽可能的重用已经存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。

第5篇：Java代码格式规范

代码格式规范，仅是为了体现一种规范和美观，大家可根据各自情况和公司要求遵守自己的规范。下面是小编为大家搜集整理出来的有关于Java代码格式规范，希望可以帮助到大家！

publicclassCodeRule{

//声明变量，等号两边有空格。

privatestaticinti=1;

//方法声明，右括号和左大括号中间有空格。

publicstaticvoidmain(String[]args){

//if语句，比较连接符(>)左右有空格，小括号和大括号中间有空格。

//if与左括号中间有空格

if(i>0){

System.out.println(i);

}

//两个条件的连接(&&)，左右有空格。

if(i>0&&i<2){

System.out.println(i);

}

//if..else语句两种格式

//1.参考JDK，个人使用方式，else跟大括号，前后都有空格

if(i>0&&i<2){

System.out.println(i);

}elseif(i>2){

System.out.println(i+1);

}else{

System.out.println(i);

}

//2.参考HypericHQ源码,else另起一行，后仍有空格

if(i==1){

System.out.println(i);

}

else{

System.out.println(i);

}

//while语句，与if语句类型，while与括号中间有空格，括号内格式与if相同

while(i>0&&i<2){

System.out.println(i);

i++;

}

//for语句，两种格式

//1.参考HypericHQ，个人使用方式。分号后带空格，每个子语句中，连接符左右都带空格。

//for与括号中间带空格，大小括号中间带空格。

for(intj=0;j<10;j++){

System.out.println(i);

}

//2.参考JDK，区别在于子语句中，连接符左右无空格。

for(intj=0;j<10;j++){

System.out.println(i);

}

//+-*/，格式，四则运算符号前后有空格。

//在JDK的有些代码里，在方法调用的参传递或在判断语句中存在的四则运算中，四则运算符号前后无空格。

//为了不造成困扰和混淆，个人为均保留空格。

inta=1+2;

intb=1-2;

intc=1*2;

intd=1/2;

//三元表达式格式，每个符号中间均有空格

intj=i>2?1:-1;

//方法声明和调用，用逗号分隔的参数，逗号后有空格。

sum(a,b);

sum(c+d,j);

}

//方法声明，多个参数，逗号后有空格

privatestaticintsum(inti,intj){

returni+j;

}

}

注：如有遗漏和错误，欢迎指出，有错必改。

第6篇：Java代码复用规则

引导语：代码复用就是利用已有的代码，或者相关的知识去编写新的代码来构造软件。以下是百分网小编分享给大家的Java代码复用规则，欢迎阅读!

代码复用的规则

代码复用是绝大多数程序员所期望的，也是OO的目标之一。总结我多年的编码经验，为了使代码能够最大程度上复用，应该特别注意以下几个方面。

对接口编程

"对接口编程"是面向对象设计(OOD)的第一个基本原则。它的含义是：使用接口和同类型的组件通讯，即，对于所有完成相同功能的组件，应该抽象出一个接口，它们都实现该接口。具体到JAVA中，可以是接口(interface)，或者是抽象类(abstractclass)，所有完成相同功能的组件都实现该接口，或者从该抽象类继承。我们的客户代码只应该和该接口通讯，这样，当我们需要用其它组件完成任务时，只需要替换该接口的实现，而我们代码的其它部分不需要改变!

当现有的组件不能满足要求时，我们可以创建新的组件，实现该接口，或者，直接对现有的组件进行扩展，由子类去完成扩展的功能。

优先使用对象组合，而不是类继承

"优先使用对象组合，而不是类继承"是面向对象设计的第二个原则。并不是说继承不重要，而是因为每个学习OOP的人都知道OO的基本特*之一就是继承，以至于继承已经被滥用了，而对象组合技术往往被忽视了。下面分析继承和组合的优缺点：

类继承允许你根据其他类的实现来定义一个类的实现。这种通过生成子类的复用通常被称为白箱复用(white-boxreuse)。术语"白箱"是相对可视*而言：在继承方式中，父类的内部细节对子类可见。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组合对象来获得。对象组合要求对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-boxreuse)，因为被组合的对象的内部细节是不可见的。对象只以"黑箱"的形式出现。

继承和组合各有优缺点。类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变父类的实现。但是类继承也有一些不足之处。首先，因为继承在编译时刻就定义了，所以无法在运行时刻改变从父类继承的实现。更糟的是，父类通常至少定义了子类的部分行为，父类的任何改变都可能影响子类的行为。如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活*并最终限制了复用*。

对象组合是通过获得对其他对象的引用而在运行时刻动态定义的。由于组合要求对象具有良好定义的接口，而且，对象只能通过接口访问，所以我们并不破坏封装*;只要类型一致，运行时刻还可以用一个对象来替代另一个对象;更进一步，因为对象的实现是基于接口写的，所以实现上存在较少的依赖关系。

优先使用对象组合有助于你保持每个类被封装，并且只集中完成单个任务。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物(这正是滥用继承的后果)。另一方面，基于对象组合的设计会有更多的对象(但只有较少的类)，且系统的行为将依赖于对象间的关系而不是被定义在某个类中。

注意：理想情况下，我们不用为获得复用而去创建新的组件，只需要使用对象组合技术，通过组装已有的组件就能获得需要的功能。但是事实很少如此，因为可用的组件*并不丰富。使用继承的复用使得创建新的组件要比组装已有的组件来得容易。这样，继承和对象组合常一起使用。然而，正如前面所说，千万不要滥用继承而忽视了对象组合技术。

相关的设计模式有：Bridge、Composite、Decorator、Observer、Strategy等。

下面的例子演示了这个规则，它的前提是：我们对同一个数据结构，需要以任意的格式输出。

第一个例子，我们使用基于继承的框架，可以看到，它很难维护和扩展。

abstractclassAbstractExampleDocument

{

//skipsomecode...

publicvoidoutput(Examplestructure)

{

if(null!=structure)

{

this.format(structure);

}

}

protectedvoidformat(Examplestructure);

}

第二个例子，我们使用基于对象组合技术的框架，每个对象的任务都清楚的分离开来，我们可以替换、扩展格式类，而不用考虑其它的任何事情。

classDefaultExampleDocument

{

//skipsomecode...

publicvoidoutput(Examplestructure)

{

ExampleFormatterformatter=

(ExampleFormatter)manager.lookup(Roles.FORMATTER);

if(null!=structure)

{

formatter.format(structure);

}

}

}

这里，用到了类似于"抽象工厂"的组件创建模式，它将组件的创建过程交给manager来完成;ExampleFormatter是所有格式的抽象父类;

将可变的部分和不可变的部分分离

"将可变的部分和不可变的部分分离"是面向对象设计的第三个原则。如果使用继承的复用技术，我们可以在抽象基类中定义好不可变的部分，而由其子类去具体实现可变的部分，不可变的部分不需要重复定义，而且便于维护。如果使用对象组合的复用技术，我们可以定义好不可变的部分，而可变的部分可以由不同的组件实现，根据需要，在运行时动态配置。这样，我们就有更多的时间关注可变的部分。

对于对象组合技术而言，每个组件只完成相对较小的功能，相互之间耦合比较松散，复用率较高，通过组合，就能获得新的功能。

减少方法的长度

通常，我们的方法应该只有尽量少的几行，太长的方法会难以理解，而且，如果方法太长，则应该重新设计。对此，可以总结为以下原则：

☆三十秒原则：如果另一个程序员无法在三十秒之内了解你的函数做了什么(What)，如何做(How)以及为什么要这样做(Why)，那就说明你的代码是难以维护的，必须得到提高;

☆一屏原则：如果一个函数的代码长度超过一个屏幕，那么或许这个函数太长了，应该拆分成更小的子函数;

☆一行代码尽量简短，并且保证一行代码只做一件事：那种看似技巧*的冗长代码只会增加代码维护的难度。

消除case/if语句