阳光男孩

Java SE 是Java平台标准版的简称(Java Platform, Standard Edition) (also known as Java 2 Platform) ，用于开发和部署桌面、服务器以及嵌入设备和实时环境中的Java应用程序。Java SE包括用于开发Java Web服务的类库，同时，Java SE为Java EE提供了基础。Java SE(Java Platform, Standard Edition，Java标准版)就是基于JDK和JRE的。
Java是目前所有编程语言中最流行、发展最快的语言之一，随着Java SE 6.0的发布，Java也变得更加强大和易用。
Java SE 6 的第 29 个更新版本发布了，该版本修复了一些关键的bug. 此更新的完整版本的内部版本是1.6.0_29-b11(其中“B”代表“Build”)。外部版本号是6u29。
安全基准：

针对此次版本，发布的重要补丁更新包涵盖了20个Oracle Java SE新增的安全漏洞。其中19个漏洞在未经许可的情况下可以远程操控，比如在无需用户名和密码的情况下就可以远程登录。

至于部署方面的问题，只有在JDK和JRE7、JRE6中才能修复部署方面的漏洞。用户在最新的JDK以及JRE7或者JRE 6中，应该使用默认的Java插件和Java Web Start。
官网详细说明：http://www.oracle.com/technetwork/java/javase/6u29-relnotes-507960.html
下载地址：http://www.oracle.com/technetwork/java/javase/tzdata-versions-138805.html

10月19日消息，谷歌今天与三星在香港联合举办发布会，对外正式发布新机Galaxy Nexus，以及代号为“冰淇淋三明治”（Ice Cream Sandwich）的Android 4.0系统。
令人兴奋的是发布会结束后，Android 4.0随后也可以在Android开发中心下载。
新的SDK支持移动数据控制、高分辨率图像、面部识别、增强共享等功能。

具体详情请移步：
http://developer.android.com/sdk/android-4.0.html

由于JDart项目被托管在Google Code上的缘故，谷歌最新推出的编程语言现在可以运行在Java虚拟机上。上周“Goto”大会在丹麦奥胡斯举行，谷歌两位开发人员会借着主题演讲的机会来揭晓这门新语言的全貌。

Dart编程语言适合于那些对JavaScript并不感冒的Java编程人员。该语言可以使用结构化代码来快速创建原型。
Dart语言可以看做是JavaScript语言的替代品。Google已经意识到JavaScript在未来Web开发应用中起到的不可估量的作用，因此推出了Dart这种结构化Web编程语言，希望成为JavaScript的替代品。
Dart语言是一种面向对象的语言，设计的目标如下：用于创建Web应用程序的编程语言，突出结构化、灵活性，让程序员在Dart的学习中感到得心应手。
Dart代码以两种方式执行，一种是原生虚拟机，一种是JavaScript引擎，用编译器将Dart代码翻译成 JavaScript代码。这允许程序员在Dart中创建Web应用，编译后在任何浏览器上运行。Dart语言官网提供了名叫Dartboard的在线应用，让感兴趣的开发者在线上编程和运行。
JDart项目目前处于早期发展阶段，只提供少数翻译的指令。JDart编译器生成了jar文件可以运行在任意一台Java 7虚拟机上。作者提供了一些示例，您可以很清楚编译器真正生成的结果。以下提供一个简单的Hello World输出示例，Dart代码如下：

1 main() {
2 print(“hello world”);
3 }

编译结果如下：

1 public class test {
2 public static void main(java.lang.String[]);
3 Code:
4 0: invokedynamic #18,  0             // InvokeDynamic #0:__main__:()V
5 5: return
6
7 public static java.lang.Object __main__();
8 Code:
9 0: ldc           #21                 // String hello world
10 2: invokedynamic #27,  0             // InvokeDynamic #1:print:(Ljava/lang/String;)V
11 7: aconst_null
12 8: areturn
13 }

对于Dart而言，要想彻底替代JavaScript，还为时过早。但将它用于Web应用程序的开发，还不失为一种好的想法。

VisualVM是一个集成多个JDK命令行工具的可视化工具。可以作为Java应用程序性能分析和运行监控的工具。开发人员可以利用它来监控，分 析，获 胜Thread-Dumps，浏览Heap dumps。系统管理员可以利用它来监测，控制Java应用程序横跨整个网络的情况。Java应用程序使用人员可以利用它来创建包含所有必要信息的Bug 报告。

