java减少代码体积,java怎么优化代码减少内存

java中的压缩原理是什么？

什么是压缩文件？ 简单的说，就是经过压缩软件压缩的文件叫压缩文件,压缩的原理是把文件的二进制代码压缩,把相邻的0,1代码减少,比如有000000,可以把它变成6个0 的写法60,来减少该文件的空间。 ■怎么压缩文件？ 首先要安装压缩软件，现在比较流行的是WinRAR「一种高效快速的文件压缩软件(中文版)」。 其次是建立一个压缩包：选择你要制作成压缩包的文件或文件夹，当然你也可也多选，方法同资源管理器，也就是按住Ctrl或Shift再选择文件（文件夹）。 选取完毕之后，就可以单击工具栏上的“压缩”按钮，在这里你可以选择压缩格式：RAR和ZIP。 如果你想得到较大的压缩率，建议选择RAR格式。 各个选项选择好以后，单击确定按钮就开始制作压缩包了，非常方便。有时候大家会遇到这个问题，就是你在一个论坛里要上传一些文件压缩包，压缩包大小有3M，但是论坛限制会员上传大小只有2M，怎么办呢？ 其实办法很简单，就是在你压缩这个文件时，分成几个带分卷压缩包，分卷包大小设置为2M即可，比如：原来文件名为123.rar(3M)，压缩成分卷包后为123.part1.rar(2M)与123.part2.rar(1M)两个文件，这样你就可以上传了。 具体方法如下： 1、在要压缩的文件上点右键 2、添加到压缩文件.... 3、选常规 4、压缩方式选最好 5、批定压缩分卷大小(按字节计算)，1M = 1024K，1K = 1024字节，填写数字即可 当你下载了带有分卷的压缩包后，如何解压文件呢？ 具体方法如下： 1、把所有的压缩分卷全部下载完整 2、所有分卷必须在同一个文件夹内 3、然后双击解压第一个分卷，即可 注：分卷解压的文件必须是连续的，若分卷未下载完整，则解压时自然会提示需要下一压缩分卷

有没有减小jar包体积的办法

