转载自：www.blogjava.net/zhaobin
来自BlueDavy的博客：

1. 为什么学习OSGi
2. OSGi成为JSR291以及OSGi对Spring产生的影响
3. OSGi应用于企业应用Step by step之持久篇
4. SCA:企业应用开发的利器
5. OSGi和SCA
6. 基于OSGi实现可扩展的模块的设计
7. OSGi in action online演讲的资料【推荐】
8. 基于OSGi搭建动态化的系统
9. OSGi Extender Model启示录
10. Play OSGi
11. Bnd - Bundle Tool中文使用手册
12. 基于Eclipse Equinox的插件框架：TPF
13. TPF插件管理框架功能、实现以及下载【推荐】
14. 发布《OSGi实战》正式版【特别推荐】
15. 发布《OSGi进阶》正式版【特别推荐】
16. OSGi PPT For Newer【推荐】

来自 勤劳的蜜蜂的博客：

1. OSGi介绍（一）什么是OSGi
2. OSGi介绍（二）一个假想的实例
3. OSGi介绍（三）OSGi service platform的体系结构
4. OSGi介绍（四）第一个bundle
5. OSGi介绍（五）两个bundle
6. OSGi介绍（六）OSGi的service
7. OSGi介绍（七）bundle和service(续)

来自Phrancol的博客：

1. 构建模块化的动态Web应用（演示版）
2. 开发基于Equinox/OSGI 的 Web Application (一) [译]
3. 开发基于Equinox/OSGI 的 Web Application (二) [译]
4. Spring-OSGI 1.0 M3 中文手册(Spring Dynamic Modules Reference Guide for OSGi(tm) Service Platforms)
5. Developing Equinox/Spring-osgi/Spring Framework Web Application Part 1 - 显示首页【推荐】
6. Developing Equinox/Spring-osgi/Spring Framework Web Application Part 2 - 使用Spring-OSGI
7. Developing Equinox/Spring-osgi/Spring Framework Web Application Part 3 - 找到我的Bean

来自八进制的博客：

1. Equinox OSGi服务器应用程序的配置步骤
2. 利用OSGi DS实现可配置Web应用程序初探

来自罗明的博客：

1. 让OSGi支持JSF Web开发
2. [OSGi]为什么我们需要Bnd？

来自yangbutao的博客：

1. OSGI 服务层探究
2. OSGI Module & lifecycle

来自erylee的博客：

1. OpenCore: OSGi上部署Hibernate的四种方式
2. OpenCore:OSGi上部署Apache Common Log
3. OpenCore:基于OSGi开发纯插件体系结构的WEB应用程序

来自任成's Blog

1. Equinox OSGi系列之一 Equinox入门
2. Equinox OSGi系列之二 搭建Equinox OSGi核心环境
3. Equinox OSGi系列之三 Equinox配置参数详解
4. Equinox OSGi系列之四 创建自己的OSGi应用项目 

来自IBM 的developerworks

1. 利用 Eclipse 开发基于 OSGi 的 Bundle 应用（2006 年 7 月 17 日）
2. 基于 OSGi 的面向服务的组件编程（2007 年 8 月 31 日）

来自其他的博客或帖子：

1. SOA应用系统总体框架及相关概念
2. SCA与OSGi真的具有可比性吗？【推荐】
3. Eclipse(3.1) Plugin Framework(基于OSGI的Plugin Architecture)
4. 谈谈osgi中的事件机制
5. 基于Web的OSGi框架构想
6. From JavaWorld  "Hello, OSGi, Part 1: Bundles for beginners" "Hello, OSGi, Part 3: Take it to the server side - JavaWorld"

刚刚找到的面试题目。自己做了一下，反正挺惨不人睹的。贴出来就想帮帮有需要的人
并且问问为什么是这个结果呢？有的题的答案真的想不到啊～想不到～

一、判断题（30分）
1．Java程序里,创建新的类对象用关键字new，回收无用的类对象使用关键字free。
2．对象可以赋值，只要使用赋值号（等号）即可，相当于生成了一个各属性与赋值对象相同的新对象。
3．有的类定义时可以不定义构造函数，所以构造函数不是必需的。
4．类及其属性、方法可以同时有一个以上的修饰符来修饰。
5．Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点
6．抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。
7．Final类中的属性和方法都必须被final修饰符修饰。
8．最终类不能派生子类，最终方法不能被覆盖。
9．子类要调用父类的方法，必须使用super关键字。
10．一个Java类可以有多个父类。
11．如果p是父类Parent的对象，而c是子类Child的对象，则语句c = p是正确的。
12．在java集合中，Vector和HashMap是线程安全的。
13．当一个方法在运行过程中产生一个异常，则这个方法会终止，但是整个程序不一定终止运行。
14．接口是特殊的类，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法。
15．用“+”可以实现字符串的拼接，用- 可以从一个字符串中去除一个字符子串。

二、选择题（30分）
1、关于垃圾收集的哪些叙述是正确的（   ）：
A．程序开发者必须自己创建一个线程进行内存释放的工作
B．垃圾收集允许程序开发者明确指定并立即释放该内存
C．垃圾收集将检查并释放不再使用的内存
D．垃圾收集能够在期望的时间释放被java对象使用的内存
2、下面的哪些赋值语句是不正确的（   ）：
A．float　f=11.1;
B．double　d=5.3E12;
C．double　d=3.14159;
D．double　d=3.14D；
3、下面关于变量及其范围的陈述哪些是不正确的（   ）：
A．实例变量是类的成员变量
B．实例变量用关键字static声明
C．在方法中定义的局部变量在该方法被执行时创建
D．局部变量在使用前必须被初始化
4、下列关于修饰符混用的说法，错误的是（  ）：
A．abstract不能与final并列修饰同一个类
B．abstract类中不可以有private的成员
C．abstract方法必须在abstract类中
D．static方法中能处理非static的属性
5、容器Panel和Applet缺省使用的布局编辑策略是（    ）：
A、BorderLayout  B、FlowLayout      C、GridLayout      D、CardLayout
6、以下标识符中哪项是不合法的(    )：
A、 BigMeaninglessName                     B、$int
C、1 st                                    D、$1
7、main方法是Java  Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（    ）：
A、    public  static  void  main（）   
B、    public  static  void   main（String[ ]  args）
C、    public  static int  main（String[ ]  arg）
D、    public  void  main（String  arg[ ]）
8、执行完以下代码int [ ]  x = new  int[25]；后，以下哪项说明是正确的（    ）：
A、    x[24]为0
B、    x[24]未定义
C、    x[25]为0
D、    x[0]为空
9、以下代码段执行后的输出结果为（     ）：
       int  x=3； int  y=10；
       System.out.println(y%x);
A、0
B、1
C、2
D、3
10、以下哪个表达式是不合法的（    ）：
A、String  x=”Hello”;   int  y=9;   x+=y;
B、String  x=”Hello”;   int  y=9;  if(x= =y)  { }
C、String  x=”Hello”;  int  y=9;  x=x+y;
D、String  x=null;  int  y=(x!=null)&&(x.length()>0) ? x.length : 0
11、编译运行以下程序后，关于输出结果的说明正确的是 （    ）：
       public  class   Conditional{
              public  static  void  main(String  args[  ]){
                     int  x=4;
                     System.out.println(“value  is  “+ ((x>4) ? 99.9 :9));
}
}
A、    输出结果为：value  is  99.99
B、    输出结果为：value  is  9
C、    输出结果为：value  is  9.0
D、    编译错误
12、以下声明合法的是（     ）：
A、    default  String  s；
B、    public  final  static  native  int  w( )
C、    abstract  double  d；
D、    abstract  final  double  hyperbolicCosine( )
13、关于以下application的说明，正确的是（    ）：
1．  class   StaticStuff
2． {
3．                  static  int  x=10；
4．                  static  { x+=5；}
5．                  public  static  void  main（String  args[ ]）
6．                  {
7．                       System.out.println(“x=” + x);
8．                  }
9．                  static  { x/=3;}
10.   }
A、 4行与9行不能通过编译，因为缺少方法名和返回类型 
B、 9行不能通过编译，因为只能有一个静态初始化器
C、 编译通过，执行结果为：x=5
D、编译通过，执行结果为：x=3
14、关于以下程序代码的说明正确的是（   ）：
1．class  HasStatic{
2．    private  static  int  x=100；
3．    public  static  void  main(String  args[  ]){
4．        HasStatic  hs1=new  HasStatic(  );
5．        hs1.x++;
6．        HasStatic  hs2=new  HasStatic(  );
7．        hs2.x++;
8．        hs1=new  HasStatic( );
9．        hs1.x++;
10．       HasStatic.x- -;
11．       System.out.println(“x=”+x);
12．   }
13．}
A、5行不能通过编译，因为引用了私有静态变量
B、10行不能通过编译，因为x是私有静态变量
C、程序通过编译，输出结果为：x=103
D、程序通过编译，输出结果为：x=102
15、以下选项中循环结构合法的是（    ）：
A、while (int  i<7){
     i++;
     System.out.println(“i is “+i);
}
B、int  j=3;
while(j){
   System.out.println(“ j  is “+j);
}
C、int  j=0;
for(int  k=0; j + k !=10; j++,k++){
    System.out.println(“ j  is “+ j + “k  is”+ k);
}
D、int  j=0;
do{
        System.out.println( “j  is “+j++);
        if (j = = 3) {continue  loop;}
}while  (j<10);

三、简答题（40分）
1.    写出下列程序的运行结果
public class Cat
{　　
  void mi( ) throws NullPointerException
  {
    System.out.println( “Cat mi mi .. “ );
  }
}
public class SmallCat extends Cat
{int i=8;
  void mi( ) throws Exception
  {
    System.out.println( “SmallCat mi mi .. “ );
  }
  public static void main( String[] a ) throws Exception
  {
    Cat cat = new SmallCat();
    cat.mi();
  }
}


写出下列程序的运行结果
interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable, Bounceable {
    Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
    public Ball(String name) {
        this.name = name;       
    }
   public void play() {
        ball = new Ball("Football");
        System.out.println(ball.getName());
    }
}

写出下列程序的运行结果
class Value{
public int i = 15;
}
public class Test{
public static void main(String argv[]){
       Test t = new Test();
    t.first();
   }
public void first(){
       int i = 5;
       Value v = new Value();
      v.i = 25;
      second(v, i);
      System.out.println(v.i);
   }
public void second(Value v, int i){
      i = 0;
       v.i = 20;
     Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
      }
}


写出下列程序的运行结果
class MyThread extends Thread{
public void run(){
System.out.println("MyThread: run()");
}
public void start(){
System.out.println("MyThread: start()");
    }
}
class MyRunnable implements Runnable{
public void run(){
System.out.println("MyRunnable: run()");
    }
public void start(){
System.out.println("MyRunnable: start()");
   }
}
public class MyTest {
public static void main(String args[]){
MyThread myThread  =  new MyThread();
MyRunnable myRunnable = new MyRunnable();
Thread thread  =  new Thread(myRunnable);
myThread.start();
thread.start();
}
}

一、参考资料：

1. Tuning Garbage Collection with the 5.0 Java Virtual Machine 官方指南。
2. Hotspot memory management whitepaper 官方白皮书。
3. Java Tuning White Paper 官方文档。
4. FAQ about Garbage Collection in the Hotspot  官方FAQ，JVM1.4.2。
5. Java HotSpot 虚拟机中的垃圾收集 JavaOne2004上的中文ppt
6. A Collection of JVM Options JVM选项的超完整收集。

二、基本概念

1、堆(Heap)

JVM管理的内存叫堆。在32Bit操作系统上有1.5G-2G的限制，而64Bit的就没有。

JVM初始分配的内存由-Xms指定，默认是物理内存的1/64但小于1G。

JVM最大分配的内存由-Xmx指定，默认是物理内存的1/4但小于1G。

默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制，可以由-XX:MinHeapFreeRatio=指定。
默认空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制，可以由-XX:MaxHeapFreeRatio=指定。

服务器一般设置-Xms、-Xmx相等以避免在每次GC 后调整堆的大小，所以上面的两个参数没啥用。 

2.基本收集算法

1. 复制：将堆内分成两个相同空间，从根(ThreadLocal的对象，静态对象）开始访问每一个关联的活跃对象，将空间A的活跃对象全部复制到空间B，然后一次性回收整个空间A。
   因为只访问活跃对象，将所有活动对象复制走之后就清空整个空间，不用去访问死对象，所以遍历空间的成本较小，但需要巨大的复制成本和较多的内存。
2. 标记清除(mark-sweep)：收集器先从根开始访问所有活跃对象，标记为活跃对象。然后再遍历一次整个内存区域，把所有没有标记活跃的对象进行回收处理。该算法遍历整个空间的成本较大暂停时间随空间大小线性增大，而且整理后堆里的碎片很多。
3. 标记整理(mark-sweep-compact)：综合了上述两者的做法和优点，先标记活跃对象，然后将其合并成较大的内存块。

    可见，没有免费的午餐，无论采用复制还是标记清除算法，自动的东西都要付出很大的性能代价。

3.分代

    分代是Java垃圾收集的一大亮点，根据对象的生命周期长短，把堆分为3个代：Young，Old和Permanent，根据不同代的特点采用不同的收集算法，扬长避短也。

Young(Nursery)，年轻代。研究表明大部分对象都是朝生暮死，随生随灭的。因此所有收集器都为年轻代选择了复制算法。
    复制算法优点是只访问活跃对象，缺点是复制成本高。因为年轻代只有少量的对象能熬到垃圾收集，因此只需少量的复制成本。而且复制收集器只访问活跃对象，对那些占了最大比率的死对象视而不见，充分发挥了它遍历空间成本低的优点。

    Young的默认值为4M，随堆内存增大，约为1/15，JVM会根据情况动态管理其大小变化。
    -XX:NewRatio= 参数可以设置Young与Old的大小比例，-server时默认为1:2，但实际上young启动时远低于这个比率？如果信不过JVM，也可以用-Xmn硬性规定其大小，有文档推荐设为Heap总大小的1/4。

    Young的大小非常非常重要，见“后面暂停时间优先收集器”的论述。

    Young里面又分为3个区域，一个Eden，所有新建对象都会存在于该区，两个Survivor区，用来实施复制算法。每次复制就是将Eden和第一块Survior的活对象复制到第2块，然后清空Eden与第一块Survior。Eden与Survivor的比例由-XX:SurvivorRatio=设置，默认为32。Survivio大了会浪费，小了的话，会使一些年轻对象潜逃到老人区，引起老人区的不安，但这个参数对性能并不重要。 

Old(Tenured)，年老代。年轻代的对象如果能够挺过数次收集，就会进入老人区。老人区使用标记整理算法。因为老人区的对象都没那么容易死的，采用复制算法就要反复的复制对象，很不合算，只好采用标记清理算法，但标记清理算法其实也不轻松，每次都要遍历区域内所有对象，所以还是没有免费的午餐啊。

-XX:MaxTenuringThreshold=设置熬过年轻代多少次收集后移入老人区，CMS中默认为0，熬过第一次GC就转入，可以用-XX:+PrintTenuringDistribution查看。

Permanent，持久代。装载Class信息等基础数据，默认64M，如果是类很多很多的服务程序，需要加大其设置-XX:MaxPermSize=，否则它满了之后会引起fullgc()或Out of Memory。 注意Spring，Hibernate这类喜欢AOP动态生成类的框架需要更多的持久代内存。

4.minor/major collection

    每个代满了之后都会促发collection，（另外Concurrent Low Pause Collector默认在老人区68%的时候促发)。GC用较高的频率对young进行扫描和回收，这种叫做minor collection。
而因为成本关系对Old的检查回收频率要低很多，同时对Young和Old的收集称为major collection。
    System.gc()会引发major collection，使用-XX:+DisableExplicitGC禁止它，或设为CMS并发-XX:+ExplicitGCInvokesConcurrent。

5.小结

Young -- minor collection -- 复制算法

Old(Tenured) -- major colletion -- 标记清除/标记整理算法