新版本主要改进包括：
自动死锁监测工具对没个线程CPU进行采样和内存分析支持 Eclipse IDE 3.6 或更新版本。

下面是我根据多年的阅读和实践经验，给您推荐的一些图书：
第一部分： Java语言篇
1 《Java编程规范》
  星级：
  适合对象：初级，中级
  介绍：作者James Gosling（Java之父），所以这本书我觉得你怎么也得读一下。对基础讲解的很不错。

2 《Java核心技术：卷Ⅰ基础知识》
  星级：
  适合对象：初级，中级
  介绍：官方机构图书，你怎么也得有一本，这本书比较全面而且易懂。放在案旁用到的时候查一查，看一看。是学习入门必备书。
   注：新手必备

3 《Java编程思想》
星级：
  适合对象：初级，中级
  介绍：这本书的作者就是著名的C++编程思想，对OO的理解很好，Java作为一门面向对象的语言，你学习Java最好也同时参考这本书进行入门学习。
  注：新手必备

4 《Effective Java》
  星级：
  适合对象：初级，中级，高级
  介绍：作者是Java的第2号人物，目前是Google的Java老大，是James Gosling强力推荐的一本书。

 5 《Java与模式》
  星级：
  适合对象：中级，高级
  介绍：是国人写的难得的值得购买的一本书，当然现在也有大话设计模式之类的出现，这本书出现的比较早，是初级到中高级必读的图书之一。
 注：没有理解面向对象前，读这本书没有意义。最好是有过项目经验再读比较好。

 6 《SCJP学习指南》 星级：
  适合对象：初级，中级
  介绍：官方考试必备图书，对你检验自己学些Java知识情况很有帮助，这本书最适合学生阅读，这本书理解透了，找工作面试Java题目不会有任何问题，工作多年的拿这里的题目不会做的都很多。

 7 《Java数据结构和算法》
  星级：
  适合对象：初级，中级，高级
  介绍：这本书使用Java语言描述了我们常用的数据结构，写的非常不错。值得一看，不过目前基本断货（这个就是最有利的说明）。

8《Junit Recipes中文版：程序员实用测试技巧》
  星级：
  适合对象：初级，中级，高级
  介绍：目前敏捷盛行，这个你是不管怎样也得看一看的。

第二部分：中级进阶篇
1《Spring in action》
  星级：
  适合对象：初级，中级，高级
  介绍：Spring框架，作为Java程序员是怎么都必须学习的。IOC、AOP是你以后见到的软件的基础。另外基本上很多东西都和Spring产生联系。

2《精通Spring 2.x:企业应用开发详解》
  星级：
  适合对象：初级，中级，高级
  介绍：书中提供了Spring中的目前最流行用法的实例和实用情况。

3《iBatis实践》
  星级：
  适合对象：初级，中级，高级
  介绍：iBatis必看参考书，in action从未让人失望过。

4 《精通Hibernate:Java对象持久化技术详解》
  星级：
  适合对象：初级，中级，高级
  介绍：Hibernate必备参考书，也是国人写的，难得的一本好书，而且作者是个MM。

5 《Struts 2.1权威指南》
  星级：
  适合对象：初级，中级
  介绍：学习Struts2的一本国人写的不错的书，不过名称显得大了点。权威指南应该只有作者才可以这么叫。

6 《Maven实践》
  星级：
  适合对象：初级，中级
  介绍：从Ant到Maven现在时大势所趋了，您怎么也得学习一下。

7《expert one-on-one J2EE Development without EJB中文版》
   星级：
  适合对象：初级，中级
  介绍：这个其实是Spring的基础，作者巨牛。强力推荐，可惜是基本买不到这本书了。

8 《Tomcat权威指南》
  星级：
  适合对象：初级，中级
  介绍：做Java Web的一般都必须学习这个，为Apache的开源项目。

9 《Head First Servlets & Jsp》
  星级：
  适合对象：初级，中级
  介绍：Servlet和Jsp作为JavaEE程序员是必须要掌握好的，而且Head First系列从未令人失望。

10 《Head First HTML与CSS.XHTML》
  星级：
  适合对象：初级
  介绍：介绍Web前端的不错的入门书。

11 《HTML+CSS网页设计与布局从入门到精通》
  星级：
  适合对象：初级
  介绍：这本书最大的特点是带光盘而且讲解的不错，应用实例也不错。