通常回答只有两种，一种是制作一个可执行的 JAR 文件包，然后就可以像.chm 文档一样双击运行了；而另一种是使用 JET 来进行 编译。但是 JET 是要用钱买的，而且据说 JET 也不是能把所有的 Java 程序都编译成执行文件，性能也要打些折扣。所以，使用制作可执行 JAR 文件包的方法就是最佳选择了，何况它还能保持 Java 的跨平台特性。 下面就来看看什么是 JAR 文件包吧： 一. JAR 文件包 JAR 文件就是 Java Archive File，顾名思意，它的应用是与 Java 息息相关的，是 Java 的一种文档格式。JAR 文件非常类似 ZIP 文件——准确的说，它就是 ZIP 文件，所以叫它文件包。JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中，包含了一个 META-INF/MANIFEST.MF 文件，这个文件是在生成 JAR 文件的时候自动创建的。举个例子，如果我们具有如下目录结构的一些文件： == `-- test `-- Test.class 把它压缩成 ZIP 文件 test.zip，则这个 ZIP 文件的内部目录结构为： test.zip `-- test `-- Test.class 如果我们使用 JDK 的 jar 命令把它打成 JAR 文件包 test.jar，则这个 JAR 文件的内部目录结构为： test.jar |-- META-INF |　 `-- MANIFEST.MF `-- test `--Test.class 二. 创建可执行的 JAR 文件包 制作一个可执行的 JAR 文件包来发布你的程序是 JAR 文件包最典型的用法。 Java 程序是由若干个 .class 文件组成的。这些 .class 文件必须根据它们所属的包不同而分级分目录存放；运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命令的 -cp 参数；运行时还要到控制台下去使用 java 命令来运行，如果需要直接双击运行必须写 Windows 的批处理文件 (.bat) 或者 Linux 的 Shell 程序。因此，许多人说，Java 是一种方便开发者苦了用户的程序设计语言。 其实不然，如果开发者能 够制作一个可执行的 JAR 文件包交给用户，那么用户使用起来就方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候，安装文件会将 .jar 文件映射给 javaw.exe 打开。那么，对于一个可执行的 JAR 文件包，用户只需要双击它就可以运行程序了，和阅读 .chm 文档一样方便 (.chm 文档默认是由 hh.exe 打开的)。那么，现在的关键，就是如何来创建这个可执行的 JAR 文件包。 创建可执行的 JAR 文件包，需要使用带 cvfm 参数的 jar 命令，同样以上述 test 目录为例，命令如下： jar cvfm test.jar manifest.mf test 这 里 test.jar 和 manifest.mf 两个文件，分别是对应的参数 f 和 m，其重头戏在 manifest.mf。因为要创建可执行的 JAR 文件包，光靠指定一个 manifest.mf 文件是不够的，因为 MANIFEST 是 JAR 文件包的特征，可执行的 JAR 文件包和不可执行的 JAR 文件包都包含 MANIFEST。关键在于可执行 JAR 文件包的 MANIFEST，其内容包含了 Main-Class 一项。这在 MANIFEST 中书写格式如下： Main-Class: 可执行主类全名(包含包名) 例如，假设上例中的 Test.class 是属于 test 包的，而且是可执行的类 (定义了 public static void main(String[]) 方法)，那么这个 manifest.mf 可以编辑如下： Main-Class: test.Test ; 这个 manifest.mf 可以放在任何位置，也可以是其它的文件名，只需要有 Main-Class: test.Test 一行，且该行以一个回车符结束即可。创建了 manifest.mf 文件之后，我们的目录结构变为： == |-- test |　 `-- Test.class `-- manifest.mf 这时候，需要到 test 目录的上级目录中去使用 jar 命令来创建 JAR 文件包。也就是在目录树中使用“==”表示的那个目录中，使用如下命令： jar cvfm test.jar manifest.mf test 之后在“==”目录中创建了 test.jar，这个 test.jar 就是执行的 JAR 文件包。运行时只需要使用 java -jar test.jar 命令即可。 需 要注意的是，创建的 JAR 文件包中需要包含完整的、与 Java 程序的包结构对应的目录结构，就像上例一样。而 Main-Class 指定的类，也必须是完整的、包含包路径的类名，如上例的 test.Test；而且在没有打成 JAR 文件包之前可以使用 java ; 来运行这个类，即在上例中 java test.Test 是可以正确运行的 (当然要在 CLASSPATH 正确的情况下)。 三. jar 命令详解 jar 是随 JDK 安装的，在 JDK 安装目录下的 bin 目录中，Windows 下文件名为 jar.exe，Linux 下文件名为 jar。它的运行需要用到 JDK 安装目录下 lib 目录中的 tools.jar 文件。不过我们除了安装 JDK 什么也不需要做，因为 SUN 已经帮我们做好了。我们甚至不需要将 tools.jar 放到 CLASSPATH 中。 使用不带任何的 jar 命令我们可以看到 jar 命令的用法如下： jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 ... 其中 {ctxu} 是 jar 命令的子命令，每次 jar 命令只能包含 ctxu 中的一个，它们分别表示： -c　创建新的 JAR 文件包 -t　列出 JAR 文件包的内容列表 -x　展开 JAR 文件包的指定文件或者所有文件 -u　更新已存在的 JAR 文件包 (添加文件到 JAR 文件包中) [vfm0M] 中的选项可以任选，也可以不选，它们是 jar 命令的选项参数 -v　生成详细报告并打印到标准输出 -f　指定 JAR 文件名，通常这个参数是必须的 -m　指定需要包含的 MANIFEST 清单文件 -0　只存储，不压缩，这样产生的 JAR 文件包会比不用该参数产生的体积大，但速度更快 -M　不产生所有项的清单（MANIFEST〕文件，此参数会忽略 -m 参数 [jar-文件] 即需要生成、查看、更新或者解开的 JAR 文件包，它是 -f 参数的附属参数 [manifest-文件] 即 MANIFEST 清单文件，它是 -m 参数的附属参数 [-C 目录] 表示转到指定目录下去执行这个 jar 命令的操作。它相当于先使用 cd 命令转该目录下再执行不带 -C 参数的 jar 命令，它只能在创建和更新 JAR 文件包的时候可用。 文件名 ... 指定一个文件/目录列表，这些文件/目录就是要添加到 JAR 文件包中的文件/目录。如果指定了目录，那么 jar 命令打包的时候会自动把该目录中的所有文件和子目录打入包中。 下面举一些例子来说明 jar 命令的用法： 一) jar cf test.jar test 该命令没有执行过程的显示，执行结果是在当前目录生成了 test.jar 文件。如果当前目录已经存在 test.jar，那么该文件将被覆盖。 二) jar cvf test.jar test 该命令与上例中的结果相同，但是由于 v 参数的作用，显示出了打包过程，如下： 标明清单(manifest) 增加：test/(读入= 0) (写出= 0)(存储了 0%) 增加：test/Test.class(读入= 漆) (写出= 陆)(压缩了 一四%) 三) jar cvfM test.jar test 该命令与 二) 结果类似，但在生成的 test.jar 中没有包含 META-INF/MANIFEST 文件，打包过程的信息也略有差别： 增加：test/(读入= 0) (写出= 0)(存储了 0%) 增加：test/Test.class(读入= 漆) (写出= 陆)(压缩了 一四%) 四) jar cvfm test.jar manifest.mf test 运行结果与 二) 相似，显示信息也相同，只是生成 JAR 包中的 META-INF/MANIFEST 内容不同，是包含了 manifest.mf 的内容 5) jar tf test.jar 在 test.jar 已经存在的情况下，可以查看 test.jar 中的内容，如对于 二) 和 三) 生成的 test.jar 分别应该此命令，结果如下； 对于 二) META-INF/ META-INF/MANIFEST.MF test/ test/Test.class 对于 三) test/ test/Test.class 陆) jar tvf test.jar 除显示 5) 中显示的内容外，还包括包内文件的详细信息，如： 0 Wed Jun 一9 一5:三9:0陆 GMT 二00二 META-INF/ 吧陆 Wed Jun 一9 一5:三9:0陆 GMT 二00二 META-INF/MANIFEST.MF 0 Wed Jun 一9 一5:三三:0四 GMT 二00二 test/ 漆 Wed Jun 一9 一5:三三:0四 GMT 二00二 test/Test.class 漆) jar xf test.jar 解开 test.jar 到当前目录，不显示任何信息，对于 二) 生成的 test.jar，解开后的目录结构如下： == |-- META-INF |　 `-- MANIFEST `-- test `--Test.class 吧) jar xvf test.jar 运行结果与 漆) 相同，对于解压过程有详细信息显示，如： 创建：META-INF/ 展开：META-INF/MANIFEST.MF 创建：test/ 展开：test/Test.class 9) jar uf test.jar manifest.mf 在 test.jar 中添加了文件 manifest.mf，此使用 jar tf 来查看 test.jar 可以发现 test.jar 中比原来多了一个 manifest。这里顺便提一下，如果使用 -m 参数并指定 manifest.mf 文件，那么 manifest.mf 是作为清单文件 MANIFEST 来使用的，它的内容会被添加到 MANIFEST 中；但是，如果作为一般文件添加到 JAR 文件包中，它跟一般文件无异。 一0) jar uvf test.jar manifest.mf 与 9) 结果相同，同时有详细信息显示，如： 增加：manifest.mf(读入= 一漆) (写出= 一9)(压缩了 -一一%) 四. 关于 JAR 文件包的一些技巧 一) 使用 unzip 来解压 JAR 文件 在 介绍 JAR 文件的时候就已经说过了，JAR 文件实际上就是 ZIP 文件，所以可以使用常见的一些解压 ZIP 文件的工具来解压 JAR 文件，如 Windows 下的 WinZip、WinRAR 等和 Linux 下的 unzip 等。使用 WinZip 和 WinRAR 等来解压是因为它们解压比较直观，方便。而使用 unzip，则是因为它解压时可以使用 -d 参数指定目标目录。 在解压一个 JAR 文件的时候是不能使用 jar 的 -C 参数来指定解压的目标的，因为 -C 参数只在创建或者更新包的时候可用。那么需要将文件解压到某个指定目录下的时候就需要先将这具 JAR 文件拷贝到目标目录下，再进行解压，比较麻烦。如果使用 unzip，就不需要这么麻烦了，只需要指定一个 -d 参数即可。如： unzip test.jar -d dest/ 二) 使用 WinZip 或者 WinRAR 等工具创建 JAR 文件 上 面提到 JAR 文件就是包含了 META-INF/MANIFEST 的 ZIP 文件，所以，只需要使用 WinZip、WinRAR 等工具创建所需要 ZIP 压缩包，再往这个 ZIP 压缩包中添加一个包含 MANIFEST 文件的 META-INF 目录即可。对于使用 jar 命令的 -m 参数指定清单文件的情况，只需要将这个 MANIFEST 按需要修改即可。 三) 使用 jar 命令创建 ZIP 文件 有 些 Linux 下提供了 unzip 命令，但没有 zip 命令，所以需要可以对 ZIP 文件进行解压，即不能创建 ZIP 文件。如要创建一个 ZIP 文件，使用带 -M 参数的 jar 命令即可，因为 -M 参数表示制作 JAR 包的时候不添加 MANIFEST 清单，那么只需要在指定目标 JAR 文件的地方将 .jar 扩展名改为 .zip 扩展名，创建的就是一个不折不扣的 ZIP 文件了，如将上一节的第 三) 个例子略作改动： jar cvfM test.zip tes

