java编码规范及优化总结

一、 java概述

1991 年Sun公司的James Gosling（詹姆斯·高斯林）等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器。1994年将Oak语言更名为Java。 

二、 Java的三种技术架构

J2EE：Java PlatformEnterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；

J2SE：Java PlatformStandard Edition，完成桌面应用程序的开发，是其它两者的基础；

J2ME：Java PlatformMicro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；  

三、 Java环境变量

1，JDK：JavaDevelopment Kit，java的开发和运行环境，java的开发工具和jre。

2，JRE：Java RuntimeEnvironment，java程序的运行环境，java运行的所需的类库+JVM。

3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

4，javac命令和java命令做什么事情呢？

  要知道java是分两部分的：一个是编译，一个是运行。

   javac ：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java文件进行编译。 生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。

   java ：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行.

 

Java为什么能跨平台: 

因为Java程序编译之后的代码不是能被硬件系统直接运行的代码，而是一种“中间码”，二进制字节码的class文件，jvm就解释执行class文件。不同的硬件平台上安装有不同的Java虚拟机(JVM)，由JVM来把字节码再“翻译”成所对应的硬件平台能够执行的代码。所以它的代码就能不经修改，就能在不同平台的jvm上运行(在UNIX用UNIX的jvm,在linux上用linux的jvm，在windows上用windows的jvm）。假如用windows移植到UNIX，只需把java文件是UNIX的jvm上编译成class文件，然后用jvm运行就可以了.因此对于Java编程者来说，不需要考虑硬件平台是什么。所以Java可以跨平台。

四、 Java编码规范及优化

1.  &和&&，|和||的区别

&：位运算符，不管怎样，都会执行"&"符号左右两边的程序。

&&：逻辑运算符，只有当符号"&&"左边程序为真(true)后，才会执行符号"&&"右边的程序。

例子: if(str != null & !"".equals(str))，if(str != null && !"".equals(str))

使用场景：条件判断下使用&&比使用&效率更高，&一般用于位运算。

|和||同理可证。

2.  关键字final

1：这个关键字是一个修饰符，可以修饰类，方法，变量。

2：被final修饰的类是一个最终类，不可以被继承。

3：被final修饰的方法是一个最终方法，不可以被覆盖。

4：被final修饰的变量是一个常量，只能赋值一次。

 

常量名称定义时，有规范，所有字母都大写，如果由多个单词组成，中间用 _ 连接。

例子：private staticfiinal String OS_TYPE = “windows”;

3.  ==与equals

值类型是存储在内存中的堆栈（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。

==操作：比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。

  equals操作：表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。

==比较的是2个对象的地址，而equals比较的是2个对象的内容。

显然，当equals为true时，==不一定为true；

例子：

    一、String中的equals和==

    1、

    public class TestString{

    public static voidmain(String[] args) {

    String s1 ="Monday";

    String s2 ="Monday";

    }

    }

    上面这段程序中，到底有几个对象呢？

    来检测一下吧，稍微改动一下程序

    public class TestString{

    public static voidmain(String[] args) {

    String s1 ="Monday";

    String s2 ="Monday";

    if (s1 == s2)

   System.out.println("s1 == s2");

    else

    System.out.println("s1!= s2");

    }

    }

    编译并运行程序，输出：s1== s2说明：s1 与 s2 引用同一个 String 对象 -- "Monday"!

    2.再稍微改动一下程序，会有更奇怪的发现：

    public class TestString{

    public static voidmain(String[] args) {

    String s1 ="Monday";

    String s2 = new String("Monday");

    if (s1 == s2)

   System.out.println("s1 == s2");

    else

   System.out.println("s1 != s2");

    if (s1.equals(s2))System.out.println("s1 equals s2");

    else

   System.out.println("s1 not equals s2");

    }

    }

我们将s2用new操作符创建

    程序输出：

    s1 != s2

    s1 equals s2

    说明：s1 s2分别引用了两个"Monday"String对象

    3. 字符串缓冲池

    原来，程序在运行的时候会创建一个字符串缓冲池当使用 s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1

    将s2引用s1所引用的对象"Monday"

    第二段程序中，使用了 new操作符，他明白的告诉程序："我要一个新的！不要旧的！"于是一个新的"Monday"Sting对象被创建在内存中。他们的值相同，但是位置不同，一个在池中游泳一个在岸边休息。哎呀，真是资源浪费，明明是一样的非要分开做什么呢？

    4.

    再次更改程序：

    public class TestString{

    public static voidmain(String[] args) {

    String s1 ="Monday";

    String s2 = new String("Monday");

    s2 = s2.intern();

    if (s1 == s2)

   System.out.println("s1 == s2");

    else

   System.out.println("s1 != s2");

    if (s1.equals(s2))System.out.println("s1 equals s2");

    else

   System.out.println("s1 not equals s2");

    }

    }

    这次加入：s2 =s2.intern();

    程序输出：

    s1 == s2

    s1 equals s2

    原来，（java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方法没什么用处。但实际上，它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把"abc"添加到字符串池中，然后再返回它的引用。

    ）

    更好的办法：

    把所有的String都intern()到缓冲池去吧

    最好在用到new的时候就进行这个操作

    String s2 = newString("Monday").intern();

    然后就可以用==比较两个字符串的值了

 

二、简单数据类型和封装类中的equals和==

    Java为每一个简单数据类型提供了一个封装类，每个基本数据类型可以封装成对象类型。

    除int（Integer）和char（Character），其余类型首字母大写即成封装类类型名。double (Double), float(Float),long(Long),short(Short),byte(Byte),boolean(Boolean).

    以int和Integer为例说明

    Java中int和Integer区别如下：

    1.int是基本的数据类型,默认值可以为0；2.Integer是int的封装类,默认值为null；3.int和Integer都可以表示某一个数值；4.int和Integer不能够互用，因为他们两种不同的数据类型；

    int a1=1;

    int a2=1;

    Integer b1 =new Integer(1);

    Integer b2 =new Integer(1);

  ------------------------------

    a1==a2 这个是成立的,很简单,都知道a1==b1 这个是不成立的.表达式的值为 false,它们是不同的数据类型b1==b2 这个也是不成立的.表达式的值为 false,虽然是相同的数据类型,但是它们是两个对象,==比较的是2个对象的地址,它们的地址是不相等的,内容相等都是1;

    b1.equals(b2)==true 这个是成立的,表达式的值为 true. 相同数据类型,两个对象,地址不同,内容相同, quals比较的是2个对象的内容,所以成立。

    (a.equals(b),因为equals比较的是两个对象，所以a,b都不能为基本数据类型，否则会出编译错误。)同理,其它的封装类和基本类型也是这样的.

    java中equals和==的区别

    ==比较的是2个对象的地址，而equals比较的是2个对象的内容。

    三、其他类怎么使用equals和==

    API里的类大部分都重写了equals方法，没有重写的一般是自己写的类，如果是你自己定义的一个类，比较自定义类用equals和==是一样的，都是比较句柄地址，因为自定义的类是继承于object，而object中的equals就是用==来实现的，你可以看源码。

    四、java里equals和hashCode之间什么关系

    只是为了维护hashCode 方法的常规协定,才要求用equals比较的两个对象的hashCode相同. equals()和hashCode()都来自java.lang.Object.你当然可以重写.

    比如a.equals(b).仅当a的内存地址相等时,才返回true.当然如String等类已经对这个方法进行了重写,比较的就不再是内存地址了. hashCode()的值也是与内存地址相关的.所以仅当内存地址相等时,hashCode才相等.

    同样很多类也重写了这个方法,还是以String为例:

    public int hashCode() {

    int h = hash;

    if (h == 0) {

    int off = offset;

    char val[] = value;

    int len = count;

    for (int i = 0; i <len; i++) {

    h = 31*h + val[off++];

    }

    hash = h;

    }

    return h;

    }

    就不在与内存地址相关了.这样做是为了保证用equals比较返回为true的两个对象,他们的hashCode是相同的.

    所以一般重写equals的时候都会重写hashCode().当然,这个相当于一个约定,一个协议.你不这么做并不会错.

    五、hashCode

    在一般的应用中你不需要了解hashcode的用法，但当你用到hashmap，hashset等集合类时要注意下hashcode。

    你想通过一个object的key来拿hashmap的value，hashmap的工作方法是，通过你传入的object的hashcode在内存中找地址，当找到这个地址后再通过equals方法来比较这个地址中的内容是否和你原来放进去的一样，一样就取出value。

    所以这里要匹配2部分，hashcode和equals但假如说你new一个object作为key去拿value是永远得不到结果的，因为每次new一个object，这个object的hashcode是永远不同的，所以我们要重写hashcode，你可以令你的hashcode是object中的一个恒量，这样永远可以通过你的object的hashcode来找到key的地址，然后你要重写你的equals方法，使内存中的内容也相等。

 

 

4.  if和switch的优劣性

if 语句适用范围比较广，只要是 boolean表达式都可以用 if 判断；而 switch 只能对基本类型进行数值比较。两者的可比性就仅限在两个基本类型比较的范围内。
说到基本类型的数值比较，那当然要有两个数。然后重点来了——
if 语句每一句都是独立的，看下面的语句：
if (a == 1) ...
else if (a == 2) ...
这样 a 要被读入寄存器两次，1 和 2 分别被读入寄存器一次。于是你是否发现其实 a 读两次是有点多余的，在你全部比较完之前只需要一次读入寄存器就行了，其余都是额外开销。但是 if 语句必须每次都把里面的两个数从内存拿出来读到寄存器，它不知道你其实比较的是同一个 a。
于是 switch case 就出来了，把上面的改成 switch case 版本：
switch (a) {
        case 0:
                break;
        case 1:
}
因为特定的规则，他一开始就知道你要比 a，于是 a 一次性读取，相比 if 节约了很多开销。

5.  String, StringBuffer,StringBuilder 的使用场景

1.三者在执行速度方面的比较：StringBuilder > StringBuffer  >  String

2.String <（StringBuffer，StringBuilder）的原因

　　　　String：字符串常量

　　　　StringBuffer：字符串变量

　　　　StringBuilder：字符串变量

从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问  ，比如这段代码：

 String s = "abcd";
 s = s+1;
 System.out.print(s);// result : abcd1

 我们明明就是改变了String型的变量s的，为什么说是没有改变呢?其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多低。而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

3.一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

 

你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：

　　　　String str = “This is only a” + “ simple” + “test”;

　　　　其实就是：

　　　　String str = “This is only a simple test”;

　　　　所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：

　　　　String str2 = “This is only a”;

　　　　String str3 = “ simple”;

　　　　String str4 = “ test”;

　　　　String str1 = str2 +str3 + str4;

　　　　这时候JVM会规规矩矩的按照原来的方式去做。

　　4.StringBuilder与 StringBuffer

　　　　StringBuilder：线程非安全的

　　　　StringBuffer：线程安全的

　　　　当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。

 

对于三者使用的总结： 1.如果要操作少量的数据用 = String

　　　　　　　　　　   2.单线程操作字符串缓冲区下操作大量数据 = StringBuilder

　　　　　　　　　　   3.多线程操作字符串缓冲区下操作大量数据 = StringBuffer

 

6.  避免在循环条件中使用复杂表达式

在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 

 

例子： 

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

           ; // ...

    }

}

 