12 《JavaScript宝典》
 星级：
  适合对象：初级，中级，高级
  介绍：是学习js的必备参考工具书之一，我记得几年前国内都没有中文版，我都把整本书打印出来看了一下。

13 《JavaScript权威指南》
  星级：
  适合对象：初级，中级，高级
  介绍：是学习js的必备参考工具书之一。我看我同事购买了，看起来还不错。

14 《征服Ajax Web2.0开发技术详解》
  星级：
  适合对象：初级，中级
  介绍：这本书当年是CSDN送给我的，感觉还是不错的。对学习AJAX有帮助。

15 《jQuery基础教程》
 星级：
 适合对象：初级，中级，高级
 介绍：从这个开始学习jQuery才是根本。不然以后遇到的很多奇怪问题不知所以然。jQuery个人感觉已经成为目前的javascript标准库了，插件无数，大大简化了前端工作。

16 《XML入门经典》
 星级：
 适合对象：初级，中级，高级
 介绍：很多人觉得没必要买XML书籍，不过我还是觉得推荐一本给你作为工具书，而且看本书可以使得你对XML方方面面有个了解。里面不少东西还是用到的。

17 《敏捷软件开发(原则模式与实践)》
 星级：
 适合对象：中级，高级
 介绍：敏捷大师的著作，您怎么也得看看。这本书包含了UML的讲解，所以我就不推荐UML的书了。

18 《重构:改善既有代码的设计》
 星级：
 适合对象：中级，高级
 介绍：同样是大师的杰作，不可不看。最重要的是让你明白软件也是一步步改进的，不是一蹴而就的。

19 《代码整洁之道》
 星级：
 适合对象：中级，高级
 介绍：软件工程的理想编码是需要无数人编出来的代码像一个人写的。这本书当作规范就不错。

注意:WebService的图书我还真不知道给您推荐什么，都不怎么样。您做个实例就明白，不过怎么做接口才是核心。

第三部分：高级篇
1  《Java消息服务》
  星级：
  适合对象：初级，中级，高级
  介绍：消息机制是以前分布式经常实用到的，与此相关的有Apache Active MQ进行开发，而且这本书的实例也是用的AQ。

2 《Java并非实践》
  星级：
  适合对象：中级，高级
  介绍：这本书也是牛人们强力推荐的，学习并发必备。

3 《Enterprise JavaBeans 3.0中文版》
  星级：
  适合对象：中级，高级
  介绍：EJB技术在大型系统中使用，主要有银行等金融机构。是开发分布式程序的选项之一，不过我不喜欢，其实银行使用的也不怎么的。结合JavaEE容器使用，开源的有JBoss，商用的有IBM和Oracle支持。
注：该类型书也有Head First系列，也很不错。另外《J2EE应用与BEA WebLogic Server》书也很不错。

4 《Hadoop权威指南》
  星级：
  适合对象：中级，高级
  介绍：云计算必备图书。作为分布式计算的工具，Hadoop目前可以说是市场上唯一成熟的产品，而且大家也都向其看齐。而起云计算炙手可热，你搞明白这本书就大概明白了什么是云以及怎么做云。

附： 《Linux 鸟哥的私房菜》
  星级：
  适合对象：初级，中级，高级
  介绍：这本书对使用和学习Linux很有用，大而全，解释的也不错，常用的基本都有了，一本在手，绝无顾忧。
最后，推荐一本贯彻全部软件工程和全文的图书《代码大全》，只是一句话：两届Software Development Magzine Jolt Award震撼大奖得主。

1、针对Oracle数据库而言，Fetch Size 是设定JDBC的Statement读取数据的时候每次从数据库中取出的记录条数，一般设置为30、50、100。Oracle数据库的JDBC驱动默认的Fetch Size=15，设置Fetch Size设置为：30、50，性能会有明显提升，如果继续增大，超出100，性能提升不明显，反而会消耗内存。
即在Hibernate配制文件中进行配制：
< property name=”hibernateProperties”>
< props>
< prop key=”hibernate.dialect”>
org.hibernate.dialect.Oracle9Dialect
< /prop>
< prop key=”hibernate.show_sql”>false< /prop>
< !– Create/update the database tables automatically when the JVM starts up
< prop key=”hibernate.hbm2ddl.auto”>update< /prop> –>
< !– Turn batching off for better error messages under PostgreSQL
< prop key=”hibernate.jdbc.batch_size”>100< /prop> –>
< prop key=”hibernate.jdbc.batch_size”>50< /prop>
< /props>< /property>

     < property name=”hibernateProperties”>　　< props>