java编的程序为什么体积非常小？

手机平台用的java，是java的精简版本，一般称作j2me，而楼主所说的java，是j2se或者j2ee。j2me的功能非常小，仅仅支持最基本的java函数，。java文件打包通过sun公司提供的wtk打包，将源程序放在src文件夹中，资源文件放于res文件夹中，然后生成就可以了。源程序可以到下载。

楼主如果不想做手机游戏的话，就可以不用考虑为自己的手机上增加自己写的东西了，因为j2me主要是用来开发手机游戏，想从事此项目的开发，必须得经过专业的培训才行，不是一两句话能说的明白的，楼主可以到网上搜寻j2me相关的信息看看

c#和java哪个更好点。

很多人说C#是微软用来和Java抗衡的武器，因为二者在很大程度上有着惊人的相似

，尽管如此，两者不同的地方也很多，所谓“于细微处见差异”。那么两者的相似和区

别都在什么地方呢？我们从今天开始，会从各个角度来对比C#和Java的特点，希望能对

正在学习、使用C#的朋友有所帮助。

1、C#和.NET平台的概貌

2000年6月，微软发布C#语言和.NET平台。C#语言是一种强类型的，面向对象的语言

，它具有语法简单、表达力强的特点，而.NET平台则是构成微软的“.NET计划”的基石