7.  array(数组)和ArrayList的使用

array 数组效率最高，但容量固定，无法动态改变，ArrayList容量可以动态增长，但牺牲了效率。 

8.  单线程应尽量使用HashMap, ArrayList

单线程应尽量使用 HashMap, ArrayList,除非必要，否则不推荐使用HashTable,Vector，她们使用了同步机制，而降低了性能。 

 

9.  采用在需要的时候才开始创建的策略

例如：

String str="abc";  

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

 

应修改为：

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

10.  在java+Oracle的应用系统开发中，java中内嵌的SQL语言应尽量使用大写形式，以减少Oracle解析器的解析负担。

11.  尽量使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量，实例变量等，都在堆（Heap）中创建，速度较慢。

12.  不要总是使用取反操作符(!)

取反操作符(!)降低程序的可读性，所以不要总是使用。

 

例子：

public class dun {

   boolean method (boolean a, boolean b) {

       if (!a)

           return !a;

       else

           return !b;

    }

}

 

 

更正：

如果可能不要使用取反操作符(!)

13.  确定stringbuffer的容量

stringbuffer的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建stringbuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。

 

例子：        

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;

}

14.  不要在循环体中实例化变量

 

在循环体中实例化临时变量将会增加内存消耗

 

例子：        

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

       }

    }

}