< prop key=”hibernate.dialect”>

org.hibernate.dialect.Oracle9Dialect

< /prop>

< prop key=”hibernate.show_sql”>false< /prop>

< !– Create/update the database tables automatically when the JVM starts up

< prop key=”hibernate.hbm2ddl.auto”>update< /prop> –>

< !– Turn batching off for better error messages under PostgreSQL

< prop key=”hibernate.jdbc.batch_size”>100< /prop> –>

< prop key=”hibernate.jdbc.batch_size”>50< /prop>

< /props>< /property>

3、不要把所有的责任推在hibernate上，对代码进行重构，减少对数据库的操作，尽量避免在数据库查询时使用in操作，以及避免递归查询操作，代码质量、系统设计的合理性决定系统性能的高低。
4、 对大数据量查询时，慎用list()或者iterator()返回查询结果， 　　(1). 使用List()返回结果时，Hibernate会所有查询结果初始化为持久化对象，结果集较大时，会占用很多的处理时间。 　　(2). 而使用iterator()返回结果时，在每次调用iterator.next()返回对象并使用对象时，Hibernate才调用查询将对应的对象初始化，对于大数据量时，每调用一次查询都会花费较多的时间。当结果集较大，但是含有较大量相同的数据，或者结果集不是全部都会使用时，使用iterator()才有优势。
5、在一对多、多对一的关系中，使用延迟加载机制，会使不少的对象在使用时方会初始化，这样可使得节省内存空间以及减少数据库的负荷，而且若PO中的集合没有被使用时，就可减少互数据库的交互从而减少处理时间。
6、对含有关联的PO(持久化对象)时，若default-cascade=”all”或者 “save-update”，新增PO时，请注意对PO中的集合的赋值操作，因为有可能使得多执行一次update操作。
7、 对于大数据量新增、修改、删除操作或者是对大数据量的查询，与数据库的交互次数是决定处理时间的最重要因素，减少交互的次数是提升效率的最好途径，所以在开发过程中，请将show_sql设置为true，深入了解Hibernate的处理过程，尝试不同的方式，可以使得效率提升。尽可能对每个页面的显示，对数据库的操作减少到100—-150条以内。越少越好。 　　以上是在进行Struts+hibernate+spring进行项目开发中，对hibernate性能优化的几点心得。

一 Java相关

1.Xmemcached，还算是比较多人使用的一个java memcached client，优点是效率和易用性，缺点是代码写的不怎么样，两年前发展到现在的东西，以后还会继续维护。

2.HS4J，看handlersocket的时候顺手写的客户端，我们公司内部某些项目在用，可能还有其他公司外的朋友在用，后来同事聚石贡献了一个扩展项目hs4j-kit，更易于使用，他写的代码很优雅漂亮，推荐一看。暂时没有精力维护。

3.Aviator，一个很初级的表达式执行引擎，行家看到肯定要笑话我。不过语法上很符合我自己的口味，我们自己的项目在用，也有几个朋友在用，会继续维护。

4.Jevent，一个玩具，其实是模仿libevent的一个java实现，对nio或者libevent的实现机制感兴趣的还可以看看。

5. Kilim，我fork的kilim实现，修改了nio调度器，使用多个reactor做调度效率更高，并添加了一个HttpClient的实现。

二 Android项目

学习android完全是玩票性质，有3个项目，对初学android开发的可能有点参考价值。

1.WhetherWeather，一个天气预报和告警的widget插件，UI太丑了。

2.UniqRecorder，写来记录儿子体重变化的小工具，可以自定义项目和生成曲线图，我自己还在用。

3.UniqTask，最近写的杀进程工具，绝对轻量级，没广告，也是我自己在用。

三 Clojure项目

1.cscheme，一个用clojure实现的scheme解释器，基于sicp这本书的解释器实现。

2.clojure-control，类似node-control的分布式部署和管理的DSL实现，挺好玩的，也有朋友在用，我自己还用不上,sunny有写了个很方便的lein插件node-control。

clojure还写了一堆烂尾项目，就不拿出来恶心人了。

四 其他

1.node-zk-browser，一个展现和管理zookeeper的web应用，我们自己在用，基于node.js实现。