。

.NET平台的核心包括两方面，一方面就是著名的通用语言运行机(Common Language

Runtime)，虽然这个名词起得晦涩了点，不过大家可以拿它和Java的虚拟机来作比较，

二者完成的任务大致相同；另一方面就是一大堆通用函数库，这些库函数可以被多种语

言调用，并且通过编译都产生一种共同的中间语言（Intermediate Language），这种语

言也可以拿Java的字节码来类比，虽然完成的方式有些不一样。

2、C#和Java

下面简单地把C#和Java的相似处列出来，虽然在这里我们重点讨论的是C#和Java的

不同点，但是了解一下二者的相同之处也是很有必要的。

二者都编译成跨平台的、跨语言的代码，并且代码只能在一个受控制的环境中运行

自动回收垃圾内存，并且消除了指针（在C#中可以使用指针，不过必须注明unsafe

关键字）

都不需要头文件，所有的代码都被“包(package)”限制在某个范围内，并且因为没

有头文件，所以消除了类定义的循环依赖

所有的类都是从对象派生出来，并且必须使用New关键字分配内存

用对象加锁的方式来支持多线程

都具有接口(interface)的概念

内部类

继承类的时候不会以某种特定的访问权限来继承；

没有全局函数或者常量，一切必须属于类；

数组或者字符串都自带长度计算和边界检查；

只使用“.”操作符，没有“-”和“::”；

“null”、“boolean”和“bool”成为了关键字；

任何变量均在使用前进行初始化；

不能使用整数来返回到if条件语句中，必须使用布尔值；

“Try”模块后可以有“finally” ；

3. 属性（Property）

属性的概念对大家来说应该是很熟悉的，类成员函数可以自由地访问本类中的任何

属性成员。不过若要从一个类中去访问另一个类中的属性，那就比较麻烦了，所以很多

时候我们使用Getxxx和Setxxx方法，这样看起来显得极不自然，比如用Java或者C++，代

码是这样的：

foo.setSize (getSize () + 1);

label.getFont().setBold (true);

但是，在C#中，这样的方法被“属性化”了。同样的代码，在C#就变成了：

foo.size++;

label.font.bold = true;