三、收集器

1.古老的串行收集器(Serial Collector)

    使用 -XX:+UseSerialGC，策略为年轻代串行复制，年老代串行标记整理。

2.吞吐量优先的并行收集器(Throughput Collector)

    使用 -XX:+UseParallelGC ，也是JDK5 -server的默认值。策略为：
    1.年轻代暂停应用程序，多个垃圾收集线程并行的复制收集，线程数默认为CPU个数，CPU很多时，可用–XX:ParallelGCThreads=减少线程数。
    2.年老代暂停应用程序，与串行收集器一样，单垃圾收集线程标记整理。

    所以需要2+的CPU时才会优于串行收集器，适用于后台处理，科学计算。

    可以使用-XX:MaxGCPauseMillis= 和 -XX:GCTimeRatio 来调整GC的时间。

3.暂停时间优先的并发收集器(Concurrent Low Pause Collector-CMS)

    前面说了这么多，都是为了这节做铺垫......

    使用-XX:+UseConcMarkSweepGC，策略为：
    1.年轻代同样是暂停应用程序，多个垃圾收集线程并行的复制收集。
    2.年老代则只有两次短暂停，其他时间应用程序与收集线程并发的清除。

3.1 年老代详述

    并行(Parallel)与并发(Concurrent)仅一字之差，并行指多条垃圾收集线程并行，并发指用户线程与垃圾收集线程并发，程序在继续运行，而垃圾收集程序运行于另一个个CPU上。

    并发收集一开始会很短暂的停止一次所有线程来开始初始标记根对象，然后标记线程与应用线程一起并发运行，最后又很短的暂停一次，多线程并行的重新标记之前可能因为并发而漏掉的对象，然后就开始与应用程序并发的清除过程。可见，最长的两个遍历过程都是与应用程序并发执行的，比以前的串行算法改进太多太多了！！！

    串行标记清除是等年老代满了再开始收集的，而并发收集因为要与应用程序一起运行，如果满了才收集，应用程序就无内存可用，所以系统默认68%满的时候就开始收集。内存已设得较大，吃内存又没有这么快的时候，可以用-XX:CMSInitiatingOccupancyFraction=恰当增大该比率。

3.2 年轻代详述

   可惜对年轻代的复制收集，依然必须停止所有应用程序线程，原理如此，只能靠多CPU，多收集线程并发来提高收集速度，但除非你的Server独占整台服务器，否则如果服务器上本身还有很多其他线程时，切换起来速度就..... 所以，搞到最后，暂停时间的瓶颈就落在了年轻代的复制算法上。

    因此Young的大小设置挺重要的，大点就不用频繁GC，而且增大GC的间隔后，可以让多点对象自己死掉而不用复制了。但Young增大时，GC造成的停顿时间攀升得非常恐怖，比如在我的机器上，默认8M的Young，只需要几毫秒的时间，64M就升到90毫秒，而升到256M时，就要到300毫秒了，峰值还会攀到恐怖的800ms。谁叫复制算法，要等Young满了才开始收集，开始收集就要停止所有线程呢。

3.3 持久代

可设置-XX:+CMSClassUnloadingEnabled -XX:+CMSPermGenSweepingEnabled，使CMS收集持久代的类，而不是fullgc，netbeans5.5 performance文档的推荐。

4.增量(train算法)收集器(Incremental Collector)

已停止维护，–Xincgc选项默认转为并发收集器。

四、暂停时间显示

 加入下列参数 (请将PrintGC和Details中间的空格去掉，CSDN很怪的认为是禁止字句） 

-verbose:gc -XX:+PrintGC Details  -XX:+PrintGCTimeStamps

会程序运行过程中将显示如下输出

 9.211: [GC 9.211: [ParNew: 7994K->0K(8128K), 0.0123935 secs] 427172K->419977K(524224K), 0.0125728 secs]

 显示在程序运行的9.211秒发生了Minor的垃圾收集，前一段数据针对新生区，从7994k整理为0k，新生区总大小为8128k，程序暂停了12ms，而后一段数据针对整个堆。

对于年老代的收集，暂停发生在下面两个阶段，CMS-remark的中断是17毫秒：

[GC [1 CMS-initial-mark: 80168K(196608K)] 81144K(261184K), 0.0059036 secs] 

[1 CMS-remark: 80168K(196608K)] 82493K(261184K),0.0168943 secs]

再加两个参数 -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime对暂停时间看得更清晰。

五、真正不停的BEA JRockit 与Sun RTS2.0

   Bea的JRockit 5.0 R27 的特色之一是动态决定的垃圾收集策略，用户可以决定自己关心的是吞吐量，暂停时间还是确定的暂停时间，再由JVM在运行时动态决定、改变改变垃圾收集策略。
   
   它的Deterministic GC的选项是-Xgcprio: deterministic，号称可以把暂停可以控制在10-30毫秒，非常的牛，一句Deterministic道尽了RealTime的真谛。 不过细看一下文档，30ms的测试环境是1 GB heap 和 平均  30% 的活跃对象(也就是300M)活动对象，2 个 Xeon 3.6 GHz  4G内存 ，或者是4 个Xeon 2.0 GHz，8G内存。

  最可惜JRockt的license很奇怪，虽然平时使用免费，但这个30ms的选项就需要购买整个Weblogic Real Time Server的license。 

  其他免费选项，有：

• -Xgcprio:pausetime -Xpausetarget=210ms 
    因为免费，所以最低只能设置到200ms pause target。 200ms是Sun认为Real-Time的分界线。
• -Xgc:gencon
  普通的并发做法，效率也不错。

  JavaOne2007上有Sun的 Java Real-Time System 2.0 的介绍，RTS2.0基于JDK1.5，在Real-Time  Garbage Collctor上又有改进，但还在beta版状态，只供给OEM，更怪。

六、JDK 6.0的改进

因为JDK5.0在Young较大时的表现还是不够让人满意，又继续看JDK6.0的改进，结果稍稍失望，不涉及我最头痛的年轻代复制收集改良。

1.年老代的标识-清除收集，并行执行标识
  JDK5.0只开了一条收集进程与应用线程并发标识，而6.0可以开多条收集线程来做标识，缩短标识老人区所有活动对象的时间。

2.加大了Young区的默认大小
默认大小从4M加到16M，从堆内存的1/15增加到1/7

3.System.gc()可以与应用程序并发执行
使用-XX:+ExplicitGCInvokesConcurrent 设置

七、小结

1. JDK5.0/6.0

对于服务器应用，我们使用Concurrent Low Pause Collector，对年轻代，暂停时多线程并行复制收集；对年老代，收集器与应用程序并行标记--整理收集，以达到尽量短的垃圾收集时间。

本着没有深刻测试前不要胡乱优化的宗旨，命令行属性只需简单写为：

然后要根据应用的情况，在测试软件辅助可以下看看有没有JVM的默认值和自动管理做的不够的地方可以调整，如-xmn 设Young的大小，-XX:MaxPermSize设持久代大小等。

2. JRockit 6.0 R27.2

但因为JDK5的测试结果实在不能满意，后来又尝试了JRockit，总体效果要好些。
 JRockit的特点是动态垃圾收集器是根据用户关心的特征动态决定收集算法的，参数如下

1.垃圾收集算法的核心思想

　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。

　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别，如果对象正在被引用，那么称其为存活对象，反之，如果对象不再被引用，则为垃圾对象，可以回收其占据的空间，用于再分配。垃圾收集算法的选择和垃圾收集系统参数的合理调节直接影响着系统性能，因此需要开发人员做比较深入的了解。

2.触发主GC(Garbage Collector)的条件

　　JVM进行次GC的频率很高,但因为这种GC占用时间极短,所以对系统产生的影响不大。更值得关注的是主GC的触发条件,因为它对系统影响很明显。总的来说,有两个条件会触发主GC:
 

　　①当应用程序空闲时,即没有应用线程在运行时,GC会被调用。因为GC在优先级最低的线程中进行,所以当应用忙时,GC线程就不会被调用,但以下条件除外。

　　②Java堆内存不足时,GC会被调用。当应用线程在运行,并在运行过程中创建新对象,若这时内存空间不足,JVM就会强制地调用GC线程,以便回收内存用于新的分配。若GC一次之后仍不能满足内存分配的要求,JVM会再进行两次GC作进一步的尝试,若仍无法满足要求,则 JVM将报“out of memory”的错误,Java应用将停止。

　　由于是否进行主GC由JVM根据系统环境决定,而系统环境在不断的变化当中,所以主GC的运行具有不确定性,无法预计它何时必然出现,但可以确定的是对一个长期运行的应用来说,其主GC是反复进行的。

3.减少GC开销的措施

　　根据上述GC的机制,程序的运行会直接影响系统环境的变化,从而影响GC的触发。若不针对GC的特点进行设计和编码,就会出现内存驻留等一系列负面影响。为了避免这些影响,基本的原则就是尽可能地减少垃圾和减少GC过程中的开销。具体措施包括以下几个方面:

　　(1)不要显式调用System.gc()

　　此函数建议JVM进行主GC,虽然只是建议而非一定,但很多情况下它会触发主GC,从而增加主GC的频率,也即增加了间歇性停顿的次数。

　　(2)尽量减少临时对象的使用

　　临时对象在跳出函数调用后,会成为垃圾,少用临时变量就相当于减少了垃圾的产生,从而延长了出现上述第二个触发条件出现的时间,减少了主GC的机会。

　　(3)对象不用时最好显式置为Null

　　一般而言,为Null的对象都会被作为垃圾处理,所以将不用的对象显式地设为Null,有利于GC收集器判定垃圾,从而提高了GC的效率。

　　(4)尽量使用StringBuffer,而不用String来累加字符串(详见blog另一篇文章JAVA中String与StringBuffer)

　　由于String是固定长的字符串对象,累加String对象时,并非在一个String对象中扩增,而是重新创建新的String对象,如Str5=Str1+Str2+Str3+Str4,这条语句执行过程中会产生多个垃圾对象,因为对次作“+”操作时都必须创建新的String对象,但这些过渡对象对系统来说是没有实际意义的,只会增加更多的垃圾。避免这种情况可以改用StringBuffer来累加字符串,因StringBuffer是可变长的,它在原有基础上进行扩增,不会产生中间对象。

　　(5)能用基本类型如Int,Long,就不用Integer,Long对象

　　基本类型变量占用的内存资源比相应对象占用的少得多,如果没有必要,最好使用基本变量。

　　(6)尽量少用静态对象变量

　　静态变量属于全局变量,不会被GC回收,它们会一直占用内存。

　　(7)分散对象创建或删除的时间

　　集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机会。

4.gc与finalize方法

　　⑴gc方法请求垃圾回收

　　使用System.gc()可以不管JVM使用的是哪一种垃圾回收的算法，都可以请求Java的垃圾回收。需要注意的是，调用System.gc()也仅仅是一个请求。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

　　⑵finalize方法透视垃圾收集器的运行

　　在JVM垃圾收集器收集一个对象之前 ，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java提供了缺省机制来终止化该对象释放资源，这个方法就是finalize()。它的原型为：

　　protected void finalize() throws Throwable

　　在finalize()方法返回之后，对象消失，垃圾收集开始执行。原型中的throws Throwable表示它可以抛出任何类型的异常。

　　因此，当对象即将被销毁时，有时需要做一些善后工作。可以把这些操作写在finalize()方法里。

 

 

⑶代码示例

5.Java 内存泄漏
　　由于采用了垃圾回收机制，任何不可达对象(对象不再被引用)都可以由垃圾收集线程回收。因此通常说的Java 内存泄漏其实是指无意识的、非故意的对象引用，或者无意识的对象保持。无意识的对象引用是指代码的开发人员本来已经对对象使用完毕，却因为编码的错误而意外地保存了对该对象的引用(这个引用的存在并不是编码人员的主观意愿)，从而使得该对象一直无法被垃圾回收器回收掉，这种本来以为可以释放掉的却最终未能被释放的空间可以认为是被“泄漏了”。

　　考虑下面的程序,在ObjStack类中,使用push和pop方法来管理堆栈中的对象。两个方法中的索引(index)用于指示堆栈中下一个可用位置。push方法存储对新对象的引用并增加索引值,而pop方法减小索引值并返回堆栈最上面的元素。在main方法中,创建了容量为64的栈,并64次调用push方法向它添加对象,此时index的值为64,随后又32次调用pop方法,则index的值变为32,出栈意味着在堆栈中的空间应该被收集。但事实上,pop方法只是减小了索引值,堆栈仍然保持着对那些对象的引用。故32个无用对象不会被GC回收,造成了内存渗漏。

 

 

6.如何消除内存泄漏

　　虽然Java虚拟机(JVM)及其垃圾收集器(garbage collector，GC)负责管理大多数的内存任务，Java软件程序中还是有可能出现内存泄漏。实际上，这在大型项目中是一个常见的问题。避免内存泄漏的第一步是要弄清楚它是如何发生的。本文介绍了编写Java代码的一些常见的内存泄漏陷阱，以及编写不泄漏代码的一些最佳实践。一旦发生了内存泄漏，要指出造成泄漏的代码是非常困难的。因此本文还介绍了一种新工具，用来诊断泄漏并指出根本原因。该工具的开销非常小，因此可以使用它来寻找处于生产中的系统的内存泄漏。

　　垃圾收集器的作用

　　虽然垃圾收集器处理了大多数内存管理问题，从而使编程人员的生活变得更轻松了，但是编程人员还是可能犯错而导致出现内存问题。简单地说，GC循环地跟踪所有来自“根”对象(堆栈对象、静态对象、JNI句柄指向的对象，诸如此类)的引用，并将所有它所能到达的对象标记为活动的。程序只可以操纵这些对象;其他的对象都被删除了。因为GC使程序不可能到达已被删除的对象，这么做就是安全的。

　　虽然内存管理可以说是自动化的，但是这并不能使编程人员免受思考内存管理问题之苦。例如，分配(以及释放)内存总会有开销，虽然这种开销对编程人员来说是不可见的。创建了太多对象的程序将会比完成同样的功能而创建的对象却比较少的程序更慢一些(在其他条件相同的情况下)。

　　而且，与本文更为密切相关的是，如果忘记“释放”先前分配的内存，就可能造成内存泄漏。如果程序保留对永远不再使用的对象的引用，这些对象将会占用并耗尽内存，这是因为自动化的垃圾收集器无法证明这些对象将不再使用。正如我们先前所说的，如果存在一个对对象的引用，对象就被定义为活动的，因此不能删除。为了确保能回收对象占用的内存，编程人员必须确保该对象不能到达。这通常是通过将对象字段设置为null或者从集合(collection)中移除对象而完成的。但是，注意，当局部变量不再使用时，没有必要将其显式地设置为null。对这些变量的引用将随着方法的退出而自动清除。

　　概括地说，这就是内存托管语言中的内存泄漏产生的主要原因：保留下来却永远不再使用的对象引用。

　　典型泄漏

　　既然我们知道了在Java中确实有可能发生内存泄漏，就让我们来看一些典型的内存泄漏及其原因。

　　全局集合

　　在大的应用程序中有某种全局的数据储存库是很常见的，例如一个JNDI树或一个会话表。在这些情况下，必须注意管理储存库的大小。必须有某种机制从储存库中移除不再需要的数据。

　　这可能有多种方法，但是最常见的一种是周期性运行的某种清除任务。该任务将验证储存库中的数据，并移除任何不再需要的数据。

　　另一种管理储存库的方法是使用反向链接(referrer)计数。然后集合负责统计集合中每个入口的反向链接的数目。这要求反向链接告诉集合何时会退出入口。当反向链接数目为零时，该元素就可以从集合中移除了。

　　缓存

　　缓存是一种数据结构，用于快速查找已经执行的操作的结果。因此，如果一个操作执行起来很慢，对于常用的输入数据，就可以将操作的结果缓存，并在下次调用该操作时使用缓存的数据。