2.erlwsh，一个erlang的web shell实现，可以在浏览器里做erlang编程，被一些开源项目比如membase用到了。

一、内存溢出类型

1、java.lang.OutOfMemoryError: PermGen space
JVM管理两种类型的内存，堆和非堆。堆是给开发人员用的上面说的就是，是在JVM启动时创建；非堆是留给JVM自己用的，用来存放类的信息的。它和堆不同，运行期内GC不会释放空间。如果web app用了大量的第三方jar或者应用有太多的class文件而恰好MaxPermSize设置较小，超出了也会导致这块内存的占用过多造成溢出，或者tomcat热部署时侯不会清理前面加载的环境，只会将context更改为新部署的，非堆存的内容就会越来越多。
PermGen space的全称是Permanent Generation space,是指内存的永久保存区域，这块内存主要是被JVM存放Class和Meta信息的,Class在被Loader时就会被放到PermGen space中，它和存放类实例(Instance)的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理，所以如果你的应用中有很CLASS的话,就很可能出现PermGen space错误，这种错误常见在web服务器对JSP进行pre compile的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。
一个最佳的配置例子：(经过本人验证，自从用此配置之后，再未出现过tomcat死掉的情况)
set JAVA_OPTS=-Xms800m -Xmx800m -XX:PermSize=128M -XX:MaxNewSize=256m -XX:MaxPermSize=256m
2、java.lang.OutOfMemoryError: Java heap space
第一种情况是个补充，主要存在问题就是出现在这个情况中。其默认空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。如果内存剩余不到40％，JVM就会增大堆到Xmx设置的值，内存剩余超过70％，JVM就会减小堆到Xms设置的值。所以服务器的Xmx和Xms设置一般应该设置相同避免每次GC后都要调整虚拟机堆的大小。假设物理内存无限大，那么JVM内存的最大值跟操作系统有关，一般32位机是1.5g到3g之间，而64位的就不会有限制了。
注意：如果Xms超过了Xmx值，或者堆最大值和非堆最大值的总和超过了物理内存或者操作系统的最大限制都会引起服务器启动不起来。
垃圾回收GC的角色
JVM调用GC的频度还是很高的，主要两种情况下进行垃圾回收：
当应用程序线程空闲；另一个是java内存堆不足时，会不断调用GC，若连续回收都解决不了内存堆不足的问题时，就会报out of memory错误。因为这个异常根据系统运行环境决定，所以无法预期它何时出现。
根据GC的机制，程序的运行会引起系统运行环境的变化，增加GC的触发机会。
为了避免这些问题，程序的设计和编写就应避免垃圾对象的内存占用和GC的开销。显示调用System.GC()只能建议JVM需要在内存中对垃圾对象进行回收，但不是必须马上回收，
一个是并不能解决内存资源耗空的局面，另外也会增加GC的消耗。

二、JVM内存区域组成

简单的说java中的堆和栈
java把内存分两种：一种是栈内存，另一种是堆内存
1。在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；
2。堆内存用来存放由new创建的对象和数组
在函数（代码块）中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量所分配的内存空间；在堆中分配的内存由java虚拟机的自动垃圾回收器来管理
堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。缺点就是要在运行时动态分配内存，存取速度较慢；
栈的优势是存取速度比堆要快，缺点是存在栈中的数据大小与生存期必须是确定的无灵活性。
java堆分为三个区：New、Old和Permanent
GC有两个线程：
新创建的对象被分配到New区，当该区被填满时会被GC辅助线程移到Old区，当Old区也填满了会触发GC主线程遍历堆内存里的所有对象。Old区的大小等于Xmx减去-Xmn
java栈存放
栈调整：参数有+UseDefaultStackSize -Xss256K，表示每个线程可申请256k的栈空间
每个线程都有他自己的Stack

三、JVM如何设置虚拟内存