15.  使用条件操作符代替"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;

}

16.  用'stringtokenizer'代替 'indexof()' 和'substring()'

字符串的分析在很多应用中都是常见的。使用indexof()和substring()来分析字符串容易导致 stringindexoutofboundsexception。而使用stringtokenizer类来分析字符串则会容易一些，效率也会高一些。

 

StringTokenizer token=new StringTokenizer(orginStr,".");    

17.  将try/catch块移出循环

把try/catch块放入循环体内，会极大的影响性能，如果编译jit被关闭或者你所使用的是一个不带jit的jvm，性能会将下降21%之多!

        

例子：        

import java.io.fileinputstream;

public class try {

   void method (fileinputstream fis) {

       for (int i = 0; i < size; i++) {

           try {                      

                _sum += fis.read();

           } catch (exception e) {}

       }

    }

   private int _sum;

}

 

        

更正：        

将try/catch块移出循环      

 voidmethod (fileinputstream fis) {

       try {

           for (int i = 0; i < size; i++) {

                _sum += fis.read();

           }

       } catch (exception e) {}

18.  不要在循环中调用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);

19.  避免在循环条件中使用复杂表达式

在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。

 

例子：

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

           ; // ...

    }

}

20.  不要创建一些不使用的对象，不要导入一些不使用的类