可以看出来，C#显然更容易阅读和理解。我们从这个“属性方法”的子程序代码中

，也可以看到类似情况：

Java/C++:

public int getSize()

{

return size;

}

public void setSize (int value)

{

size = value;

}

C#:

public int Size

{

　get{return size;}

　set{size = value;}

}

为了区分这种属性化的方法和类的属性成员，在C#中把属性成员称作“域(field)”

，而“属性”则成为这种“属性化的方法”专用的名词。顺便说一句，其实这样的属性

化方法在VB和DELPHI中是经常碰到的，在VB中它也就叫属性。

另外，在C#中Get和Set必须成对出现，一种属性不能只有Get而没有Set（在Java和

C++中就可以只有Get或者只有Set），C#中这样做的好处在于便于维护，假如要对某种属

性进行修改，就会同时注意Get和Set方法，同时修改，不会改了这个忘了那个。

4、对象索引机制（Indexer）

C#中引入了对象索引机制。说得明白点，对象索引其实就是对象数组。这里和上一

节中的属性联系起来讲一下，属性需要隐藏Get和Set方法，而在索引机制中，各个对象

的Get或者Set方法是暴露出来的。比如下面的例子就比较清楚地说明了这一点。

public class Skyscraper

{

　Story[] stories;

　public Story this [int index] {

get {

　return stories [index];

}

set {

　if (value != null) {

stories [index] = value;

　}

}

　}

...

}

5. 指代（Delegate）

指代这个玩意很特别，它有点象指针，但又不完全是，不过大家还是可以把它理解

为一种类型安全的、面向对象的指针。（什么是类型安全和面向对象就不用讲了吧？）

顺便提一句，有很多书上把Delegate翻译成代理，我觉得这样翻不够确切，翻译成“指

代”更恰当些，道理上吻合，并且还符合它的本来意思——微软本来就是用Delegate来

“取代指针”，所以叫“指代”，呵呵。

说起指代，也许至今Sun还会对它愤愤不已，为什么呢？因为在Sun的标准Java中是

没有这个东西的，它是微软99年发布的MSVJ++6添加的“新特性”。为此，两家公司吵得

不亦乐乎，并且还专门在网上写了大量文章互相攻击，有兴趣的朋友可以去看看（只有

英文版）。

话归正传，指代有什么特点呢？一个明显的特点就是它具有了指针的行为，就好象

从Java又倒回到了C++。在C#中，指代完成的功能大概和C++里面的指针，以及Java中的

接口相当。但是，指代比起C++的“正宗指针”来又要高明一些，因为它可以同时拥有多

个方法，相当于C++里面的指针能同时指向多个函数，并且是类型安全的，这一点体现了

它的“对象”特性；而比起Java的接口来，指代高明的地方在于它能可以不经过内部类

就调用函数，或者用少量代码就能调用多种函数，这一点体现了它的“指针”特性。呵

呵，很有“波粒二象性”的味道吧？指代最重要的应用在于对于事件的处理，下一节我

们将重点介绍。

6、事件（Event）

C#对事件是直接支持的（这个特点也是MSVJ所具有的）。当前很多主流程序语言处

理事件的方式各不相同，Delphi采用的是函数指针（这在Delphi中的术语是“closure”

）、Java用改编类来实现、VC用WindowsAPI的消息系统，而C#则直接使用delegate和ev

ent关键字来解决这个问题。下面让我们来看一个例子，例子中会给大家举出声明、调用

和处理事件的全过程。

//首先是指代的声明，它定义了唤醒某个函数的事件信号

public delegate void ScoreChangeEventHandler (int newScore, ref bool cancel)

;

//定义一个产生事件的类

public class Game