提示：在JVM中如果98％的时间是用于GC且可用的Heap size 不足2％的时候将抛出此异常信息。
提示：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。
提示：JVM初始分配的内存由-Xms指定，默认是物理内存的1/64；JVM最大分配的内存由-Xmx指定，默认是物理内存的1/4。
默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。因此服务器一般设置-Xms、-Xmx相等以避免在每次GC 后调整堆的大小。
提示：假设物理内存无限大的话，JVM内存的最大值跟操作系统有很大的关系。
简单的说就32位处理器虽然可控内存空间有4GB,但是具体的操作系统会给一个限制，
这个限制一般是2GB-3GB（一般来说Windows系统下为1.5G-2G，Linux系统下为2G-3G），而64bit以上的处理器就不会有限制了
提示：注意：如果Xms超过了Xmx值，或者堆最大值和非堆最大值的总和超过了物理内存或者操作系统的最大限制都会引起服务器启动不起来。
提示：设置NewSize、MaxNewSize相等，&quot;new&quot;的大小最好不要大于&quot;old&quot;的一半，原因是old区如果不够大会频繁的触发&quot;主&quot; GC ，大大降低了性能
JVM使用-XX:PermSize设置非堆内存初始值，默认是物理内存的1/64；
由XX:MaxPermSize设置最大非堆内存的大小，默认是物理内存的1/4。
解决方法：手动设置Heap size
修改TOMCAT_HOME/bin/catalina.bat
在“echo &quot;Using CATALINA_BASE: $CATALINA_BASE&quot;”上面加入以下行：
JAVA_OPTS=&quot;-server -Xms800m -Xmx800m -XX:MaxNewSize=256m&quot;

四、性能检查工具使用

定位内存泄漏：
JProfiler工具主要用于检查和跟踪系统（限于Java开发的）的性能。JProfiler可以通过时时的监控系统的内存使用情况，随时监视垃圾回收，线程运行状况等手段，从而很好的监视JVM运行情况及其性能。
1. 应用服务器内存长期不合理占用，内存经常处于高位占用，很难回收到低位；
2. 应用服务器极为不稳定，几乎每两天重新启动一次，有时甚至每天重新启动一次；
3. 应用服务器经常做Full GC(Garbage Collection)，而且时间很长，大约需要30-40秒，应用服务器在做Full GC的时候是不响应客户的交易请求的，非常影响系统性能。
因为开发环境和产品环境会有不同，导致该问题发生有时会在产品环境中发生，通常可以使用工具跟踪系统的内存使用情况，在有些个别情况下或许某个时刻确实是使用了大量内存导致out of memory，这时应继续跟踪看接下来是否会有下降，
如果一直居高不下这肯定就因为程序的原因导致内存泄漏。

五、不健壮代码的特征及解决办法

1、尽早释放无用对象的引用。好的办法是使用临时变量的时候，让引用变量在退出活动域后，自动设置为null，暗示垃圾收集器来收集该对象，防止发生内存泄露。
对于仍然有指针指向的实例，jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾，提高GC回收机制效率；
2、我们的程序里不可避免大量使用字符串处理，避免使用String，应大量使用StringBuffer，每一个String对象都得独立占用内存一块区域；
String str = &quot;aaa&quot;;
String str2 = &quot;bbb&quot;;
String str3 = str + str2;//假如执行此次之后str ,str2以后再不被调用,那它就会被放在内存中等待Java的gc去回收,程序内过多的出现这样的情况就会报上面的那个错误,建议在使用字符串时能使用StringBuffer就不要用String,这样可以省不少开销；
3、尽量少用静态变量，因为静态变量是全局的，GC不会回收的；
4、避免集中创建对象尤其是大对象，JVM会突然需要大量内存，这时必然会触发GC优化系统内存环境；显示的声明数组空间，而且申请数量还极大。
这是一个案例想定供大家警戒
使用jspsmartUpload作文件上传,运行过程中经常出现java.outofMemoryError的错误，
检查之后发现问题：组件里的代码
m_totalBytes = m_request.getContentLength();
m_binArray = new byte[m_totalBytes];
问题原因是totalBytes这个变量得到的数极大，导致该数组分配了很多内存空间，而且该数组不能及时释放。解决办法只能换一种更合适的办法，至少是不会引发outofMemoryError的方式解决。参考：http://bbs.xml.org.cn/blog/more.asp?name=hongrui&amp;id=3747
5、尽量运用对象池技术以提高系统性能；生命周期长的对象拥有生命周期短的对象时容易引发内存泄漏，例如大集合对象拥有大数据量的业务对象的时候，可以考虑分块进行处理，然后解决一块释放一块的策略。
6、不要在经常调用的方法中创建对象，尤其是忌讳在循环中创建对象。可以适当的使用hashtable，vector 创建一组对象容器，然后从容器中去取那些对象，而不用每次new之后又丢弃
7、一般都是发生在开启大型文件或跟数据库一次拿了太多的数据，造成 Out Of Memory Error 的状况，这时就大概要计算一下数据量的最大值是多少，并且设定所需最小及最大的内存空间值。