这毫无意义，如果代码中出现”The value of the local variable i is not used”、”The importjava.util is never used”，那么请删除这些无用的内容

21.  程序运行过程中避免使用反射

反射是Java提供给用户一个很强大的功能，功能强大往往意味着效率不高。不建议在程序运行过程中使用尤其是频繁使用反射机制，特别是Method的invoke方法，如果确实有必要，一种建议性的做法是将那些需要通过反射加载的类在项目启动的时候通过反射实例化出一个对象并放入内存—-用户只关心和对端交互的时候获取最快的响应速度，并不关心对端的项目启动花多久时间。

22.  字符串变量和字符串常量equals的时候将字符串常量写在前面

这是一个比较常见的小技巧了，如果有以下代码：

 

String str = "123";

if (str.equals("123")) {

 

}

建议修改为：

String str = "123";

if ("123".equals(str)) {

...

}

这么做主要是可以避免空指针异常

23.  避免对超出范围的基本数据类型做向下强制转型

这绝不会得到想要的结果：

public static void main(String[] args){

long l = 12345678901234L;

int i = (int)l;

System.out.println(i);

}

我们可能期望得到其中的某几位，但是结果却是：

1942892530

解释一下。Java中long是8个字节64位的，所以12345678901234在计算机中的表示应该是：

0000 0000 0000 0000 0000 1011 0011 10100111 0011 1100 1110 0010 1111 1111 0010

 

一个int型数据是4个字节32位的，从低位取出上面这串二进制数据的前32位是：

0111 0011 1100 1110 0010 1111 1111 0010

 

这串二进制表示为十进制1942892530，所以就是我们上面的控制台上输出的内容。从这个例子上还能顺便得到两个结论：

 