　　缓存通常都是以动态方式实现的，其中新的结果是在执行时添加到缓存中的。典型的算法是：

　　检查结果是否在缓存中，如果在，就返回结果。

　　如果结果不在缓存中，就进行计算。

　　将计算出来的结果添加到缓存中，以便以后对该操作的调用可以使用。

　　该算法的问题(或者说是潜在的内存泄漏)出在最后一步。如果调用该操作时有相当多的不同输入，就将有相当多的结果存储在缓存中。很明显这不是正确的方法。

　　为了预防这种具有潜在破坏性的设计，程序必须确保对于缓存所使用的内存容量有一个上限。因此，更好的算法是：

　　检查结果是否在缓存中，如果在，就返回结果。

　　如果结果不在缓存中，就进行计算。

　　如果缓存所占的空间过大，就移除缓存最久的结果。

　　将计算出来的结果添加到缓存中，以便以后对该操作的调用可以使用。

　　通过始终移除缓存最久的结果，我们实际上进行了这样的假设：在将来，比起缓存最久的数据，最近输入的数据更有可能用到。这通常是一个不错的假设。

　　新算法将确保缓存的容量处于预定义的内存范围之内。确切的范围可能很难计算，因为缓存中的对象在不断变化，而且它们的引用包罗万象。为缓存设置正确的大小是一项非常复杂的任务，需要将所使用的内存容量与检索数据的速度加以平衡。

　　解决这个问题的另一种方法是使用java.lang.ref.SoftReference类跟踪缓存中的对象。这种方法保证这些引用能够被移除，如果虚拟机的内存用尽而需要更多堆的话。

　　ClassLoader

　　Java ClassLoader结构的使用为内存泄漏提供了许多可乘之机。正是该结构本身的复杂性使ClassLoader在内存泄漏方面存在如此多的问题。ClassLoader的特别之处在于它不仅涉及“常规”的对象引用，还涉及元对象引用，比如：字段、方法和类。这意味着只要有对字段、方法、类或ClassLoader的对象的引用，ClassLoader就会驻留在JVM中。因为ClassLoader本身可以关联许多类及其静态字段，所以就有许多内存被泄漏了。

　　确定泄漏的位置

　　通常发生内存泄漏的第一个迹象是：在应用程序中出现了OutOfMemoryError。这通常发生在您最不愿意它发生的生产环境中，此时几乎不能进行调试。有可能是因为测试环境运行应用程序的方式与生产系统不完全相同，因而导致泄漏只出现在生产中。在这种情况下，需要使用一些开销较低的工具来监控和查找内存泄漏。还需要能够无需重启系统或修改代码就可以将这些工具连接到正在运行的系统上。可能最重要的是，当进行分析时，需要能够断开工具而保持系统不受干扰。

　　虽然OutOfMemoryError通常都是内存泄漏的信号，但是也有可能应用程序确实正在使用这么多的内存;对于后者，或者必须增加JVM可用的堆的数量，或者对应用程序进行某种更改，使它使用较少的内存。但是，在许多情况下，OutOfMemoryError都是内存泄漏的信号。一种查明方法是不间断地监控GC的活动，确定内存使用量是否随着时间增加。如果确实如此，就可能发生了内存泄漏。

在Ubuntu 8.04中查看显卡是否装好
运行glxinfo | grep rendering
如果显示”direct rendering: Yes”，则已安装

1、下载驱动

我下载的就是NVIDIA-Linux-x86_64-173.14.12-pkg2.run这个文件，下载后放到home目录下吧。

 

2、删除原驱动包
sudo apt-get -–purge remove nvidia-glx nvidia-glx-new
然后删除 /lib/linux-restricted-modules/2.6.22-14-generic/文件夹下面带有nvidia字样的内容，注意里面有一个隐藏文件.nvidia-new-installer也要删掉

这里是内核自带的驱动

再检查一下这两个文件是否存在，/etc/init.d/nvidia-glx /etc/init.d/nvidia-kernel 如果存在，删除掉。

3、安装要用到的软件
sudo apt-get install build-essential pkg-config xserver-xorg-dev linux-headers-`uname -r`

安装编译包。

我在安装的时候提示说没有lib，驱动安装时候要安装Kernel Interface，如果采用自己编译的方式则要求系统中有libc的源码。我想一般人都是没有的，呵呵。这个时候我们可以在安装驱动之前先自己把这个源码给安装好，问题就解决了。如何安装？呵呵，更简单，强大的 apt install阿， 运行：
sudo apt-get install libc6-dev
一行命令搞定。

4、备份
备份文件是一个好习惯。
sudo cp /etc/default/linux-restricted-modules-common ～/linux-restricted-modules-common.backup
sudo cp /etc/X11/xorg.conf ～/xorg.conf.backup

5、禁止系统使用默认的驱动
sudo gedit /etc/default/linux-restricted-modules-common
在最后的双引号中添加nv nvidia_new，即把文件中的“”，改成“nv nvidia_new”
如果前面第二步删除完整了其实也可以不用执行这一步。

6、将后面的操作记录在纸上，因为后面会完全在终端字符界面下操作。

7、停止GDM进程
sudo /etc/init.d/gdm stop
按Ctrl+Alt+F1，登录后进入第7步。

8、安装驱动
进入下好的驱动所在目录
执行：sudo sh ./NVIDIA-Linux-x86_64-173.14.12-pkg2.run

安装过程中

如果提示有旧驱动，询问是否删除旧驱动，选Yes；
如果提示缺少某某模块（modules），询问是否上网下载，选no；
如果提示编译模块，询问是否进行编译，选ok；
如果提示将要修改Xorg.conf，询问是否允许，选Yes；

接下来就是等待安装完成。

9、安装完成就回到终端，重启GDM
sudo /etc/init.d/gdm restart

如果失败，就重启机子：sudo shutdown -r now

好了，当看到NV的logo后，才表示安装成功。

如果不想看NVIDIA的LOGO,可以修改 /etc/X11/xorg.conf
在Section “Device”中添加Option “NoLogo” “True”

如:
Section “Device”
Identifier “通用显示卡”
Driver “nvidia”
Option “NoLogo” “True”
EndSection

10.显示高级设置
如果想进行显示方面的高级设置，在终端下输入：nvidia-settings命令。

左边第二项是设置分辨率（server display configuration），从右边的resolution中选择分辨率，再点击apply,

预览一下，不好取消就行了。

至此，安装完毕。

如果御载的话就用这个命令

sh NVIDIA-Linux-x86_64-173.14.12-pkg2.run –uninstall

安装成功，就这么简单，一般nvidia 会自动配置好所有～｀

重新配置x server：
sudo apt-get install pkg-config xserver-xorg-dev3
sudo dpkg-reconfigure xserver-xorg

安装MySQL

sudo apt-get install mysql-server

这个应该很简单了，而且我觉得大家在安装方面也没什么太大问题，所以也就不多说了，下面我们来讲讲配置。

配置MySQL

注意，在Ubuntu下MySQL缺省是只允许本地访问的，如果你要其他机器也能够访问的话，那么需要改变/etc/mysql/my.cnf配置文件了！下面我们一步步地来：

默认的MySQL安装之后根用户是没有密码的，所以首先用根用户进入：

$mysql -u root

在这里之所以用-u root是因为我现在是一般用户（firehare），如果不加-u root的话，mysql会以为是firehare在登录。注意，我在这里没有进入根用户模式，因为没必要。一般来说，对mysql中的数据库进行操作， 根本没必要进入根用户模式，只有在设置时才有这种可能。

进入mysql之后，最要紧的就是要设置Mysql中的root用户密码了，否则，Mysql服务无安全可言了。

mysql> GRANT ALL PRIVILEGES ON *.* TO root@localhost IDENTIFIED BY "123456";

注意，我这儿用的是123456做为root用户的密码，但是该密码是不安全的，请大家最好使用大小写字母与数字混合的密码，且不少于8位。

这样的话，就设置好了MySQL中的root用户密码了，然后就用root用户建立你所需要的数据库。我这里就以xoops为例：

mysql>CREATE DATABASE xoops；

mysql>GRANT ALL PRIVILEGES ON xoops.* TO xoops_root@localhost IDENTIFIED BY "654321";

这样就建立了一个xoops_roots的用户，它对数据库xoops有着全部权限。以后就用xoops_root来对xoops数据库进行管理，而无需要再用root用户了，而该用户的权限也只被限定在xoops数据库中。

如果你想进行远程访问或控制，那么你要做两件事：

其一：

mysql>GRANT ALL PRIVILEGES ON xoops.* TO xoops_root@"%" IDENTIFIED BY "654321";

允许xoops_root用户可以从任意机器上登入MySQL。

其二：

$sudo gedit /etc/mysql/my.cnf

老的版本中

>skip-networking => # skip-networking

新的版本中

>bind-address=127.0.0.1 => bind-address= 你机器的IP

这样就可以允许其他机器访问MySQL了。

Ubuntu8.04开启3D桌面特效与设置方法

Ubuntu 8.04 (Hardy Heron) 中集成了强大3D交互界面，Ubuntu 的 3D桌面特效给用户带来了一种全新的视觉用户。想必有很多朋友也因为看到了 Ubuntu 8.04 那炫目的 3D 桌面特效才开始慢慢地了解Ubuntu 8.04 (Hardy Heron) 的。虽然在这之前也不少的朋友写过设置 Ubuntu 阅读全文
类别：Ubuntu 查看评论
文章来源:http://hi.baidu.com/whchensiyuan/blog/item/75a0ddbe9e308d0c18d81fd5.html

此篇是Ubuntu 8.04下加源安装Google Gadgets的方法，用户不再需要自行编译了，而且能一直保持最新。

　　Google Gadgets是一套跨平台的桌面工具集，for Linux版本刚刚公布不久。

　　在ubuntu 8.04中：

　　编辑源文件：

sudo gedit /etc/apt/sources.list

　　加入下面两行：

deb http://ppa.launchpad.net/googl

阅读全文
类别：Ubuntu 查看评论
文章来源:http://hi.baidu.com/whchensiyuan/blog/item/0c2bec1ebdef9a0c314e15bf.html

很多新手面临的困难和困惑都出现在编译和打包软件方面，unubtu的apt－get方式的确很易用，但是也屏蔽了学习的空间，对于那些希望好好学习linux的而又感到困惑的人，通过以下三个程序的帮助，应该可以有效的减轻你的负担：

第一个，checkinstall
安装命令：sudo apt-get install checkinstall
程序功能：能跟踪由“make install”或类似命令安装的所有文件，并为这些文件创建Slackware、RPM或者Debian安装包，然后把它添加到已安装软件包数据库中，以 阅读全文
类别：默认分类 查看评论
文章来源:http://hi.baidu.com/whchensiyuan/blog/item/ac02403c7db675e83c6d9745.html

Linux常用命令详解

来源: LUPA开源社区
发布时间: 2007-05-27 05:34 版权申明

字体: 小 中 大
[点击图片可在新窗口打开]

文章来源于http://www.lupaworld.com

Linux之所以受到广大计算机爱好者的喜爱，主要原因有两个，首先它是自由软件，用户不用支付费用就可以使用它，并可根据自己的需要对它进行修改。另外，它具有Unix的全部功能，任何使用Unix系统或想要学习Unix系统的人都可以从中获益。

让我们一起从每一个命令开始，走向Linux高手之路吧。

1.Linux进入与退出系 阅读全文
类别：默认分类 查看评论
文章来源:http://hi.baidu.com/whchensiyuan/blog/item/8a8b9ad58836ab07a08bb74e.html

ubuntu中默认的是gnome桌面，也可以为你的程序设置快捷方式。

可以以两种方式生成快捷方式，这里叫做起动器：命令行方式和拖动程序图标的方式。这里以Lumaqq为例说明之。

1.在应用程序菜单中创建起动器：

在命令行中输入如下命令：

sudo gedit /usr/share/applications/LumaQQ.desktop

//sudo是以超级用户权限执行后面命令
//gedit是打开文本编辑器，后面的路径标识要编辑的文件
//在/usr/share/applications目录下可以看到许多*.desktop的文件，都是应用程序的起动器，所以上述 阅读全文
类别：默认分类 查看评论
文章来源:http://hi.baidu.com/whchensiyuan/blog/item/df1445e695411c28b83820f4.html

已经有一些热心人写了Compiz Fusion的设置指南，但大多是在7.10版下面的，现在系统升级成8.04后，CompizConfig设置管理器的内容有些不同，我等新手摸索了几天，小有心得，奉献给大家，写得有点罗嗦，清见谅。

点击 系统->首选项->Advanced Desktop Effects Settings 打开CompizConfig设置管理器(即CCSM)

1、3D桌面设置：点击General options，把Desktop Size选项卡里的“Horizontal Virtual Size（水平虚拟大小）”设置为4，“Vertical Virtual Size（垂直虚拟大小）”设置为 阅读全文
类别：默认分类 查看评论
文章来源:http://hi.baidu.com/whchensiyuan/blog/item/43e981eef1e8fee9cf1b3e4a.html

Linux之所以受到广大计算机爱好者的喜爱，主要原因有两个，首先它是自由软件，用户不用支付费用就可以使用它，并可根据自己的需要对它进行修改。另外，它具有Unix的全部功能，任何使用Unix系统或想要学习Unix系统的人都可以从中获益。

让我们一起从每一个命令开始，走向Linux高手之路吧。

1.Linux进入与退出系统
进入Linux系统：
必须要输入用户的账号，在系统安装过程中可以创建以下两种帐号：
1．root--超级用户帐号（系统管理员），使用这个帐号可以在系统中做任何事情。
2．普通用户--这个帐号供普通用户使用，可以进行有限的操作。
一般的Linux使用者均为普通用户，而系统管理员一般使用超级用户帐号完成一些系统管理的工作。如果只需要完成一些由普通帐号就能完成的任务，建议不要使用超级用户帐号，以免无意中破坏系统。影响系统的正常运行。
用户登录分两步：第一步，输入用户的登录名，系统根据该登录名识别用户；第二步，输入用户的口令，该口令是用户自己设置的一个字符串，对其他用户是保密的，是在登录时系统用来辨别真假用户的关键字。
当用户正确地输入用户名和口令后，就能合法地进入系统。屏幕显示：
[root@loclhost /root] #

这时就可以对系统做各种操作了。注意超级用户的提示符是“#”，其他用户的提示符是“$”。

修改口令
为了更好的保护用户帐号的安全，Linux允许用户随时修改自己的口令，修改口令的命令是passwd，它将提示用户输入旧口令和新口令，之后还要求用户再次确认新口令，以避免用户无意中按错键。如果用户忘记了口令，可以向系统管理员申请为自己重新设置一个。

虚拟控制台
Linux是一个真正的多用户操作系统，它可以同时接受多个用户登录。Linux还允许一个用户进行多次登录，这是因为Linux和UNIX一样，提供了 虚拟控制台的访问方式，允许用户在同一时间从控制台进行多次登录。虚拟控制台的选择可以通过按下Alt键和一个功能键来实现，通常使用F1-F6例如，用 户登录后，按一下Alt-F2键，用户又可以看到"login:"提示符，说明用户看到了第二个虚拟控制台。然后只需按Alt-F1键，就可以回到第一个 虚拟控制台。一个新安装的Linux系统默认允许用户使用Alt-F1到Alt-F6键来访问前六个虚拟控制台。虚拟控制台可使用户同时在多个控制台上工 作，真正体现 Linux系统多用户的特性。用户可以在某一虚拟控制台上进行的工作尚未结束时，切换到另一虚拟控制台开始另一项工作。
退出系统
不论是超级用户，还是普通用户，需要退出系统时，在shell提示符下，键入exit命令即可。

Linux文件的复制、删除和移动命令
cp命令