Web开发方面没有王者,PHP市场很大,但RoR,Python,Java,及至Asp.net都占据着一方市场.那么作为Java程序员,当你不想使用SSH做网站的时候,尝试一下Grails吧,这里是Java程序员使用Grails的十大优势

1.易于学习
这里并不是说Grails不易于PHP或者Python程序员学习,Grails和Groovy都很容易学习,也容易使用,但对于Java程序员来说则有很大不同,因为它更易于学习与使用.你可以同时使用Java语法和Groovy语法,并且Groovy语法也更易于Java程序员学习.同时你不需要放弃你对于Spring/Hibernate的积累,要知道,放弃积累推倒重来是不对的.

2.IDE支持
无论是Netbeans, IDEA还是Eclipse都对Grails有非常不错的支持,无论是语法高亮,自动部署还是重构.IDE支持对于java程序员来说应该是非常重要的,试试Netbeans的Grails插件吧,相当不错.

3.领域驱动开发
如果你不了解领域驱动开发(Domain Driven Design),可以搜索一下Evans DDD或者类似的关键字,使用Grails,拿到你的需求,设计你的领域类,然后下面的工作就只是设置你的页面,通过领域类你可以清楚地看到模型层次关系与业务层次关系.这样会让生活更清晰一点.

4.性能
你关心性能吗?当然在Web开发中语言的性能并不是最重要的方面,但你依然需要关心你的程序的性能.比如你的业务量扩大了或者你的站点变成了高流量网站, 你都需要面临性能的问题.而使用Grails你不需要担心这一点,只需要关注你的程序就好了,因为Java平台是足够快的:)

5.稳定的JavaEE平台
当你需要Web Service,或者需要分布式环境,或者需要处理异步消息,设计邮件系统,Grails可以让你轻松与JavaEE平台整合,因为Grails本身就是基于Java的框架,你知道JavaEE是稳定的,你可以将Grails部署到Glassfish,Tomcat, Jetty,JBoss或者Weblogic.

6.社区
Grails有一个稳定活跃的社区,当你碰上任何问题的时候,加入Grails的邮件列表吧,先读一读提问的智慧,你会在邮件列表中得到你想要的；当你没碰上任何问题的时候,也请加入Grails的邮件列表吧,你可以学到更多不仅是Grails的知识.

7.插件系统
Grails的核心很小,大部分的功能都是基于插件系统的,Grails有很多非常优秀的插件,当然你也可以用自己的插件.我利用rateable插件,只用了十分钟就做出来了类似于douban.com中给书和电影打分的star rate功能,这绝对Cool.

8.约定大于配置
Java程序员肯定需要知道什么是CoC.当我们使用Struts2的时候,我们未必需要告诉action如何去找到要渲染的jsp,这就是CoC,但我们不可能在整个JavaEE体系中使用CoC,比如你没办法从Struts中以CoC的方式获取EJB,但Grails却是完全基于CoC的,无论是 Controller到页面,还是领域类(Domain Class)到数据库的映射,都是以CoC的形式做的,这样可以节省你大量的时间,同时Grails也提供了可选的配置文件以提高灵活性.

9.不重复工作
作为程序员,要学会的不仅是各种技能,更多的是要学会重用.因此Java程序员没必要不断学习太多很新的东西,反而应该在积累的基础上去改进,当你是优秀的Java程序员的时候,我相信你可以在半天的时间内学会Django,但何必为此抛弃JavaEE?用Grails吧,少花点时间去研究,多用自己成熟的东西去创造.

10.Wicket集成
可能你不太乎这一点,但这一点对我来说很重要,毕竟我们在Wicket上有很多积累.那么,既然Grails可以轻松与Wicket集成,这就说明 Grails也可以轻松复用你的其他Web框架,这样就达到了更好的利用效果,而你可以继续复用你的积累.最重要的不是学习多少东西,而是节省时间,创造生产力.

这里通过节点流和处理流总结一下流的具体用法。
节点流的分类：

节点流分别对File（文件），Array（内存中的一个数组），String（字符串），Pipe（管道）进行处理。

处理流的分类：