{

　// 注意这里使用了event关键字

　public event ScoreChangeEventHandler ScoreChange;

int score;

// Score 属性

public int Score

{

　get {

return score;

　}

　set {

if (score != value)

{

　bool cancel = false;

　ScoreChange (value, ref cancel);

　if (! cancel)

　score = value;

}

}

}

// 处理事件的类

public class Referee

{

　public Referee (Game game)

　{

// 裁判负责调整比赛中的分数变化

game.ScoreChange += new ScoreChangeEventHandler (game_ScoreChange);

　}

　// 注意这里的函数是怎样和ScoreChangeEventHandler的信号对上号的

　private void game_ScoreChange (int newScore, ref bool cancel)

　{

if (newScore 100)

　System.Console.WriteLine ("Good Score");

else

{

　cancel = true;

　System.Console.WriteLine ("No Score can be that high!");

}

　}

}

// 主函数类，用于测试上述特性

public class GameTest

{

　public static void Main ()

　{

Game game = new Game ();

Referee referee = new Referee (game);

game.Score = 70;

game.Score = 110;

　}

}

在主函数中，我们创建了一个game对象和一个裁判对象，然后我们通过改变比赛分

数，来观察裁判对此会有什么响应。

请注意，我们的这个系统中，Game对象是感觉不到裁判对象的存在的，Game对象在

这里只负责产生事件，至于有谁会来倾听这个事件，并为之作出反应，Game对象是不作

任何表态的。

我们注意到，在裁判类的Referee函数中，Game.ScoreChange后面使用了+=和-=操作

符，这是什么意思呢？回到我们定义ScoreChange的地方，可以发现ScoreChange是用ev

ent关键字修饰的，那么这里的意思就很明白了：ScoreChange是一个事件，而事件被触

发后需要相应的事件处理机制，+=/-=就是为这个事件增加/移除相对应的事件处理程序

，而且，并不是一个事件只能对应一个处理程序，我们还可以用这两个操作符为同一事

件增加/移除数个事件处理程序。怎么样？很方便吧！

在实际应用中，和我们上面讲的（竞赛-裁判）机制很相近的系统就是图形用户界面

系统了。Game对象可以看作是图形界面上的小零件，而得分事件就相当于用户输入事件

，而裁判就相当于相应的应用程序，用于处理用户输入。

指代机制的首次亮相是在MSVJ里，它是由Anders Hejlsberg发明的，现在又用到了

C#中。指代用在Java语言中的后果，则直接导致了微软和Sun之间对类和指针的关系产生

了大量的争论和探讨。有意思的是，Java的发明者James Gosling非常幽默地称呼指代的

发明者Anders Hejlsberg为“‘函数指针’先生”，因为Anders Hejlsberg总是想方设

法地把指针变相地往各种语言中放；不过有人在看了Java中大量地使用了各种类后，也

戏称Java的发明者James Gosling为“‘全都是类’先生”，真是其中滋味，尽在不言中

啊。

在MyEcjava里java代码太长，在代码里写些什么关键词可把代码收起来?

这个。。。java现在还没那么先进，你把一行拆成两行不行吗

还是那句话，没有什么关键词可以使当前语句自动收缩，那是IDE干的活。。。

如果你怕别人无意修改代码，那么多写几个类，用继承和重构的方法来减少一个类里的代码量

如何优化JAVA代码及提高执行效率

可供程序利用的资源（内存、CPU时间、网络带宽等）是有限的，优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容：减小代码的体积，提高代码的运行效率。本文讨论的主要是如何提高代码的效率。

在Java程序中，性能问题的大部分原因并不在于Java语言，而是在于程序本身。养成好的代码编写习惯非常重要，比如正确地、巧妙地运用java.lang.String类和java.util.Vector类，它能够显著地提高程序的性能。下面我们就来具体地分析一下这方面的问题。

1、 尽量指定类的final修饰符带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%

。

2、 尽量重用对象。特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。

3、 尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。

4、 不要重复初始化变量 默认情况下，调用类的构造函数时，

Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。

5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。

6、 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，即使关闭以释放资源。因为对这些大对象的操作会造成系统大的开销，稍有不慎，会导致严重的后果。

7、 由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置成null。

8、 在使用同步机制时，应尽量使用方法同步代替代码块同步。

9、 尽量减少对变量的重复计算

例如：for(int i = 0;i list.size; i ++) {

…

}

应替换为：

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

…

}

10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。

例如： String str = “aaa”;

if(i == 1) {

list.add(str);

}

应替换为：

if(i == 1) {

String str = “aaa”;

list.add(str);

}

11、慎用异常

异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。

12、不要在循环中使用：

Try {

} catch() {

}

应把其放置在最外层。

13、StringBuffer 的使用：

StringBuffer表示了可变的、可写的字符串。

有三个构造方法 :

StringBuffer (); //默认分配16个字符的空间

StringBuffer (int size); //分配size个字符的空间

StringBuffer (String str); //分配16个字符+str.length()个字符空间