该命令的功能是将给出的文件或目录拷贝到另一文件或目录中，同MSDOS下的copy命令一样，功能十分强大。
语法： cp [选项] 源文件或目录 目标文件或目录
说明：该命令把指定的源文件复制到目标文件或把多个源文件复制到目标目录中。
该命令的各选项含义如下：
- a 该选项通常在拷贝目录时使用。它保留链接、文件属性，并递归地拷贝目录，其作用等于dpR选项的组合。
- d 拷贝时保留链接。
- f 删除已经存在的目标文件而不提示。
- i 和f选项相反，在覆盖目标文件之前将给出提示要求用户确认。回答y时目标文件将被覆盖，是交互式拷贝。
- p 此时cp除复制源文件的内容外，还将把其修改时间和访问权限也复制到新文件中。
- r 若给出的源文件是一目录文件，此时cp将递归复制该目录下所有的子目录和文件。此时目标文件必须为一个目录名。
- l 不作拷贝，只是链接文件。
需要说明的是，为防止用户在不经意的情况下用cp命令破坏另一个文件，如用户指定的目标文件名已存在，用cp命令拷贝文件后，这个文件就会被新源文件覆盖，因此，建议用户在使用cp命令拷贝文件时，最好使用i选项。

mv命令

用户可以使用mv命令来为文件或目录改名或将文件由一个目录移入另一个目录中。该命令如同MSDOS下的ren和move的组合。
语法：mv [选项] 源文件或目录 目标文件或目录
说明：视mv命令中第二个参数类型的不同（是目标文件还是目标目录），mv命令将文件重命名或将其移至一个新的目录中。当第二个参数类型是文件时，mv 命令完成文件重命名，此时，源文件只能有一个（也可以是源目录名），它将所给的源文件或目录重命名为给定的目标文件名。当第二个参数是已存在的目录名称 时，源文件或目录参数可以有多个，mv命令将各参数指定的源文件均移至目标目录中。在跨文件系统移动文件时，mv先拷贝，再将原有文件删除，而链至该文件 的链接也将丢失。
命令中各选项的含义为：
- I 交互方式操作。如果mv操作将导致对已存在的目标文件的覆盖，此时系统询问是否重写，要求用户回答y或n，这样可以避免误覆盖文件。
- f 禁止交互操作。在mv操作要覆盖某已有的目标文件时不给任何指示，指定此选项后，i选项将不再起作用。
如果所给目标文件（不是目录）已存在，此时该文件的内容将被新文件覆盖。为防止用户用mv命令破坏另一个文件，使用mv命令移动文件时，最好使用i选项。

rm命令

用户可以用rm命令删除不需要的文件。该命令的功能为删除一个目录中的一个或多个文件或目录，它也可以将某个目录及其下的所有文件及子目录均删除。对于链接文件，只是断开了链接，原文件保持不变。
rm命令的一般形式为：
rm [选项] 文件…
如果没有使用- r选项，则rm不会删除目录。
该命令的各选项含义如下：
- f 忽略不存在的文件，从不给出提示。
- r 指示rm将参数中列出的全部目录和子目录均递归地删除。
- i 进行交互式删除。
使用rm命令要小心。因为一旦文件被删除，它是不能被恢复的。了防止这种情况的发生，可以使用i选项来逐个确认要删除的文件。如果用户输入y，文件将被删除。如果输入任何其他东西，文件则不会删除。

Linux目录的创建与删除命令
mkdir命令

功能：创建一个目录（类似MSDOS下的md命令）。
语法：mkdir [选项] dir-name
说明：该命令创建由dir-name命名的目录。要求创建目录的用户在当前目录中（dir-name的父目录中）具有写权限，并且dirname不能是当前目录中已有的目录或 文件名称。
命令中各选项的含义为：
- m 对新建目录设置存取权限。也可以用chmod命令设置。
- p 可以是一个路径名称。此时若路径中的某些目录尚不存在， 加上此选项后， 系统将自动建立好那些尚不存在的目录，即一次可以建立多个目录。

rmdir 命令

功能：删除空目录。
语法：rmdir [选项] dir-name
说明：dir-name表示目录名。该命令从一个目录中删除一个或多个子目录项。需要 特别注意的是，一个目录被删除之前必须是空的。rm - r dir命令可代替 rmdir，但是有危险性。删除某目录时也必须具有对父目录的写权限。
命令中各选项的含义为：
- p 递归删除目录dirname，当子目录删除后其父目录为空时，也一同被删除。如果整个路径被删除或者由于某种原因保留部分路径，则系统在标准输出上显示相应 的信息。

cd 命令

功能：改变工作目录。
语法：cd [directory]
说明：该命令将当前目录改变至directory所指定的目录。若没有指定directory， 则回到用户的主目录。为了改变到指定目录，用户必须拥有对指定目录的执行和读 权限。
该命令可以使用通配符（通配符含义请参见第十章）。

pwd 命令

在Linux层次目录结构中，用户可以在被授权的任意目录下利用mkdir命令创建新目录，也可以利用cd命令从一个目录转换到另一个目录。然而，没有提示符来告知用 户目前处于哪一个目录中。要想知道当前所处的目录，可以使用pwd命令，该命令显示整个路径名。
语法：pwd
说明：此命令显示出当前工作目录的绝对路径。

ls 命令

ls是英文单词list的简写，其功能为列出目录的内容。这是用户最常用的一个命令之一，因为用户需要不时地查看某个目录的内容。该命令类似于DOS下的dir命令。
语法：ls [选项] [目录或是文件]
对于每个目录，该命令将列出其中的所有子目录与文件。对于每个文件，ls将输出 其文件名以及所要求的其他信息。默认情况下，输出条目按字母顺序排序。当未给出目录名或是文件名时，就显示当前目录的信息。
命令中各选项的含义如下：
- a 显示指定目录下所有子目录与文件，包括隐藏文件。
- A 显示指定目录下所有子目录与文件，包括隐藏文件。但不列出“.”和 “..”。
- b 对文件名中的不可显示字符用八进制逃逸字符显示。
- c 按文件的修改时间排序。
- C 分成多列显示各项。
- d 如果参数是目录，只显示其名称而不显示其下的各文件。往往与l选项一起使 用，以得到目录的详细信息。
- f 不排序。该选项将使lts选项失效，并使aU选项有效。
- F 在目录名后面标记“/”，可执行文件后面标记“*”，符号链接后面标记 “@”，管道（或FIFO）后面标记“|”，socket文件后面标记“=”。
- i 在输出的第一列显示文件的i节点号。
- l 以长格式来显示文件的详细信息。这个选项最常用。
每行列出的信息依次是： 文件类型与权限 链接数 文件属主 文件属组 文件大小 建立或最近修改的时间 名字
对于符号链接文件，显示的文件名之后有“—〉”和引用文件路径名。
对于设备文件，其“文件大小”字段显示主、次设备号，而不是文件大小。
目录中的总块数显示在长格式列表的开头，其中包含间接块。
- L 若指定的名称为一个符号链接文件，则显示链接所指向的文件。
- m 输出按字符流格式，文件跨页显示，以逗号分开。
- n 输出格式与l选项相同，只不过在输出中文件属主和属组是用相应的UID号和 GID号来表示，而不是实际的名称。
- o 与l选项相同，只是不显示拥有者信息。
- p 在目录后面加一个“/”。
- q 将文件名中的不可显示字符用“?”代替。
- r 按字母逆序或最早优先的顺序显示输出结果。
- R 递归式地显示指定目录的各个子目录中的文件。
- s 给出每个目录项所用的块数，包括间接块。
- t 显示时按修改时间（最近优先）而不是按名字排序。若文件修改时间相同，则 按字典顺序。修改时间取决于是否使用了c或u选顶。缺省的时间标记是最后一次修 改时间。
- u 显示时按文件上次存取的时间（最近优先）而不是按名字排序。即将-t的时间 标记修改为最后一次访问的时间。
- x 按行显示出各排序项的信息。
用ls - l命令显示的信息中，开头是由10个字符构成的字符串，其中第一个字符表示文件类型，它可以是下述类型之一：
- 普通文件
d 目录
l 符号链接
b 块设备文件
c 字符设备文件
后面的9个字符表示文件的访问权限，分为3组，每组3位。
第一组表示文件属主的权限，第二组表示同组用户的权限，第三组表示其他用户的权限。每一组的三个字 符分别表示对文件的读、写和执行权限。
各权限如下所示：
r 读
w 写
x 执行。对于目录，表示进入权限。
s 当文件被执行时，把该文件的UID或GID赋予执行进程的UID（用户ID）或GID（组 ID）。
t 设置标志位（留在内存，不被换出）。如果该文件是目录，在该目录中的文件只能被超级用户、目录拥有者或文件属主删除。如果它是可执行文件，在该文件执行 后，指向其正文段的指针仍留在内存。这样再次执行它时，系统就能更快地装入该文件。

Linux文本处理命令
sort命令

sort命令的功能是对文件中的各行进行排序。sort命令有许多非常实用的选项，这些选项最初是用来对数据库格式的文件内容进行各种排序操作的。实际上，sort命令可以被认为是一个非常强大的数据管理工具，用来管理内容类似数据库记录的文件。
Sort命令将逐行对文件中的内容进行排序，如果两行的首字符相同，该命令将继续比较这两行的下一字符，如果还相同，将继续进行比较。
语法：
sort [选项] 文件
说明：sort命令对指定文件中所有的行进行排序，并将结果显示在标准输出上。如不指定输入文件或使用“- ”，则表示排序内容来自标准输入。
sort排序是根据从输入行抽取的一个或多个关键字进行比较来完成的。排序关键字定义了用来排序的最小的字符序列。缺省情况下以整行为关键字按ASCII字符顺序进行排序。
改变缺省设置的选项主要有：
- m 若给定文件已排好序，合并文件。
- c 检查给定文件是否已排好序，如果它们没有都排好序，则打印一个出错信息，并以状态值1退出。
- u 对排序后认为相同的行只留其中一行。
- o 输出文件 将排序输出写到输出文件中而不是标准输出，如果输出文件是输入文件之一，sort先将该文件的内容写入一个临时文件，然后再排序和写输出结果。
改变缺省排序规则的选项主要有：
- d 按字典顺序排序，比较时仅字母、数字、空格和制表符有意义。
- f 将小写字母与大写字母同等对待。
- I 忽略非打印字符。
- M 作为月份比较：“JAN”<“FEB”
- r 按逆序输出排序结果。
＋posl - pos2 指定一个或几个字段作为排序关键字，字段位置从posl开始，到pos2为止（包括posl，不包括pos2）。如不指定pos2，则关键字为从posl到行尾。字段和字符的位置从0开始。
- b 在每行中寻找排序关键字时忽略前导的空白（空格和制表符）。
- t separator 指定字符separator作为字段分隔符。

uniq命令

文件经过处理后在它的输出文件中可能会出现重复的行。例如，使用cat命令将两个文件合并后，再使用sort命令进行排序，就可能出现重复行。这时可以使用uniq命令将这些重复行从输出文件中删除，只留下每条记录的唯一样本。
语法：
uniq [选项] 文件
说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如果输入文件用“- ”表示，则从标准输入读取。
该命令各选项含义如下：
- c 显示输出中，在每行行首加上本行在文件中出现的次数。它可取代- u和- d选项。
- d 只显示重复行。
- u 只显示文件中不重复的各行。
- n 前n个字段与每个字段前的空白一起被忽略。一个字段是一个非空格、非制表符的字符串，彼此由制表符和空格隔开（字段从0开始编号）。
+n 前n个字符被忽略，之前的字符被跳过（字符从0开始编号）。
- f n 与- n相同，这里n是字段数。
- s n 与＋n相同，这里n是字符数。

Linux备份与压缩命令
tar命令

tar可以为文件和目录创建档案。利用tar，用户可以为某一特定文件创建档案（备份文件），也可以在档案中改变文件，或者向档案中加入新的文件。 tar最初被用来在磁带上创建档案，现在，用户可以在任何设备上创建档案，如软盘。利用tar命令，可以把一大堆的文件和目录全部打包成一个文件，这对于 备份文件或将几个文件组合成为一个文件以便于网络传输是非常有用的。Linux上的tar是GNU版本的。
语法：tar [主选项+辅选项] 文件或者目录
使用该命令时，主选项是必须要有的，它告诉tar要做什么事情，辅选项是辅助使用的，可以选用。
主选项：
c 创建新的档案文件。如果用户想备份一个目录或是一些文件，就要选择这个选项。
r 把要存档的文件追加到档案文件的未尾。例如用户已经作好备份文件，又发现还有一个目录或是一些文件忘记备份了，这时可以使用该选项，将忘记的目录或文件追加到备份文件中。
t 列出档案文件的内容，查看已经备份了哪些文件。
u 更新文件。就是说，用新增的文件取代原备份文件，如果在备份文件中找不到要更新的文件，则把它追加到备份文件的最后。
x 从档案文件中释放文件。
辅助选项：
b 该选项是为磁带机设定的。其后跟一数字，用来说明区块的大小，系统预设值为20（20*512 bytes）。
f 使用档案文件或设备，这个选项通常是必选的。
k 保存已经存在的文件。例如我们把某个文件还原，在还原的过程中，遇到相同的文件，不会进行覆盖。
m 在还原文件时，把所有文件的修改时间设定为现在。
M 创建多卷的档案文件，以便在几个磁盘中存放。
v 详细报告tar处理的文件信息。如无此选项，tar不报告文件信息。
w 每一步都要求确认。
z 用gzip来压缩/解压缩文件，加上该选项后可以将档案文件进行压缩，但还原时也一定要使用该选项进行解压缩。

gzip命令

减少文件大小有两个明显的好处，一是可以减少存储空间，二是通过网络传输文件时，可以减少传输的时间。gzip是在Linux系统中经常使用的一个对文件进行压缩和解压缩的命令，既方便又好用。
语法：gzip [选项] 压缩（解压缩）的文件名
各选项的含义：
-c 将输出写到标准输出上，并保留原有文件。
-d 将压缩文件解压。
-l 对每个压缩文件，显示下列字段：
压缩文件的大小
未压缩文件的大小
压缩比
未压缩文件的名字
-r 递归式地查找指定目录并压缩其中的所有文件或者是解压缩。
-t 测试，检查压缩文件是否完整。
-v 对每一个压缩和解压的文件，显示文件名和压缩比。
-num 用指定的数字num调整压缩的速度，-1或--fast表示最快压缩方法（低压缩比），-9或--best表示最慢压缩方法（高压缩比）。系统缺省值为6。

unzip命令

用MS Windows下的压缩软件winzip压缩的文件如何在Linux系统下展开呢？可以用unzip命令，该命令用于解扩展名为.zip的压缩文件。
语法：unzip [选项] 压缩文件名.zip
各选项的含义分别为：
-x 文件列表 解压缩文件，但不包括指定的file文件。
-v 查看压缩文件目录，但不解压。
-t 测试文件有无损坏，但不解压。
-d 目录 把压缩文件解到指定目录下。
-z 只显示压缩文件的注解。
-n 不覆盖已经存在的文件。
-o 覆盖已存在的文件且不要求用户确认。
-j 不重建文档的目录结构，把所有文件解压到同一目录下。

在Linux环境下运行DOS命令　 　
Linux系统提供了一组称为mtools的可移植工具，可以让用户轻松地从标准的DOS软盘上读、写文件和目录。它们对DOS和Linux环境之间交换 文件非常有用。它们是不具备共同的文件系统格式的系统之间交换文件的有力手段。对于一个MSDOS的软盘，只要把软盘放在软驱中，就可以利用 mtools提供的命令来访问软盘上的文件。
mtools的主要命令如下：
mcd 目录名 改变MSDOS目录；
mcopy 源文件 目标文件 在MSDOS和Unix之间复制文件；
mdel 文件名 删除MSDOS文件；
mdir 目录名 显示MSDOS目录；
mformat 驱动器号 在低级格式化的软盘上创建MSDOS文件系统；
rnlabel 驱动器号 产生MSDOS卷标；
mmd 目录名 建立MSDOS目录；
mrd 目录名 删除MSDOS目录；
mren 源文件 目标文件 重新命名已存在的MSDOS文件；
mtype 文件名 显示MSDOS文件的内容。
提示：这些命令和对应的MSDOS命令非常相似。