常用的处理流有：缓冲流，转换流，数据流，对象流，打印流。
缓冲流：要套接在相应的字节流之上，对读写的数据提供了缓冲功能，提高了读写的效率，同时也增加了一些更方便方法。
缓冲流的作用就像一个桶，原本的字节流是个水管，水管直接连到目的地，加了缓冲流之后，就是在水管下接了一个桶，等桶接满水后再倒入目的地。起到了缓冲的作用。这样就可以一次读到更多的数据，避免了频繁的读写硬盘。由于带了缓冲功能，所以就写数据的时候需要使用flush方法。

1. import java.io.*;
2. public class TestBufferStream{
3.    public static void main(String[] args){
4.         try{
5.              BufferedWriter bw=new BufferedWriter(new FileWriter(“F:\\Java\\IO\\dat.txt”));//在对写文件的字节流上套接上缓冲流
6.              BufferedReader br=new BufferedReader(new FileReader(“F:\\Java\\IO\\dat.txt”));//在对读文件的字节流上套接上缓冲流
7.              String s=null;
8.              for(int i=1;i<=100;i++){
9.                 s=String.valueOf(Math.random());//通过随机函数给s赋值
10.                 bw.write(s);                    //将s写入到dat.txt文件中
11.                 bw.newLine();                   //写入一个分行符。缓冲流比较好用的方法就是可以写入或读取一行的数据。
12.              }
13.              bw.flush();                        //使内存中的所有数据立刻写出，不再缓冲。
14.              while((s=br.readLine())!=null){    //按行读取文件内容
15.                 System.out.println(s);
16.              }
17.              bw.close();                        //关闭处理流同时关闭里面的节点流。
18.              br.close();
19.
20.         }
21.         catch(IOException e){
22.              e.printStackTrace();
23.         }
24.    }
25. }
转换流：用与字节数据到字符数据之间的转化。InputStreamReader需要和InputStream套接，OutputStreamWriter需要和outputStream套接。
数据流：DataInputStream 和DataOutputStream  提供将基础数据类型写入到文件中，或者读取出来，这个流的用处还是很大的，如果没有这种流的话，有一个long，本身只占8个字节，如果我要写入到文件，需要转成字符串，然后在转成字符数组，那空间会占用很多，但是有了这种流之后就很方便了，直接将这8个字节写到文件就可以了，既节约了内存空间也使程序写起来更加方便简单。但是读取的时候需要注意了，根据读取的数据类型，指针会往下移，所以你读的顺序必须要和写的顺序一致才能完成你正确的需求。否则就相当与把数据拆分了。

1. import java.io.*;
2. public class TestDataStream{
3.       public static void main(String[] args){
4.           ByteArrayOutputStream baos=new ByteArrayOutputStream();   //建一个节点流。
5.           DataOutputStream dos=new DataOutputStream(baos);          //在节点流上接一根数据流“管道”                                   try{
6.               dos.writeDouble(Math.random());                       //double型 ，占8个字节
7.               dos.writeBoolean(true);                               //boolean型，占一个字节
8.               ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
9.               System.out.println(bais.available());                 //输出流中总的可用字节数–9
10.               DataInputStream dis=new DataInputStream(bais);        //同样在输出流的外面接上数据流“管道”
11.               System.out.println(dis.readDouble());                 //直接读出double型的数
12.               System.out.println(dis.readBoolean());                //直接读出boolean型
13.               dos.close();
14.               dis.close();
15.           }catch(IOException e){
16.               e.printStackTrace();
17.           }
18.
19.       }
20. }

打印流：java.io中专门提供用于打印的流，这类流在写入的时候有自动flush的功能，所以不需要每打印一个东西都flush一次。
1. import java.io.*;
2. public class TestPrintStream1{
3.        public static void main(String[] args){
4.            PrintStream ps=null;
5.            try{
6.               FileOutputStream fos=new FileOutputStream(“F:\\Java\\IO\\log.dat”);//创建输出流，指定输出地点
7.               ps=new PrintStream(fos);                                           //在流外面包装打印流
8.            }catch(IOException e){
9.               e.printStackTrace();
10.            }
11.            if(ps!=null){
12.               System.setOut(ps);                                                 //将系统的打印设置成打印流ps
13.            }
14.            int ln=0;
15.            for(char c=0;c<=60000;c++){
16.                System.out.print(c+”  “);                                         //不在打印到dos窗口，输出流直接打印到指定文件中
17.                if(ln++>=100){
18.                      System.out.println();ln=0;
19.                }
20.            }
21.         }
22. }