你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。这里提到的构造函数是StringBuffer(int

length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int

minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的途径。

StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也就是（2*旧值+2）。如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来立竿见影的性能增益。

StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。

14、合理的使用Java类 java.util.Vector。

简单地说，一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似，它的元素可以通过整数形式的索引访问。但是，Vector类型的对象在创建之后，对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子：

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0;

I100000; I++) { v.add(0,obj); }

除非有绝对充足的理由要求每次都把新元素插入到Vector的前面，否则上面的代码对性能不利。在默认构造函数中，Vector的初始存储能力是10个元素，如果新元素加入时存储能力不足，则以后存储能力每次加倍。Vector类就象StringBuffer类一样，每次扩展存储能力时，所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级：

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0; I100000; I++) { v.add(obj); }

同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”，删除除最后一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也就是说，从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。

假设要从前面的Vector删除所有元素，我们可以使用这种代码：

for(int I=0; I100000; I++)

{

　v.remove(0);

}

但是，与下面的代码相比，前面的代码要慢几个数量级：

for(int I=0; I100000; I++)

{

　v.remove(v.size()-1);

}

从Vector类型的对象v删除所有元素的最好方法是：

v.removeAllElements();

假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码，它要从这个Vector中删除“Hello”字符串：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(s);

这些代码看起来没什么错误，但它同样对性能不利。在这段代码中，indexOf()方法对v进行顺序搜索寻找字符串“Hello”，remove(s)方法也要进行同样的顺序搜索。改进之后的版本是：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(i);

这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置，从而避免了第二次搜索。一个更好的版本是：

String s = "Hello"; v.remove(s);

最后，我们再来看一个有关Vector类的代码片段：

for(int I=0; I++;I v.length)

如果v包含100,000个元素，这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法，但它仍旧需要一次方法调用的开销，至少JVM需要为它配置以及清除堆栈环境。在这里，for循环内部的代码不会以任何方式修改Vector类型对象v的大小，因此上面的代码最好改写成下面这种形式：

int size = v.size(); for(int I=0; I++;Isize)

虽然这是一个简单的改动，但它仍旧赢得了性能。毕竟，每一个CPU周期都是宝贵的。

15、当复制大量数据时，使用System.arraycopy()命令。

16、代码重构：增强代码的可读性。

例如：

public class ShopCart {

private List carts ;

…

public void add (Object item) {

if(carts == null) {

carts = new ArrayList();

}

crts.add(item);

}

public void remove(Object item) {

if(carts. contains(item)) {

carts.remove(item);

}

}

public List getCarts() {

//返回只读列表

return Collections.unmodifiableList(carts);

}

//不推荐这种方式

//this.getCarts().add(item);

}

17、不用new关键词创建类的实例

用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。

在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：

public static Credit getNewCredit() {

return new Credit();

}

改进后的代码使用clone()方法，如下所示：

private static Credit BaseCredit = new Credit();

public static Credit getNewCredit() {

return (Credit) BaseCredit.clone();

}

上面的思路对于数组处理同样很有用。

18、乘法和除法

考虑下面的代码：

for (val = 0; val 100000; val +=5) {

alterX = val * 8; myResult = val * 2;

}

用移位操作替代乘法操作可以极大地提高性能。下面是修改后的代码：

for (val = 0; val 100000; val += 5) {

alterX = val 3; myResult = val 1;

}

修改后的代码不再做乘以8的操作，而是改用等价的左移3位操作，每左移1位相当于乘以2。相应地，右移1位操作相当于除以2。值得一提的是，虽然移位操作速度快，但可能使代码比较难于理解，所以最好加上一些注释。

19、在JSP页面中关闭无用的会话。

一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 %@pagesession="false"% 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession

session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。

对于那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。使用如下page指令：%@ page session="false"%

20、JDBC与I/O

如果应用程序需要访问一个规模很大的数据集，则应当考虑使用块提取方式。默认情况下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。

[p][/p]21、Servlet与内存使用

许多开发者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看，典型的症状是用户感到系统周期性地变慢，却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。

解决这类内存问题主要有二种办法。第一种办法是，在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这样，只要实现valueUnbound()方法，就可以显式地释放Bean使用的资源。另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外，也可以用编程的方式调用会话的setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器允许的客户请求的最大间隔时间，以秒计。