Linux改变文件或目录的访问权限命令
Linux系统中的每个文件和目录都有访问许可权限，用它来确定谁可以通过何种方式对文件和目录进行访问和操作。
文件或目录的访问权限分为只读，只写和可执行三种。以文件为例，只读权限表示只允许读其内容，而禁止对其做任何的更改操作。可执行权限表示允许将该文件作 为一个程序执行。文件被创建时，文件所有者自动拥有对该文件的读、写和可执行权限，以便于对文件的阅读和修改。用户也可根据需要把访问权限设置为需要的任 何组合。
有三种不同类型的用户可对文件或目录进行访问：文件所有者，同组用户、其他用户。所有者一般是文件的创建者。所有者可以允许同组用户有权访问文件，还可以将文件的访问权限赋予系统中的其他用户。在这种情况下，系统中每一位用户都能访问该用户拥有的文件或目录。
每一文件或目录的访问权限都有三组，每组用三位表示，分别为文件属主的读、写和执行权限；与属主同组的用户的读、写和执行权限；系统中其他用户的读、写和执行权限。当用ls -l命令显示文件或目录的详细信息时，最左边的一列为文件的访问权限。例如：
$ ls -l sobsrc. tgz
-rw-r--r-- 1 root root 483997 Ju1 l5 17:3l sobsrc. tgz
横线代表空许可。r代表只读，w代表写，x代表可执行。注意这里共有10个位置。第一个字符指定了文件类型。在通常意义上，一个目录也是一个文件。如果第一个字符是横线，表示是一个非目录的文件。如果是d，表示是一个目录。
例如：

- rw- r-- r--
普通文件 文件主 组用户 其他用户
是文件sobsrc.tgz 的访问权限，表示sobsrc.tgz是一个普通文件；sobsrc.tgz的属主有读写权限；与sobsrc.tgz属主同组的用户只有读权限；其他用户也只有读权限。
确定了一个文件的访问权限后，用户可以利用Linux系统提供的chmod命令来重新设定不同的访问权限。也可以利用chown命令来更改某个文件或目录的所有者。利用chgrp命令来更改某个文件或目录的用户组。
下面分别对这些命令加以介绍。

chmod 命令

chmod命令是非常重要的，用于改变文件或目录的访问权限。用户用它控制文件或目录的访问权限。
该命令有两种用法。一种是包含字母和操作符表达式的文字设定法；另一种是包含数字的数字设定法。

1. 文字设定法
chmod [who] [+ | - | =] [mode] 文件名?
命令中各选项的含义为：
操作对象who可是下述字母中的任一个或者它们的组合：
u 表示“用户（user）”，即文件或目录的所有者。
g 表示“同组（group）用户”，即与文件属主有相同组ID的所有用户。
o 表示“其他（others）用户”。
a 表示“所有（all）用户”。它是系统默认值。
操作符号可以是：
+ 添加某个权限。
- 取消某个权限。
= 赋予给定权限并取消其他所有权限（如果有的话）。
设置mode所表示的权限可用下述字母的任意组合：
r 可读。
w 可写。
x 可执行。
X 只有目标文件对某些用户是可执行的或该目标文件是目录时才追加x 属性。
s 在文件执行时把进程的属主或组ID置为该文件的文件属主。方式“u＋s”设置文件的用户ID位，“g＋s”设置组ID位。
t 保存程序的文本到交换设备上。
u 与文件属主拥有一样的权限。
g 与和文件属主同组的用户拥有一样的权限。
o 与其他用户拥有一样的权限。
文件名：以空格分开的要改变权限的文件列表，支持通配符。
在一个命令行中可给出多个权限方式，其间用逗号隔开。例如：chmod g+r，o+r example
使同组和其他用户对文件example 有读权限。

2. 数字设定法
我们必须首先了解用数字表示的属性的含义：0表示没有权限，1表示可执行权限，2表示可写权限，4表示可读权限，然后将其相加。所以数字属性的格式应为3个从0到7的八进制数，其顺序是（u）（g）（o）。
例如，如果想让某个文件的属主有“读/写”二种权限，需要把4（可读）+2（可写）＝6（读/写）。
数字设定法的一般形式为：
chmod [mode] 文件名?

chgrp命令

功能：改变文件或目录所属的组。
语法：chgrp [选项] group filename?
该命令改变指定指定文件所属的用户组。其中group可以是用户组ID，也可以是/etc/group文件中用户组的组名。文件名是以空格分开的要改变属组的文件列表，支持通配符。如果用户不是该文件的属主或超级用户，则不能改变该文件的组。
该命令的各选项含义为：
- R 递归式地改变指定目录及其下的所有子目录和文件的属组。

chown 命令

功能：更改某个文件或目录的属主和属组。这个命令也很常用。例如root用户把自己的一个文件拷贝给用户xu，为了让用户xu能够存取这个文件，root用户应该把这个文件的属主设为xu，否则，用户xu无法存取这个文件。
语法：chown [选项] 用户或组 文件
说明：chown将指定文件的拥有者改为指定的用户或组。用户可以是用户名或用户ID。组可以是组名或组ID。文件是以空格分开的要改变权限的文件列表，支持通配符。
该命令的各选项含义如下：
- R 递归式地改变指定目录及其下的所有子目录和文件的拥有者。
- v 显示chown命令所做的工作。
Linux与用户有关的命令

passwd命令

出于系统安全考虑，Linux系统中的每一个用户除了有其用户名外，还有其对应的用户口令。因此使用useradd命令增加时，还需使用passwd命令为每一位新增加的用户设置口令；用户以后还可以随时用passwd命令改变自己的口令。
该命令的一般格式为： passwd [用户名] 其中用户名为需要修改口令的用户名。只有超级用户可以使用“passwd 用户名”修改其他用户的口令，普通用户只能用不带参数的passwd命令修改自己的口令。
该命令的使用方法如下：
输入
passwd< Enter>；
在（current） UNIX passwd:下输入当前的口令
在new password:提示下输入新的口令（在屏幕上看不到这个口令）：
系统提示再次输入这个新口令。
输入正确后，这个新口令被加密并放入/etc/shdow文件。选取一个不易被破译的口令是很重要的。
选取口令应遵守如下规则：
口令应该至少有六位（最好是八位）字符；
口令应该是大小写字母、标点符号和数字混杂的。
超级用户修改其他用户（xxq）的口令的过程如下，
# passwd root
New UNIX password:
Retype new UNIX password:
passwd: all authentication tokens updated successfully
#

su命令

这个命令非常重要。它可以让一个普通用户拥有超级用户或其他用户的权限，也可以让超级用户以普通用户的身份做一些事情。普通用户使用这个命令时必须有超级用户或其他用户的口令。如要离开当前用户的身份，可以打exit。
该命令的一般形式为： su [选项] [? ] [使用者帐号]
说明：若没有指定使用者帐号，则系统预设值为超级用户root。 该命令中各选项的含义分别为：
? c 执行一个命令后就结束。
? 加了这个减号的目的是使环境变量和欲转换的用户相同。
? m 保留环境变量不变。
password: 【输入超级用户的密码】 　
Linux系统管理命令

wall命令

这个命令的功能是对全部已登录的用户发送信息，用户可以先把要发送的信息写好存入一个文件中，然后输入：
# wall < 文件名
这样就能对所有的用户发送信息了。
在上面的例子中符号“<”表示输入重定向，有关它的含义和用法请参阅第十章的有关内容。 例如：
# wall ‘Thank you!’
Broadcast message from root （tty1） Fri Nov 26 14：15：07 1999…
Thank you!
#
执行以上命令后，用户的屏幕上显示出“Thank you!”信息后，并不出现系统提示符$（#），再次按回车键后，屏幕出现系统提示符。

write命令

write命令的功能是向系统中某一个用户发送信息。 该命令的一般格式为：
write 用户帐号 [终端名称]
例如： $ write Guest hello
此时系统进入发送信息状态，用户可以输入要发送的信息，输入完毕，希望退出发送状态时，按组合键< Ctrl+c>即可。

mesg指令

mesg命令设定是否允许其他用户用write命令给自己发送信息。如果允许别人给自己发送信息，输入命令：
# mesg y
否则，输入：
# mesg n
对于超级用户，系统的默认值为 n；而对于一般用户系统的默认值为y。 如果mesg后不带任何参数，则显示当前的状态是y还是n.。

sync命令

sync命令是在关闭Linux系统时使用的。用户需要注意的是，不能用简单的关闭电源的方法关闭系统，因为Linux象其他Unix系统一样，在内存中 缓存了许多数据，在关闭系统时需要进行内存数据与硬盘数据的同步校验，保证硬盘数据在关闭系统时是最新的，只有这样才能确保数据不会丢失。一般正常的关闭 系统的过程是自动进行这些工作的，在系统运行过程中也会定时做这些工作，不需要用户干预。 sync命令是强制把内存中的数据写回硬盘，以免数据的丢失。用户可以在需要的时候使用此命令。该命令的一般格式为：
sync

shutdown命令

shutdown 命令可以安全地关闭或重启Linux系统，它在系统关闭之前给系统上的所有登录用户提示一条警告信息。该命令还允许用户指定一个时间参数，可以是一个精确 的时间，也可以是从现在开始的一个时间段。精确时间的格式是hh:mm，表示小时和分钟；时间段由“+”和分钟数表示。系统执行该命令后，会自动进行数据 同步的工作。
该命令的一般格式为： shutdown [选项] [时间] [警告信息] 命令中各选项的含义为：
- k 并不真正关机，而只是发出警告信息给所有用户。
- r 关机后立即重新启动。
- h 关机后不重新启动。
- f 快速关机，重启动时跳过fsck。
- n 快速关机，不经过init程序。
- c 取消一个已经运行的shutdown。
需要特别说明的是，该命令只能由超级用户使用。

free命令

free命令的功能是查看当前系统内存的使用情况，它显示系统中剩余及已用的物理内存和交换内存，以及共享内存和被核心使用的缓冲区。
该命令的一般格式为： free [-b | -k | -m] 命令中各选项的含义如下：
-b 以字节为单位显示。
-k 以K字节为单位显示。
-m 以兆字节为单位显示。

uptime命令

uptime命令显示系统已经运行了多长时间，它依次显示下列信息：现在时间、系统已经运行了多长时间、目前有多少登录用户、系统在过去的1分钟、5分钟和15分钟内的平均负载。
该命令的一般格式为： uptime

Linux磁盘管理
df命令

功能：检查文件系统的磁盘空间占用情况。可以利用该命令来获取硬盘被占用了多少空间，目前还剩下多少空间等信息。
语法：df [选项]
说明：df命令可显示所有文件系统对i节点和磁盘块的使用情况。
该命令各个选项的含义如下：
-a 显示所有文件系统的磁盘使用情况，包括0块（block）的文件系统，如/proc文件系统。
-k 以k字节为单位显示。
-i 显示i节点信息，而不是磁盘块。
-t 显示各指定类型的文件系统的磁盘空间使用情况。
-x 列出不是某一指定类型文件系统的磁盘空间使用情况（与t选项相反）。
-T 显示文件系统类型。

du命令

du的英文原义为“disk usage”，含义为显示磁盘空间的使用情况。
功能：统计目录（或文件）所占磁盘空间的大小。
语法：du [选项] [Names…]
说明：该命令逐级进入指定目录的每一个子目录并显示该目录占用文件系统数据块（1024字节）的情况。若没有给出Names，则对当前目录进行统计。
该命令的各个选项含义如下：
-s 对每个Names参数只给出占用的数据块总数。
-a 递归地显示指定目录中各文件及子孙目录中各文件占用的数据块数。若既不指定-s，也不指定-a，则只显示Names中的每一个目录及其中的各子目录所占的磁盘块数。
-b 以字节为单位列出磁盘空间使用情况（系统缺省以k字节为单位）。
-k 以1024字节为单位列出磁盘空间使用情况。
-c 最后再加上一个总计（系统缺省设置）。
-l 计算所有的文件大小，对硬链接文件，则计算多次。
-x 跳过在不同文件系统上的目录不予统计。

dd命令

功能：把指定的输入文件拷贝到指定的输出文件中，并且在拷贝过程中可以进行格式转换。可以用该命令实现DOS下的diskcopy命令的作用。先用dd 命令把软盘上的数据写成硬盘的一个寄存文件，再把这个寄存文件写入第二张软盘上，完成diskcopy的功能。需要注意的是，应该将硬盘上的寄存文件用 rm命令删除掉。系统默认使用标准输入文件和标准输出文件。
语法：dd [选项]
if =输入文件（或设备名称）。
of =输出文件（或设备名称）。
ibs = bytes 一次读取bytes字节，即读入缓冲区的字节数。
skip = blocks 跳过读入缓冲区开头的ibs*blocks块。
obs = bytes 一次写入bytes字节，即写入缓冲区的字节数。
bs = bytes 同时设置读/写缓冲区的字节数（等于设置ibs和obs）。
cbs = byte 一次转换bytes字节。
count=blocks 只拷贝输入的blocks块。
conv = ASCII 把EBCDIC码转换为ASCIl码。
conv = ebcdic 把ASCIl码转换为EBCDIC码。
conv = ibm 把ASCIl码转换为alternate EBCDIC码。
conv = block 把变动位转换成固定字符。
conv = ublock 把固定位转换成变动位。
conv = ucase 把字母由小写转换为大写。
conv = lcase 把字母由大写转换为小写。
conv = notrunc 不截短输出文件。
conv = swab 交换每一对输入字节。
conv = noerror 出错时不停止处理。
conv = sync 把每个输入记录的大小都调到ibs的大小（用NUL填充）。

fdformat 命令

软盘是用户常用的存储介质之一。软盘在使用之前必须先作格式化操作，然后可以用tar、dd、cpio等命令存储数据，也可以在软盘上建立可安装的文件系统。
功能：低级格式化软盘
语法：format [-n] device
说明：该命令的作用是对软盘进行格式化。
-n 软盘格式化后不作检验。
device 指定要进行格式化的设备，通常是下述设备之一：
/dev/fd0d360
/dev/fd0h1200
/dev/fd0D360
/dev/fd0H360
/dev/fd0D720
/dev/fd0H720
/dev/fd0h360
/dev/fd0h720
/dev/fd0H1440

Linux其它命令
echo命令

echo命令的功能是在显示器上显示一段文字，一般起到一个提示的作用。
该命令的一般格式为： echo [ -n ] 字符串
其中选项n表示输出文字后不换行；字符串可以加引号，也可以不加引号。用echo命令输出加引号的字符串时，将字符串原样输出；用echo命令输出不加引号的字符串时，将字符串中的各个单词作为字符串输出，各字符串之间用一个空格分割。

cal命令

cal命令的功能是显示某年某月的日历。
该命令的一般格式为： cal [选项] [月 [年]] 命令中各选项的含义为：
- j 显示出给定月中的每一天是一年中的第几天（从1月1日算起）。
- y 显示出整年的日历。

date命令

date命令的功能是显示和设置系统日期和时间。
该命令的一般格式为： date [选项] 显示时间格式（以+开头，后面接格式）
date 设置时间格式
命令中各选项的含义分别为：
-d datestr, --date datestr 显示由datestr描述的日期
-s datestr, --set datestr 设置datestr 描述的日期
-u, --universal 显示或设置通用时间
时间域
% H 小时（00..23）
% I 小时（01..12）
% k 小时（0..23）
% l 小时（1..12）
% M 分（00..59）
% p 显示出AM或PM
% r 时间（hh：mm：ss AM或PM），12小时
% s 从1970年1月1日00：00：00到目前经历的秒数
% S 秒（00..59）
% T 时间（24小时制）（hh:mm:ss）
% X 显示时间的格式（％H:％M:％S）
% Z 时区 日期域
% a 星期几的简称（ Sun..Sat）
% A 星期几的全称（ Sunday..Saturday）
% b 月的简称（Jan..Dec）
% B 月的全称（January..December）
% c 日期和时间（ Mon Nov 8 14：12：46 CST 1999）
% d 一个月的第几天（01..31）
% D 日期（mm／dd／yy）
% h 和%b选项相同
% j 一年的第几天（001..366）
% m 月（01..12）
% w 一个星期的第几天（0代表星期天）
% W 一年的第几个星期（00..53，星期一为第一天）
% x 显示日期的格式（mm/dd/yy）
% y 年的最后两个数字（ 1999则是99）
% Y 年（例如：1970，1996等）
注意：只有超级用户才有权限使用date命令设置时间，一般用户只能使用date命令显示时间。