1、整型默认的数据类型是int，long l =12345678901234L，这个数字已经超出了int的范围了，所以最后有一个L，表示这是一个long型数。顺便，浮点型的默认类型是double，所以定义float的时候要写成”"float f = 3.5f”

 

2、接下来再写一句”int ii = l +i;”会报错，因为long + int是一个long，不能赋值给int

24.  把一个基本数据类型转为字符串

遇到把一个基本数据类型转为String的时候，优先考虑使用toString()方法。至于为什么，很简单：

1、String.valueOf()方法底层调用了Integer.toString()方法，但是会在调用前做空判断

2、Integer.toString()方法就不说了，直接调用了

3、i + “”底层使用了StringBuilder实现，先用append方法拼接，再用toString()方法获取字符串

 

三者对比下来，明显是2最快、1次之、3最慢

25.  对资源的close()建议分开操作

意思是，比如我有这么一段代码：

try{

XXX.close();

YYY.close();

}catch (Exception e){

 

}

建议修改为：

 

try{

 XXX.close();

 }catch (Exception e) {

 ...

}try{

YYY.close();

 }catch (Exception e) {

 

 ...}

虽然有些麻烦，却能避免资源泄露。我们想，如果没有修改过的代码，万一XXX.close()抛异常了，那么就进入了cath块中了，YYY.close()不会执行，YYY这块资源就不会回收了，一直占用着，这样的代码一多，是可能引起资源句柄泄露的。而改为下面的写法之后，就保证了无论如何XXX和YYY都会被close掉。

26.  使用数据库连接池和线程池

线程池的原理：

 

其实线程池的原理很简单，类似于操作系统中的缓冲区的概念，它的流程如下：先启动若干数量的线程，并让这些线程都处于睡眠状态，当客户端有一个新请求时，就会唤醒线程池中的某一个睡眠线程，让它来处理客户端的这个请求，当处理完这个请求后，线程又处于睡眠状态。可能你也许会问：为什么要搞得这么麻烦，如果每当客户端有新的请求时，我就创建一个新的线程不就完了？这也许是个不错的方法，因为它能使得你编写代码相对容易一些，但你却忽略了一个重要的问题?那就是性能！就拿我所在的单位来说，我的单位是一个省级数据大集中的银行网络中心，高峰期每秒的客户端请求并发数超过100，如果为每个客户端请求创建一个新线程的话，那耗费的CPU时间和内存将是惊人的，如果采用一个拥有200个线程的线程池，那将会节约大量的系统资源，使得更多的CPU时间和内存用来处理实际的商业应用，而不是频繁的线程创建与销毁。

 

数据库连接池的原理：

 

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。

 

一个数据库连接对象均对应一个物理数据库连接，每次操作都打开一个物理连接，使用完都关闭连接，这样造成系统的性能低下。数据库连接池的解决方案是在应用程序启动时建立足够的数据库连接，并讲这些连接组成一个连接池(简单说：在一个“池”里放了好多半成品的数据库联接对象)，由应用程序动态地对池中的连接进行申请、使用和释放。对于多于连接池中连接数的并发请求，应该在请求队列中排队等待。并且应用程序可以根据池中连接的使用率，动态增加或减少池中的连接数。

 

连接池技术尽可能多地重用了消耗内存地资源，大大节省了内存，提高了服务器地服务效率，能够支持更多的客户服务。通过使用连接池，将大大提高程序运行效率，同时，我们可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。

 

1)最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；

 

2)最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。

27.  使用带缓冲的输入输出流进行IO操作

带缓冲的输入输出流，即BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream，这可以极大地提升IO效率

28.  尽量避免随意使用静态变量

要知道，当某个对象被定义为static的变量所引用，那么gc通常是不会回收这个对象所占有的堆内存的，如：

public class A{

private static B b = new B();

}

此时静态变量b的生命周期与A类相同，如果A类不被卸载，那么引用B指向的B对象会常驻内存，直到程序终止

 

总之：无生命周期的用static，有生命周期的不用static。