22、使用缓冲标记

一些应用服务器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open

Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲整个页面。当JSP页面执行时，如果目标片断已经在缓冲之中，则生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求，并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说，这个功能极其有用。对于这类应用，页面级缓冲能够保存页面执行的结果，供后继请求使用。

23、选择合适的引用机制

在典型的JSP应用系统中，页头、页脚部分往往被抽取出来，然后根据需要引入页头、页脚。当前，在JSP页面中引入外部资源的方法主要有两种：include指令，以及include动作。

include指令：例如%@ include file="copyright.html"

%。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定，比运行时才确定资源更高效。

include动作：例如jsp:include page="copyright.jsp"

/。该动作引入指定页面执行后生成的结果。由于它在运行时完成，因此对输出结果的控制更加灵活。但时，只有当被引用的内容频繁地改变时，或者在对主页面的请求没有出现之前，被引用的页面无法确定时，使用include动作才合算。

24、及时清除不再需要的会话

为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多会话时，如果内存容量不足，操作系统会把部分内存数据转移到磁盘，应用服务器也可能根据“最近最频繁使用”（Most

Recently

Used）算法把部分不活跃的会话转储到磁盘，甚至可能抛出“内存不足”异常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再需要时，应当及时调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调用。

25、不要将数组声明为：public static final 。

26、HashMap的遍历效率讨论

经常遇到对HashMap中的key和value值对的遍历操作，有如下两种方法：MapString, String[] paraMap = new HashMapString, String[]();

................//第一个循环

SetString appFieldDefIds = paraMap.keySet();

for (String appFieldDefId : appFieldDefIds) {

String[] values = paraMap.get(appFieldDefId);

......

}

//第二个循环

for(EntryString, String[] entry : paraMap.entrySet()){

String appFieldDefId = entry.getKey();

String[] values = entry.getValue();

.......

}

第一种实现明显的效率不如第二种实现。

分析如下 SetString appFieldDefIds = paraMap.keySet(); 是先从HashMap中取得keySet

代码如下：

public SetK keySet() {

SetK ks = keySet;

return (ks != null ? ks : (keySet = new KeySet()));

}

private class KeySet extends AbstractSetK {

public IteratorK iterator() {

return newKeyIterator();

}

public int size() {

return size;

}

public boolean contains(Object o) {

return containsKey(o);

}

public boolean remove(Object o) {

return HashMap.this.removeEntryForKey(o) != null;

}

public void clear() {

HashMap.this.clear();

}

}

其实就是返回一个私有类KeySet, 它是从AbstractSet继承而来，实现了Set接口。

再来看看for/in循环的语法

for(declaration : expression_r)

statement

在执行阶段被翻译成如下各式

for(IteratorE #i = (expression_r).iterator(); #i.hashNext();){

declaration = #i.next();

statement

}

因此在第一个for语句for (String appFieldDefId : appFieldDefIds) 中调用了HashMap.keySet().iterator() 而这个方法调用了newKeyIterator()

IteratorK newKeyIterator() {

return new KeyIterator();

}

private class KeyIterator extends HashIteratorK {

public K next() {

return nextEntry().getKey();

}

}

所以在for中还是调用了

在第二个循环for(EntryString, String[] entry : paraMap.entrySet())中使用的Iterator是如下的一个内部类

private class EntryIterator extends HashIteratorMap.EntryK,V {

public Map.EntryK,V next() {

return nextEntry();

}

}

此时第一个循环得到key，第二个循环得到HashMap的Entry

效率就是从循环里面体现出来的第二个循环此致可以直接取key和value值

而第一个循环还是得再利用HashMap的get(Object key)来取value值

现在看看HashMap的get(Object key)方法

public V get(Object key) {

Object k = maskNull(key);

int hash = hash(k);

int i = indexFor(hash, table.length); //Entry[] table

EntryK,V e = table;

while (true) {

if (e == null)

return null;

if (e.hash == hash eq(k, e.key))

return e.value;

e = e.next;

}

}

其实就是再次利用Hash值取出相应的Entry做比较得到结果，所以使用第一中循环相当于两次进入HashMap的Entry中

而第二个循环取得Entry的值之后直接取key和value，效率比第一个循环高。其实按照Map的概念来看也应该是用第二个循环好一点，它本来就是key和value的值对，将key和value分开操作在这里不是个好选择。