clear命令

clear命令的功能是清除屏幕上的信息，它类似于DOS中的 cls命令。清屏后，提示符移动到屏幕左上角。
文章来源于http://www.lupaworld.com

ubuntu中默认的是gnome桌面，也可以为你的程序设置快捷方式。

可以以两种方式生成快捷方式，这里叫做起动器：命令行方式和拖动程序图标的方式。这里以Lumaqq为例说明之。

1.在应用程序菜单中创建起动器：

在命令行中输入如下命令：

sudo gedit /usr/share/applications/LumaQQ.desktop

//sudo是以超级用户权限执行后面命令
//gedit是打开文本编辑器，后面的路径标识要编辑的文件
//在/usr/share/applications目录下可以看到许多*.desktop的文件，都是应用程序的起动器，所以上述命令是为LunaQQ创建一个起动器配置文件。

在打开的窗口中输入如下内容：

[Desktop Entry]
Name=LumaQQ
Comment=QQ Client
Exec=/opt/LumaQQ/lumaqq//这里的路径应该是你的LunaQQ程序的安装路径
Icon=/opt/LumaQQ/QQ.png//同上
Terminal=false
Type=Application
Categories=Application;Network;//这里的内容决定创建出的起动器在应用程序菜单中的位置，按照上面的写法创建的起动器将出现在应用程序－Internet中，以此类推，如果想在应用程序－办公中创建起动器，上述最后一行应该写成：

Categories=Application;Office;

2.在顶部面板中创建起动器（类似windows中的快速启动）：

可以把任意位置的程序图标拖拽到窗口最顶端的顶部面板(Top Panel)上中间的位置，两个起动器分别是命令行终端和LumaQQ的，分别是从应用程序菜单和文件管理器中拖拽到当前位置的，在这个顶部面板中还可以 添加许多给定的起动器，方法是在顶部面板中右键单击选择添加到面板，可以看到许多内容。

3.在桌面创建起动器

方法同2类似，只需简单拖拽即可。（LumaQQ在桌面上的大图标好可爱！）

有些文档或许会提到995，465等端口号，根据我设置的实验来看不设置端口号也可以。

一．配置

1）framework下的entity里的config里面打开entityengine.xml文件，在此文件里找有四行都是以<delegator name开头的，请将里面的datasource-name="localderby"都改为datasource-name="localmysql"。

2）在此文件里找到〈datasource-name="localmysql"开头的代码区域，将里面的jdbc-username= 和jdbc-password= 都改为你安装mysql时的用户名和密码。

3）我们要在entity下的lib下的jdbc中导入mysql5.0的驱动，同时加入xapool.jar。

    4)在mysql中建ofbiz数据库，否则在下面部署工程中报错

    二．部署

    1) 在命令行下运行 ant run-install

        (前提：在环境变量中添加 ant\bin)

2) 运行 startofbiz.bat

 

三. 工程端口号的修改

  修改framework/base/config/ofbiz-containers.xml

1）  修改ofbiz端口号

    <property name="http-connector" value="connector">

            <property name="port" value="8080"/>

      </property>

 

  2)修改项目链接的端口号

<property name="https-connector" value="connector">

          <property name="port" value="8443"/>

 </property>

 

四．运行

 在浏览器中输入地址 http://localhost:8080

 

1.实体引擎核心应用类（客户端API）
涉及到12 个类：GenericDelegator，GenericValue，GenericPK，EntityCondition，
EntityExpr，EntityFieldMap，EntityConditionList，EntityWhereString，EntityOperator，
EntityListIterator，这些类都是为GenericDelegator 的接口服务的。用
户端程序和数据库之间的所有交往多是通过“GenericDelegator”完成的。

2.服务引擎应用类（服务器端API）
涉及LocalDispatcher， GenericDispatcher； ServiceDispatcher；ServiceUtil；
DispatchContext ；ServiceConfigUtil 等6 个类。

3.常用工具类
工具类主要在包org.ofbiz.core.util 中。
1、 属性文件访问工具类：UtilProperties。
2、 Map、List 对象操作工具类：UtilMisc。
3、 UtilFormatOut ：通用格式化输出工具类（主要用在 Jsp 文件或View Helper 中）。
4、 UtilURL：得到文件流的URL 地址类。
5、 UtilCache：缓存管理类。
6、 UtilValidate：通用数据输入输出数据校验（合法性和有效性）类，可任意扩展。.
7、 UtilDateTime：java.util.Date 和java.sql.Date 格式的日期/时间处理类。
8、 StringUtil：增强的字符串处理类。
9、 UtilXML：增强的符合JAXP & DOM 规范的XMl 解析器处理工具类。
10、 SiteDefs：常数定义类，定义所有Web 程序用到的和环境有关的常量。
11、 Debug：格式化输出程序调试信息类。
12、 HttpClient：模拟一个HttpServlet 请求类。
13、 HttpRequestFileUpload：接受一个通过Http 上传的文件工具类。
14、 SendMailSMTP：符合SMTP 协议的邮件发送处理类（实现发送邮件服务器的功能）。

1. entitymodle.xml中的字段类型参见 opentaps-1.0\framework\entity\fieldtype
     比较常见的字段类型定义如下：
         <field-type-def type="id-ne" sql-type="VARCHAR(20)" java-type="String">
                    <validate method="isNotEmpty" />
        </field-type-def>
         <field-type-def type="id" sql-type="VARCHAR(20)" java-type="String"></field-type-def>
         <field-type-def type="comment" sql-type="VARCHAR(255)" java-type="String"></field-type-def>
        <field-type-def type="description" sql-type="VARCHAR(255)" java-type="String"></field-type-def>
        <field-type-def type="name" sql-type="VARCHAR(100)" java-type="String"></field-type-def>
        <field-type-def type="value" sql-type="VARCHAR(255)" java-type="String"></field-type-def>

entity

Attribute Name	Required?	Description
entity-name	Y	The name of the entity as it is referred to when using the Entity Engine Java API and various other places in the Entity Engine.
table-name	N	The name of the database table that corresponds to this entity. This attribute is optional and if not specified the table name will be derived from the entity name.
package-name	Y	The name of the package that this entity is contained in. With hundreds of entities in a large data model this is used to organize and structure the entities definitions.
dependent-on	N	This can be used to specify a parent entity or an entity that this entity is dependent on. This is currently not used for anything automated in the Entity Engine, but can be used to specify an heirarchical entity structure.
enable-lock	N	Specifies whether or not optimistic locking should be used for this entity. The lastUpdatedStamp field must exist on the entity and will be used to keep track of the last time the entity instance was updated. If the current instance to be updated does not have a matching lastUpdatedStamp an EntityLockedException will be thrown. Must be true or false. Defaults to false.
never-cache	N	If this is set to true caching of this entity will not be allowed. Automatic cache clearing will not be done to improve efficiency and any attempt to use the cache methods on the entity will result in an exception so that it is easier to find and eliminate where this is being done. Must be true or false. Defaults to false.
title	N	A title for the entity. If not specified defaults to the global setting for the file the entity is in.
copyright	N	The copyright of the entity. If not specified defaults to the global setting for the file the entity is in.
author	N	The author of the entity. If not specified defaults to the global setting for the file the entity is in.
version	N	The version of the entity. If not specified defaults to the global setting for the file the entity is in.

Sub-Element Name	How Many	Description
description	0 or 1	A description of the entity. If not specified defaults to the global setting for the file the entity is in. This element has no attributes and should contain only a simple string of characters.
field	1 to many	Used to declare fields that are part of the entity.
prim-key	0 to many	Used to declare which fields are primary keys
relation	0 to many	Used to declare relationships between entities.

field

Attribute Name	Required?	Description
name	Y	The name of the field that is used to refer to it in Java code and other places.
col-name	N	The name of the corresponding database column. This is not required and if not specified this will be derived from the field name.
type	Y	The type of the field. This is looked up in the field types file for the current datasource at run-time to determine the Java and SQL types for the field and database column.

Sub-Element Name	How Many	Description
validate	0 to many	Each validate element has a single attribute called name which specifies the name of the validation method to call. These methods are not called in all Entity Engine operations and are only used for generic user interfaces like the Entity Data Maintenance pages in WebTools.

prim-key

Attribute Name	Required?	Description
field	Y	The name of the field that will be part of the primary key.

relation

Attribute Name	Required?	Description
type	Y	Specifies the type of the relationship including the cardinality of the relationship (in one direction) and if a foreign key should be created for cardinality one relationships. Must be "one", "one-nofk", or "many".
title	N	Because you may want to have more than one relationship to a single entity this attribute allows you to specify a title that will be prepended to the rel-entity-name to make up the name of the relationship. If not specified the rel-entity-name alone will be used as the relationship name.
rel-entity-name	Y	The name of the related entity. The relationship goes from this entity to the related entity.
fk-name	N	The foreign key name can be created automatically from the relationship name, but this is not recommended for two reasons: many databases have a very small maximum size (like 18 characters) for foreign key and index names, and many databases require that the FK name be unique for the entire database and not just for the table the FK is coming from.

Sub-Element Name	How Many	Description
key-map	1 to many	The key-map is used to specify a field in this entity that corresponds to a field in the related entity. This element has two attributes: field-name and rel-field-name. These are used to specify the name of the field on this entity and the corresponding name of the field on the related entity.

更加详细的内容参照： http://ofbiz.apache.org/docs/entity.html

1.将Opentaps项目导入Eclipse中
    Filee -> Import -> General -> Existing Projects into Workspace
2.Eclipse中为.bsh,.ftl文件添加编辑器
  安装Freemarker Eclipse plug-in.
  Windows > Preferences > General > Editors > File Associations and add "*.bsh" and associate it with the Scrapbook editor.
3.修改 startofbiz.bat文件

ECHO OFF
REM ####################################################
REM Licensed to the Apache Software Foundation (ASF) under one
REM or more contributor license agreements.  See the NOTICE file
REM distributed with this work for additional information
REM regarding copyright ownership.  The ASF licenses this file
REM to you under the Apache License, Version 2.0 (the
REM "License"); you may not use this file except in compliance
REM with the License.  You may obtain a copy of the License at
REM
REM http://www.apache.org/licenses/LICENSE-2.0
REM
REM Unless required by applicable law or agreed to in writing,
REM software distributed under the License is distributed on an
REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
REM KIND, either express or implied.  See the License for the
REM specific language governing permissions and limitations
REM under the License.
REM ########################################################
ECHO ON

"%JAVA_HOME%\bin\java" -Xms256M -Xmx512M -Duser.language=en -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005 -jar ofbiz.jar > runtime\logs\console.log

4.Eclipse菜单 Run -> Open Debug Dialog
   选择 Remote Java Application 
    注意: 右侧面板中的 Port 为上面红色标记，两者必需一致。

1.OfBiz中利用delegator访问数据库

1)创建GenericDelegator对象
  1.1 service中
  public static Map createHelloPerson(DispatchContext dctx, Map context) {
          GenericDelegator delegator = dctx.getDelegator();
     ...
  }
  1.2手工建立GenericDelegator对象
  GenericDelegator delegator = GenericDelegator.getGenericDelegator("default");

2)Insert a record
  通过调用delegator对象的getNextSeqId(), makeValue(String entityName, Map fields)和create()方法。
  例如：
       String helloPersonId = delegator.getNextSeqId("HelloPerson");
    GenericValue helloPerson = delegator.makeValue("HelloPerson",
                    UtilMisc.toMap("helloPersonId", helloPersonId)); // create a GenericValue from ID we just got
      helloPerson.setNonPKFields(context); // move non-primary key fields from input parameters to GenericValue
    delegator.create(helloPerson); // store the generic value, ie persists it
   
3)Remove a record
    delegator.removeByAnd(String entityName, Map fields);
   
4)Strore a record
    例如：
      Map pk = UtilMisc.toMap("attribute1", attribute1Value, "attribute2", attribute2Value);//pk中存储了查询条件
    GenericValue obj = delegator.findByPrimaryKey("ClassName", pk);
      obj.setNonPKFields(context);//contex为Map类型，存储了要更新的字段
    obj.store();

5)Store records
    List resultList = delegator.findAll(String entityName, List orderBy);
    List toStore = new ArrayList();
    toStore.addAll(resultList);
    delegator.storeAll(toStore);
   
6)Look for record/records
     findByAnd，findByCondition、findByLike、findByOr、findByPrimaryKey、
     findListIteratorByCondition、 findall、findAllByPrimaryKeys
    
2) 依据数值对象进行访问
    在现有的数值对象(GenericValue类型)上可以进行下列操作：
        根据关系查找关联信息getRelated，包括getRelated、getRelatedByAnd、getRelatedDummyPK、getRelatedMulti、getRelatedOrderBy。
        刷新本数值对象refresh
        保存本数值对象store，主要用于修改后的保存
        删除数值对象remove,包括删除本数值对象remove和删除某个关联的数值对象removeRelated
        在现有数值对象上的操作是通过调用
   
    更加具体的信息可参考：http://www.opentaps.org/javadocs/release-1.0.1/framework/api/

http://www.opensourcestrategies.com/ofbiz/tutorials.php
http://ofbiz.apache.org/
http://www.opentaps.org/index.php
http://docs.ofbiz.org/display/OFBADMIN/OFBiz+Documentation+Index
尤其是第一个里面有很多不错的文章，不过都是英文的，耐心的看下去吧。

      Java语言中的equals的规范：

          1． 自反性：对于任何一个非空引用x，x.equals(x)应该返回true；
    2． 对称性：对于任何引用x和y，如果x.equals(y)返回true，那么y.equals(x)也应该返回true。
    3． 传递性：对于任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true。
    4． 一致性：如果x和y引用的对象没有发生变化，那么反复调用x.equals(y)应该返回同样的结果。
    5． 对于任何非空引用x，x.equals(null)应该返回false。

 public boolean equals(Object obj) {
  boolean result = false;
  if (this == obj)
   return true;
  if (!(obj instanceof Student))
   return false;
  Student objTemp = (Student) obj;
  if (this.getId() == objTemp.getId())
   result = true;
  return result;
 }

Java语言中的hashcode：

  1. 将一个非0常数，例如17，储存于int result变量中。
  2. 对对象中的每一个有意义的字段f（更确切地说是被equals()所考虑的每一个字段）进行如下处理：
    A. 对这个字段计算出型别为int的hash 码 c：
      i. 如果字段是个boolean，计算(f ? 0 : 1)。
      ii. 如果字段是个byte,char,short或int，计算(int)f。
      iii. 如果字段是个long，计算(int)(f^(f >>> 32))。
      iv. 如果字段是个float，计算Float.floatToIntBits(f)。
      v. 如果字段是个double，计算Double.doubleToLongBits(f)，然后将计算结果按步骤2.A.iii处理。
      vi. 如果字段是个object reference，而且class 的equals()透过「递归呼叫equals()」的方式来比较这一字段，那么就同样也对该字段递归呼叫hashCode()。
      vii. 如果字段是个array，请将每个元素视为独立字段。也就是说对每一个有意义的元素施行上述规则，用以计算出hash 码，然后再依步骤2.B将这些数值组合起来。
    B. 将步骤A计算出来的hash码 c按下列公式组合到变量result中：result = 37*result + c;
 3. 传回result。
 4. 完成hashCode()之后，反躬自省一下：是否相等的实体具有相等的hash 码？如果不是，找出原因并修正问题。

     摘要: 前人栽树，后人乘凉。想当初自己初学Java时为了解决一个很基础的问题，好多的朋友热心的回复我，帮我分析错误。现在为了方便那些Java新手，特给出自己感觉比较好的学习网站和论坛，希望对朋友们能有点帮助。
1,http://www.javaeye.com/ 由Robbin创建发起的技术网站，人气相当旺，有不少牛人。最初是以讨论Java技 术和Hibernate技术开始的技术论坛，现在已经成为一个涵盖整个软件开发领域的综合性网站，2005年被选为中国十佳技术网站之一。
2,http://www.ibm.com/developerworks/cn/java/ 著名的IBM Developer Works。涵盖各种技术。
3,http://dev2dev.bea.com.cn/ IBM和BEA都在主推Java应用。它们的技术网站中有不少关于Java的好文章。
………………  阅读全文


文章来源:http://www.blogjava.net/creasure/archive/2008/07/08/213420.html

Eclipse 常用快捷键
Eclipse的编辑功能非常强大，掌握了Eclipse快捷键功能，能够大大提高开发效率。Eclipse中有如下一些和编辑相关的快捷键。
   1. 【ALT+/】
   此快捷键为用户编辑的好帮手，能为用户提供内容的辅助，不要为记不全方法和属性名称犯愁，当记不全类、方法和属性的名字时，多体验一下【ALT+/】快捷键带来的好处吧。
   2. 【Ctrl+O】
   显示类中方法和属性的大纲，能快速定位类的方法和属性，在查找Bug时非常有用。

   3. 【Ctrl+/】
   快速添加注释，能为光标所在行或所选定行快速添加注释或取消注释，在调试的时候可能总会需要注释一些东西或取消注释，现在好了，不需要每行进行重复的注释。

   4. 【Ctrl+D】
   删除当前行，这也是笔者的最爱之一，不用为删除一行而按那么多次的删除键。

   5. 【Ctrl+M】
   窗口最大化和还原，用户在窗口中进行操作时，总会觉得当前窗口小（尤其在编写代码时），现在好了，试试【Ctrl+M】快捷键。

   查看和定位快捷键

   在程序中，迅速定位代码的位置，快速找到Bug的所在，是非常不容易的事，Eclipse提供了强大的查找功能，可以利用如下的快捷键帮助完成查找定位的工作。

   1. 【Ctrl+K】、【Ctrl++Shift+K】
   快速向下和向上查找选定的内容，从此不再需要用鼠标单击查找对话框了。

   2. 【Ctrl+Shift+T】
   查找工作空间（Workspace）构建路径中的可找到Java类文件，不要为找不到类而痛苦，而且可以使用“*”、“？”等通配符。

   3. 【Ctrl+Shift+R】
   和【Ctrl+Shift+T】对应，查找工作空间（Workspace）中的所有文件（包括Java文件），也可以使用通配符。

   4. 【Ctrl+Shift+G】
   查找类、方法和属性的引用。这是一个非常实用的快捷键，例如要修改引用某个方法的代码，可以通过【Ctrl+Shift+G】快捷键迅速定位所有引用此方法的位置。

   5. 【Ctrl+Shift+O】
快速生成import，当从网上拷贝一段程序后，不知道如何import进所调用的类，试试【Ctrl+Shift+O】快捷键，一定会有惊喜。

   6. 【Ctrl+Shift+F】
   格式化代码，书写格式规范的代码是每一个程序员的必修之课，当看见某段代码极不顺眼时，选定后按【Ctrl+Shift+F】快捷键可以格式化这段代码，如果不选定代码则默认格式化当前文件（Java文件）。

   7. 【ALT+Shift+W】
   查找当前文件所在项目中的路径，可以快速定位浏览器视图的位置，如果想查找某个文件所在的包时，此快捷键非常有用（特别在比较大的项目中）。

   8. 【Ctrl+L】
   定位到当前编辑器的某一行，对非Java文件也有效。

   9. 【Alt+←】、【Alt+→】
   后退历史记录和前进历史记录，在跟踪代码时非常有用，用户可能查找了几个有关联的地方，但可能记不清楚了，可以通过这两个快捷键定位查找的顺序。

   10. 【F3】
快速定位光标位置的某个类、方法和属性。

   11. 【F4】
   显示类的继承关系，并打开类继承视图。

   调试快捷键

   Eclipse中有如下一些和运行调试相关的快捷键。

   1. 【Ctrl+Shift+B】：在当前行设置断点或取消设置的断点。
   2. 【F11】：调试最后一次执行的程序。
   3. 【Ctrl+F11】：运行最后一次执行的程序。
   4. 【F5】：跟踪到方法中，当程序执行到某方法时，可以按【F5】键跟踪到方法中。
   5. 【F6】：单步执行程序。
   6. 【F7】：执行完方法，返回到调用此方法的后一条语句。
   7. 【F8】：继续执行，到下一个断点或程序结束。

   常用编辑器快捷键

   通常文本编辑器都提供了一些和编辑相关的快捷键，在Eclipse中也可以通过这些快捷键进行文本编辑。
   1. 【Ctrl+C】：复制。
   2. 【Ctrl+X】：剪切。
   3. 【Ctrl+V】：粘贴。
   4. 【Ctrl+S】：保存文件。
   5. 【Ctrl+Z】：撤销。
   6. 【Ctrl+Y】：重复。
   7. 【Ctrl+F】：查找。

   其他快捷键

   Eclipse中还有很多快捷键，无法一一列举，用户可以通过帮助文档找到它们的使用方式，另外还有几个常用的快捷键如下。
   1. 【Ctrl+F6】：切换到下一个编辑器。
   2. 【Ctrl+Shift+F6】：切换到上一个编辑器。
   3. 【Ctrl+F7】：切换到下一个视图。
   4. 【Ctrl+Shift+F7】：切换到上一个视图。
   5. 【Ctrl+F8】：切换到下一个透视图。
   6. 【Ctrl+Shift+F8】：切换到上一个透视图。

   Eclipse中快捷键比较多，可以通过帮助文档找到所有快捷键的使用，但要掌握所有快捷键的使用是不可能的，也没有必要，如果花点时间熟悉本节列举的快捷键，必将会事半功倍

     摘要: 速动画教程第二十七集  SVN的安装和配置 下载：请到 http://this.oksonic.cn 下载  工具：...  阅读全文


文章来源:http://www.blogjava.net/oksonic/archive/2007/02/10/99100.html

     摘要: 速动画教程第二十五集  使用 xfire 开发 web service 应用   下载地址： http://this.oksonic.cn ...  阅读全文


文章来源:http://www.blogjava.net/oksonic/archive/2006/07/19/59069.html

     摘要: 速动画教程第三十集 搭建SSH2的集成开发环境 下载地址：www.oksonic.cn    www.oksonic.com.cn   一．开发环境： 1．  Windows2003 sp1 2．  Eclipse3.2.2 3．  MyEclipse5.1.1 4．  Struts2.0.6 5．&n...  阅读全文


文章来源:http://www.blogjava.net/oksonic/archive/2007/04/28/114363.html

在hibernate中，延迟加载是1个非常大的优点，但有时候却给我们带来一些小麻烦，在后台查询结束后，session已经关闭，但在前台显示的时候，如果存在关联关系就会产生延迟加载异常。
解决办法是客户端每次请求就分配1个session,将请求结果返回给客户端，并完成展现后关闭session。
实现这个功能非常简单，在web.xml中加入以下配置
<filter>
 <filter-name>hibernateFilter</filter-name>
 <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter </filter-class>
<init-param>
     <param-name>singleSession</param-name>
       <param-value>true</param-value>
  </init-param>
</filter>
<filter-mapping>
<filter-name>hibernateFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>

使用spring提供这个过滤器就可以实现session的集中管理了，所有以.do结尾的请求都自动分配了1个session,并且在这个请求过程中都使用这个session.

 

来自：http://springking.javaeye.com/

文章来源:http://www.blogjava.net/beansoft/archive/2008/06/19/209283.html

1.   select * from emp;

    EMPNO ENAME  JOB        MGR HIREDATE     SAL COMM  DEPTNO
    ----- ------ --------- ---- ----------- ---- ---- -------
     7369 SMITH  CLERK     7902 17-DEC-1980  800           20
     7499 ALLEN  SALESMAN  7698 20-FEB-1981 1600  300      30
     7521 WARD   SALESMAN  7698 22-FEB-1981 1250  500      30
     7566 JONES  MANAGER   7839 02-APR-1981 2975           20
     7654 MARTIN SALESMAN  7698 28-SEP-1981 1250 1400      30
     7698 BLAKE  MANAGER   7839 01-MAY-1981 2850           30
     7782 CLARK  MANAGER   7839 09-JUN-1981 2450           10
     7788 SCOTT  ANALYST   7566 09-DEC-1982 3000           20
     7839 KING   PRESIDENT      17-NOV-1981 5000           10
     7844 TURNER SALESMAN  7698 08-SEP-1981 1500    0      30
     7876 ADAMS  CLERK     7788 12-JAN-1983 1100           20
     7900 JAMES  CLERK     7698 03-DEC-1981  950           30
     7902 FORD   ANALYST   7566 03-DEC-1981 3000           20
     7934 MILLER CLERK     7782 23-JAN-1982 1300           10

2.问题：查找DEPTNO 20中出现最多次数的工资？
 select sal
      from emp
     where deptno = 20
     order by sal

           SAL
    ----------
           800
          1100
          2975
          3000
          3000

3.解决方案
使用窗口函数 DENSE_RANK,把工资重复出现的次数分等级。
  1     select sal
  2       from (
  3     select sal,
  4            dense_rank()over( order by cnt desc) as rnk
  5       from (
  6     select sal, count(*) as cnt
  8       from emp
  9      where deptno = 20
 10      group by sal
 11            ) x
 12            ) y
 13      where rnk = 1 

1.ISNULL 判断某一字段是否为空，若为空返回 TRUE，否则返回 FALSE

2.NULLIF（字段名，字段值）若字段名的值为"字段值"，则将该字段值替换成NULL

3.COALESCE(表达式1，表达式2，...表达式n） 从左到右 依次判断表达式的值,返回第一个非空的表达式的值。

有如下的一个表 user(id,name,type) ,dept(id,userid,name)
delete from test where id in (select  u.id from user u inner join dept d on u.id=dept.userid where d.name='技术部');
当在MySql下执行这条查询时，数据库报错:You can't specify target table 'test' for update in FROM clause
查阅资料发现：MySQl下不支持这样的同时有select跟delete/update同一个表的操作。

修改如下：
delete from test where id in (select * from (select  u.id from user u inner join dept d on u.id=dept.userid where d.name='技术部') ta);
Success!!!

Oracle的日期函数:

Oracle从8i开始就提供了大量的日期函数，这些日期函数包括对日期进行加减、转换、截取等功能。下面是Oracle提供的日期函数一览表 

Function	Use
ADD_MONTHS	Adds months to a date
LAST_DAY	Computes the last day of the month
MONTHS_BETWEEN	Determines the number of months between two dates
NEW_TIME	Translates a time to a new time zone
NEXT_DAY	Returns the date of the next specified weekday
ROUND	Rounds a date/time value to a specified element
SYSDATE	Returns the current date and time
TO_CHAR	Converts dates to strings
TO_DATE	Converts strings and numbers to dates
TRUNC	Truncates a date/time value to a specific element

更多详细内容请参考：http://www.blogjava.net/pengpenglin/archive/2008/06/30/211589.html

Oracle分析函数(二)

1.AVG
功能描述：用于计算一个组和数据窗口内表达式的平均值。
SAMPLE：下面的例子中列c_mavg计算员工表中每个员工的平均薪水报告，该平均值由当前员工和与之具有相同经理的前一个和后一个三者的平均数得来；

SELECT manager_id, last_name, hire_date, salary,
AVG(salary) OVER (PARTITION BY manager_id ORDER BY hire_date
ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS c_mavg
FROM employees;

MANAGER_ID LAST_NAME HIRE_DATE SALARY C_MAVG
---------- ------------------------- --------- ---------- ----------
100 Kochhar 21-SEP-89 17000 17000
100 De Haan 13-JAN-93 17000 15000
100 Raphaely 07-DEC-94 11000 11966.6667
100 Kaufling 01-MAY-95 7900 10633.3333
100 Hartstein 17-FEB-96 13000 9633.33333
100 Weiss 18-JUL-96 8000 11666.6667
100 Russell 01-OCT-96 14000 11833.3333

2.COUNT
功能描述：对一组内发生的事情进行累积计数，如果指定*或一些非空常数，count将对所有行计数，如果指定一个表达式，count返回表达式非空赋值的计数，当有相同值出现时，这些相等的值都会被纳入被计算的值；可以使用DISTINCT来记录去掉一组中完全相同的数据后出现的行数。
SAMPLE：下面例子中计算每个员工在按薪水排序中当前行附近薪水在[n-50,n+150]之间的行数，n表示当前行的薪水例如，Philtanker的薪水2200，排在他之前的行中薪水大于等于2200-50的有1行，排在他之后的行中薪水小于等于2200＋150的行没有，所以count计数值cnt3为2（包括自己当前行）；cnt2值相当于小于等于当前行的SALARY值的所有行数

SELECT last_name, salary, COUNT(*) OVER () AS cnt1,
COUNT(*) OVER (ORDER BY salary) AS cnt2,
COUNT(*) OVER (ORDER BY salary RANGE BETWEEN 50 PRECEDING
AND 150 FOLLOWING) AS cnt3 FROM employees;

LAST_NAME SALARY CNT1 CNT2 CNT3
------------------------- ---------- ---------- ---------- ----------
Olson 2100 107 1 3
Markle 2200 107 3 2
Philtanker 2200 107 3 2
Landry 2400 107 5 8
Gee 2400 107 5 8
Colmenares 2500 107 11 10
Patel 2500 107 11 10

3.DENSE_RANK
功能描述：根据ORDER BY子句中表达式的值，从查询返回的每一行，计算它们与其它行的相对位置。组内的数据按ORDER BY子句排序，然后给每一行赋一个号，从而形成一个序列，该序列从1开始，往后累加。每次ORDER BY表达式的值发生变化时，该序列也随之增加。有同样值的行得到同样的数字序号（认为null时相等的）。密集的序列返回的时没有间隔的数
SAMPLE：下例中计算每个员工按部门分区再按薪水排序，依次出现的序列号（注意与RANK函数的区别）

SELECT d.department_id , e.last_name, e.salary, DENSE_RANK()
OVER (PARTITION BY e.department_id ORDER BY e.salary) as drank
FROM employees e, departments d
WHERE e.department_id = d.department_id
AND d.department_id IN ('60', '90');

DEPARTMENT_ID LAST_NAME SALARY DRANK
------------- ------------------------- ---------- ----------
60 Lorentz 4200 1
60 Austin 4800 2
60 Pataballa 4800 2
60 Ernst 6000 3
60 Hunold 9000 4
90 Kochhar 17000 1
90 De Haan 17000 1
90 King 24000 2

 RANK()与DENSE_RANK()用法相当，但是有一个区别：DENSE_RANK在处理相同的等级时，等级的数值不会跳过,RANK()则跳过。

  RANK
功能描述：根据ORDER BY子句中表达式的值，从查询返回的每一行，计算它们与其它行的相对位置。组内的数据按ORDER BY子句排序，然后给每一行赋一个号，从而形成一个序列，该序列从1开始，往后累加。每次ORDER BY表达式的值发生变化时，该序列也随之增加。有同样值的行得到同样的数字序号（认为null时相等的）。然而，如果两行的确得到同样的排序，则序数将随后跳跃。若两行序数为1，则没有序数2，序列将给组中的下一行分配值3，DENSE_RANK则没有任何跳跃。
SAMPLE：下例中计算每个员工按部门分区再按薪水排序，依次出现的序列号（注意与DENSE_RANK函数的区别）

SELECT d.department_id , e.last_name, e.salary, RANK()
OVER (PARTITION BY e.department_id ORDER BY e.salary) as drank
FROM employees e, departments d
WHERE e.department_id = d.department_id
AND d.department_id IN ('60', '90');

DEPARTMENT_ID LAST_NAME SALARY DRANK
------------- ------------------------- ---------- ----------
60 Lorentz 4200 1
60 Austin 4800 2
60 Pataballa 4800 2
60 Ernst 6000 4
60 Hunold 9000 5
90 Kochhar 17000 1
90 De Haan 17000 1
90 King 24000 3

4.FIRST
功能描述：从DENSE_RANK返回的集合中取出排在最前面的一个值的行（可能多行，因为值可能相等），因此完整的语法需要在开始处加上一个集合函数以从中取出记录SAMPLE.
下面例子中DENSE_RANK按部门分区，再按佣金commission_pct排序，FIRST取出佣金最低的对应的所有行，然后前面的MAX函数从这个集合中取出薪水最低的值；LAST取出佣金最高的对应的所有行，然后前面的MIN函数从这个集合中取出薪水最高的值.
SELECT last_name, department_id, salary,
MIN(salary) KEEP (DENSE_RANK FIRST ORDER BY commission_pct)
OVER (PARTITION BY department_id) "Worst",
MAX(salary) KEEP (DENSE_RANK LAST ORDER BY commission_pct)
OVER (PARTITION BY department_id) "Best"
FROM employees
WHERE department_id in (20,80)
ORDER BY department_id, salary;

LAST_NAME DEPARTMENT_ID SALARY Worst Best
------------------------- ------------- ---------- ---------- ----------
Fay 20 6000 6000 13000
Hartstein 20 13000 6000 13000
Kumar 80 6100 6100 14000
Banda 80 6200 6100 14000
Johnson 80 6200 6100 14000
Ande 80 6400 6100 14000
Lee 80 6800 6100 14000
Tuvault 80 7000 6100 14000
Sewall 80 7000 6100 14000
Marvins 80 7200 6100 14000
Bates 80 7300 6100 14000

5.FIRST_VALUE
功能描述：返回组中数据窗口的第一个值。
SAMPLE：下面例子计算按部门分区按薪水排序的数据窗口的第一个值对应的名字，如果薪水的第一个值有多个，则从多个对应的名字中取缺省排序的第一个名字

SELECT department_id, last_name, salary, FIRST_VALUE(last_name)
OVER (PARTITION BY department_id ORDER BY salary ASC ) AS lowest_sal
FROM employees
WHERE department_id in(20,30);

DEPARTMENT_ID LAST_NAME SALARY LOWEST_SAL
------------- ------------------------- ---------- --------------
20 Fay 6000 Fay
20 Hartstein 13000 Fay
30 Colmenares 2500 Colmenares
30 Himuro 2600 Colmenares
30 Tobias 2800 Colmenares
30 Baida 2900 Colmenares
30 Khoo 3100 Colmenares
30 Raphaely 11000 Colmenares

6.LAST
功能描述：从DENSE_RANK返回的集合中取出排在最后面的一个值的行（可能多行，因为值可能相等），因此完整的语法需要在开始处加上一个集合函数以从中取出记录
SAMPLE：下面例子中DENSE_RANK按部门分区，再按佣金commission_pct排序，FIRST取出佣金最低的对应的所有行，然后前面的MAX函数从这个集合中取出薪水最低的值；LAST取出佣金最高的对应的所有行，然后前面的MIN函数从这个集合中取出薪水最高的值
SELECT last_name, department_id, salary,
MIN(salary) KEEP (DENSE_RANK FIRST ORDER BY commission_pct)
OVER (PARTITION BY department_id) "Worst",
MAX(salary) KEEP (DENSE_RANK LAST ORDER BY commission_pct)
OVER (PARTITION BY department_id) "Best"
FROM employees
WHERE department_id in (20,80)
ORDER BY department_id, salary;

LAST_NAME DEPARTMENT_ID SALARY Worst Best
------------------------- ------------- ---------- ---------- ----------
Fay 20 6000 6000 13000
Hartstein 20 13000 6000 13000
Kumar 80 6100 6100 14000
Banda 80 6200 6100 14000
Johnson 80 6200 6100 14000
Ande 80 6400 6100 14000
Lee 80 6800 6100 14000
Tuvault 80 7000 6100 14000
Sewall 80 7000 6100 14000
Marvins 80 7200 6100 14000
Bates 80 7300 6100 14000

7.LAST_VALUE
功能描述：返回组中数据窗口的最后一个值。
SAMPLE：下面例子计算按部门分区按薪水排序的数据窗口的最后一个值对应的名字，如果薪水的最后一个值有多个，则从多个对应的名字中取缺省排序的最后一个名字
SELECT department_id, last_name, salary, LAST_VALUE(last_name)
OVER(PARTITION BY department_id ORDER BY salary) AS highest_sal
FROM employees
WHERE department_id in(20,30);

DEPARTMENT_ID LAST_NAME SALARY HIGHEST_SAL
------------- ------------------------- ---------- ------------
20 Fay 6000 Fay
20 Hartstein 13000 Hartstein
30 Colmenares 2500 Colmenares
30 Himuro 2600 Himuro
30 Tobias 2800 Tobias
30 Baida 2900 Baida
30 Khoo 3100 Khoo
30 Raphaely 11000 Raphaely

8.LAG
功能描述：可以访问结果集中的其它行而不用进行自连接。它允许去处理游标，就好像游标是一个数组一样。在给定组中可参考当前行之前的行，这样就可以从组中与当前行一起选择以前的行。Offset是一个正整数，其默认值为1，若索引超出窗口的范围，就返回默认值（默认返回的是组中第一行），其相反的函数是LEAD
SAMPLE：下面的例子中列prev_sal返回按hire_date排序的前1行的salary值

SELECT last_name, hire_date, salary,
LAG(salary, 1, 0) OVER (ORDER BY hire_date) AS prev_sal
FROM employees
WHERE job_id = 'PU_CLERK';

LAST_NAME HIRE_DATE SALARY PREV_SAL
------------------------- ---------- ---------- ----------
Khoo 18-5月 -95 3100 0
Tobias 24-7月 -97 2800 3100
Baida 24-12月-97 2900 2800
Himuro 15-11月-98 2600 2900
Colmenares 10-8月 -99 2500 2600

9.LEAD
功能描述：LEAD与LAG相反，LEAD可以访问组中当前行之后的行。Offset是一个正整数，其默认值为1，若索引超出窗口的范围，就返回默认值（默认返回的是组中第一行）
SAMPLE：下面的例子中每行的"NextHired"返回按hire_date排序的下一行的hire_date值

SELECT last_name, hire_date,
LEAD(hire_date, 1) OVER (ORDER BY hire_date) AS "NextHired"
FROM employees WHERE department_id = 30;

LAST_NAME HIRE_DATE NextHired
------------------------- --------- ---------
Raphaely 07-DEC-94 18-MAY-95
Khoo 18-MAY-95 24-JUL-97
Tobias 24-JUL-97 24-DEC-97
Baida 24-DEC-97 15-NOV-98
Himuro 15-NOV-98 10-AUG-99
Colmenares 10-AUG-99

10.SUM
功能描述：该函数计算组中表达式的累积和。
SAMPLE：下例计算同一经理下员工的薪水累积值

SELECT manager_id, last_name, salary,
SUM (salary) OVER (PARTITION BY manager_id ORDER BY salary
RANGE UNBOUNDED PRECEDING) l_csum
FROM employees
WHERE manager_id in (101,103,108);

MANAGER_ID LAST_NAME SALARY L_CSUM
---------- ------------------------- ---------- ----------
101 Whalen 4400 4400
101 Mavris 6500 10900
101 Baer 10000 20900
101 Greenberg 12000 44900
101 Higgins 12000 44900
103 Lorentz 4200 4200
103 Austin 4800 13800
103 Pataballa 4800 13800
103 Ernst 6000 19800
108 Popp 6900 6900
108 Sciarra 7700 14600
108 Urman 7800 22400
108 Chen 8200 30600
108 Faviet 9000 39600

11.MAX
功能描述：在一个组中的数据窗口中查找表达式的最大值。
SAMPLE：下面例子中dept_max返回当前行所在部门的最大薪水值

SELECT department_id, last_name, salary,
MAX(salary) OVER (PARTITION BY department_id) AS dept_max
FROM employees WHERE department_id in (10,20,30);

DEPARTMENT_ID LAST_NAME SALARY DEPT_MAX
------------- ------------------------- ---------- ----------
10 Whalen 4400 4400
20 Hartstein 13000 13000
20 Fay 6000 13000
30 Raphaely 11000 11000
30 Khoo 3100 11000
30 Baida 2900 11000
30 Tobias 2800 11000
30 Himuro 2600 11000
30 Colmenares 2500 11000

12.MIN
功能描述：在一个组中的数据窗口中查找表达式的最小值。
SAMPLE：下面例子中dept_min返回当前行所在部门的最小薪水值

SELECT department_id, last_name, salary,
MIN(salary) OVER (PARTITION BY department_id) AS dept_min
FROM employees WHERE department_id in (10,20,30);

DEPARTMENT_ID LAST_NAME SALARY DEPT_MIN
------------- ------------------------- ---------- ----------
10 Whalen 4400 4400
20 Hartstein 13000 6000
20 Fay 6000 6000
30 Raphaely 11000 2500
30 Khoo 3100 2500
30 Baida 2900 2500
30 Tobias 2800 2500
30 Himuro 2600 2500
30 Colmenares 2500 2500

 窗口函数
      Oracle从8.1.6开始提供分析函数，分析函数用于计算基于组的某种聚合值，它和聚合函数的不同之处是对于每个组返回多行，而聚合函数对于每个组只返回一行。
    开窗函数指定了分析函数工作的数据窗口大小，这个数据窗口大小可能会随着行的变化而变化，举例如下：
1) over(order by salary) 
     按照salary排序进行累计，order by是个默认的开窗函数
2) over(partition by deptno)
     按照部门分区
3) over(order by salary range between 50 preceding and 150 following)
     每行对应的数据窗口是之前行幅度值不超过50，之后行幅度值不超过150
4) over(order by salary rows between 50 preceding and 150 following)
    每行对应的数据窗口是之前50行，之后150行
5) over(order by salary rows between unbounded preceding and unbounded following)
     每行对应的数据窗口是从第一行到最后一行，等效：
    over(order by salary range between unbounded preceding and unbounded following)

1.MySQL
    同时使用内置RAND函数、LIMIT函数和ORDER BY
        select * from table
            order by rand()  limit 5
2.Oracle
    同时使用DBMS_RANDOM包中的内置函数 VALUE、 ORDER BY和内置函数ROWNUM
       select * from(
           select name from table order by dbms_random.value()
        ) where rownum <=5

1.Oracle
    对天数采用标准加减，使用ADD_MONTHS函数加减月数和年数

   例如 1)insertDate是数据库表中的一个日期类型的字段
             则 insertDate-5为前五天，同理insertDate+5为后五天
             2) 若要获得前一个月的时间，则 add_months(insertDate,-1);
                 若要获得后一个月的时间，则 add_months(insertDate,1)
             3)若要获得前一年的时间，则 add_months(insetDate,-1*12)
                 若要获得后一年的时间，则 add_months(insetDate, 1*12)
2.MySQL
      同时使用标准加减和INTERVAL关键字，INTEVRAL 指定时间单位
   例如：insertDate - INTERVAL 1 day
               insertDate + INTERVAL 1 day
               insertDate - INTERVAL 1 month
               insertDate - INTERVAL 1 year
      也可使用DATE_ADD(),ADDDATE(),SUBDATE()函数
              DATE_ADD(insertDate,INTERVAL 5  day)      
              DATE_ADD(insertDate,INTERVAL -5  day)
              ADDDATE(),SUBDATE() 使用方法类似

在Java中，容器主要包括：数组(Array)、集合(Collection)和映射(Map)三种。

(1)数组Array：将数字与元素联系起来，其中的元素都具有相同的数据类型，只能通过下标来访问其元素；数组可以是一维的，也可以是多维的；数组一旦 生成，其容量就不能改变。数组是一种复合数据类型，在Java中，除了可以像“int[] array;”来声明和表示一个数组，还可以用Array类来表示一个数组，同样地，JDK类库还提供了Arrays类类操作数组，该类定义了对数组进行 操作的各种方法(赋值、排序、搜索、比较、查找元素等)。

(2)集合Collection：是一个接口类，包括List、Set、Queue等子接口，其具体的实现类可以用来保存多个元素。这里只讨论常用的子接 口List和Set的常用实现类。常用的List实现类有ArrayList、Vector和LinkedList等，常用的Set实现类有 HashSet、LinkedHashSet和TreeSet等。需要注意的是，List和Set有着很大的不同，主要包括是否允许元素重复和是否维护元 素的次序。

(3)映射Map：保存相关联的键值对。其具体的实现类可以将键映射到值，根据键得到值，因此，一个映射不能包含重复的键，但是允许有重复的值，每个键最 多只能映射到一个值。 常见的Map实现类有HashMap、Hashtable、LinkedHashMap和TreeMap等。

为了讨论的方便，下面以Array，List、Set、Map为分类来讨论这几种容器的使用特点。

(1)Array：

    数组的使用很直接，主要是根据下表 来获取其元素。其特点就是一旦生成，其容量不能改变，并且每个元素之间不允许有“空隙”。其使用实例可以参考电子工业出版社“宝典”系列之《Java JDK 实例宝典》(夏先波 编著)，个人感觉这本书写得不错，给出了许多JDK类库的具体使用实例，代码的注释也比较详细，很适合初学者入门学习使用，如果看Java Doc 还是有不明白的地方，也可以参考此书:)

(2)List：可用来存放多个元素，能够自动扩充容量，能够维护元素的次序，并且允许元素重复。

    (2.1)ArrayList类：最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速的随机访问，但是要从ArrayList 的中间位置插入或者删除    元素时，需要对数组进行复制、移动，代价比较高，因此，ArrayList适合随机查找和遍历，不适合插入和删除。

    (2.2)Vector类：同ArrayList一样，其内部也是通过数组实现的，不同的是，Vector支持线程的同步，能够避免多线程同时写而引起的不一致，但是实现线程的同步需要很高的代价，因此访问Vector比ArrayList慢。

    (2.3)LinkedList类：见其名，该类与链表肯定有关系:)该类的内部是通过链表来实现的，很适合数据的动态插入和删除，但是随即访问 和遍历的速度比较慢。此外，该类还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

(3)Set：可用来存放多个元素，但是不允许元素重复(即不保存重复元素)，也不能够维护元素的次序。很直观，联想一下数学中的集合的概念就很好理解了。此外，需要注意的是，加入Set的元素必须定义equals()方法以确保对象的唯一性，如String对象。

    (3.1) HashSet类：采用散列函数对元素进行排序，是专门为快速查询而设计的存入HashSet的对象必须定义hashCode()方法。

    (3.2)TreeSet类：采用红黑树的数据结构进行排序元素，使用它可以从Set中提取有序的序列。

    (3.3) LinkedHashSet类：内部使用散列以加快查询速度，同时使用链表维护元素的插入次序，在使用迭代器遍历时，会按插入次序显示结果。


(4)Map：可以用来存放相关联的键值对，根据键得到值。常见的Map实现类有HashMap、Hashtable、LinkedHashMap和TreeMap。

    (4.1)HashMap类：一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度，但不支持线程同步。HashMap最多允许一条记录的键为null，但是允许多条记录的值为null。
    
    (4.2)Hashtable类：与HashMap类似，但是它不允许记录的键或者值为null，支持线程同步，因而Hashtable在写入数据时会很慢。

    (4.3)LinkedHashMap类：保存了记录的插入顺序，在用Iterator遍历它时，先得到的记录肯定时先插入的，在遍历的时候比HashMap慢。

    (4.4)TreeMap类：能够把它保存的记录根据键排序，默认为升序排列。当用Iterator遍历它时，得到的记录是排过序的记录。