实例

    功能              ¦          示例            ¦    位运算
----------------------+---------------------------+--------------------
去掉最后一位          ¦ (101101->10110)          ¦ x >> 1
在最后加一个0        ¦ (101101->1011010)        ¦ x < < 1
在最后加一个1        ¦ (101101->1011011)        ¦ x < < 1+1
把最后一位变成1      ¦ (101100->101101)          ¦ x ¦ 1
把最后一位变成0      ¦ (101101->101100)          ¦ x ¦ 1-1
最后一位取反          ¦ (101101->101100)          ¦ x ^ 1
把右数第k位变成1      ¦ (101001->101101,k=3)      ¦ x ¦ (1 < < (k-1))
把右数第k位变成0      ¦ (101101->101001,k=3)      ¦ x & ~ (1 < < (k-1))
右数第k位取反        ¦ (101001->101101,k=3)      ¦ x ^ (1 < < (k-1))
取末三位              ¦ (1101101->101)            ¦ x & 7
取末k位              ¦ (1101101->1101,k=5)      ¦ x & ((1 < < k)-1)

取右数第k位          ¦ (1101101->1,k=4)          ¦ x >> (k-1) & 1

把末k位变成1          ¦ (101001->101111,k=4)      ¦ x ¦ (1 < < k-1)
末k位取反            ¦ (101001->100110,k=4)      ¦ x ^ (1 < < k-1)
把右边连续的1变成0    ¦ (100101111->100100000)    ¦ x & (x+1)
把右起第一个0变成1    ¦ (100101111->100111111)    ¦ x ¦ (x+1)
把右边连续的0变成1    ¦ (11011000->11011111)      ¦ x ¦ (x-1)
取右边连续的1        ¦ (100101111->1111)        ¦ (x ^ (x+1)) >> 1
去掉右起第一个1的左边 ¦ (100101000->1000)        ¦ x & (x ^ (x-1))
判断奇数      (x&1)==1
判断偶数 (x&1)==0       

例如求从x位（高）到y位（低）间共有多少个1

public static int FindChessNum(int x, int y, ushort k)
        {
            int re = 0;
            for (int i = y; i <= x; i++)
            {
                re += ((k >> (i - 1)) & 1);
            }
            return re;
        }

Heap = {Old + NEW = { Eden , from, to } }

JVM内存模型中分两大块，一块是 NEW Generation, 另一块是Old Generation. 在New Generation中，有一个叫Eden的空间，主要是用来存放新生的对象，还有两个Survivor Spaces（from,to）, 它们用来存放每次垃圾回收后存活下来的对象。在Old Generation中，主要存放应用程序中生命周期长的内存对象，还有个Permanent Generation，主要用来放JVM自己的反射对象，比如类对象和方法对象等。
垃圾回收描述：

在New Generation块中，垃圾回收一般用Copying的算法，速度快。每次GC的时候，存活下来的对象首先由Eden拷贝到某个Survivor Space, 当Survivor Space空间满了后, 剩下的live对象就被直接拷贝到Old Generation中去。因此，每次GC后，Eden内存块会被清空。在Old Generation块中，垃圾回收一般用mark-compact的算法，速度慢些，但减少内存要求.
垃圾回收分多级，0级为全部(Full)的垃圾回收，会回收OLD段中的垃圾；1级或以上为部分垃圾回收，只会回收NEW中的垃圾，内存溢出通常发生于OLD段或Perm段垃圾回收后，仍然无内存空间容纳新的Java对象的情况。

当一个URL被访问时，内存申请过程如下：
A. JVM会试图为相关Java对象在Eden中初始化一块内存区域
B. 当Eden空间足够时，内存申请结束。否则到下一步
C. JVM试图释放在Eden中所有不活跃的对象（这属于1或更高级的垃圾回收）, 释放后若Eden空间仍然不足以放入新对象，则试图将部分Eden中活跃对象放入Survivor区
D. Survivor区被用来作为Eden及OLD的中间交换区域，当OLD区空间足够时，Survivor区的对象会被移到Old区，否则会被保留在Survivor区
E. 当OLD区空间不够时，JVM会在OLD区进行完全的垃圾收集（0级）
F. 完全垃圾收集后，若Survivor及OLD区仍然无法存放从Eden复制过来的部分对象，导致JVM无法在Eden区为新对象创建内存区域，则出现”out of memory错误”

JVM调优建议:

ms/mx：定义YOUNG+OLD段的总尺寸，ms为JVM启动时YOUNG+OLD的内存大小；mx为最大可占用的YOUNG+OLD内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
NewSize/MaxNewSize：定义YOUNG段的尺寸，NewSize为JVM启动时YOUNG的内存大小；MaxNewSize为最大可占用的YOUNG内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
PermSize/MaxPermSize：定义Perm段的尺寸，PermSize为JVM启动时Perm的内存大小；MaxPermSize为最大可占用的Perm内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
SurvivorRatio：设置Survivor空间和Eden空间的比例

内存溢出的可能性

1. OLD段溢出
这种内存溢出是最常见的情况之一，产生的原因可能是：
1) 设置的内存参数过小(ms/mx, NewSize/MaxNewSize)
2) 程序问题
单个程序持续进行消耗内存的处理，如循环几千次的字符串处理，对字符串处理应建议使用StringBuffer。此时不会报内存溢出错，却会使系统持续垃圾收集，无法处理其它请求，相关问题程序可通过Thread Dump获取（见系统问题诊断一章）单个程序所申请内存过大，有的程序会申请几十乃至几百兆内存，此时JVM也会因无法申请到资源而出现内存溢出，对此首先要找到相关功能，然后交予程序员修改，要找到相关程序，必须在Apache日志中寻找。
当Java对象使用完毕后，其所引用的对象却没有销毁，使得JVM认为他还是活跃的对象而不进行回收，这样累计占用了大量内存而无法释放。由于目前市面上还没有对系统影响小的内存分析工具，故此时只能和程序员一起定位。

2. Perm段溢出
通常由于Perm段装载了大量的Servlet类而导致溢出，目前的解决办法：
1) 将PermSize扩大，一般256M能够满足要求
2) 若别无选择，则只能将servlet的路径加到CLASSPATH中，但一般不建议这么处理

3. C Heap溢出
系统对C Heap没有限制，故C Heap发生问题时，Java进程所占内存会持续增长，直到占用所有可用系统内存

其他：

JVM有2个GC线程。第一个线程负责回收Heap的Young区。第二个线程在Heap不足时，遍历Heap，将Young 区升级为Older区。Older区的大小等于-Xmx减去-Xmn，不能将-Xms的值设的过大，因为第二个线程被迫运行会降低JVM的性能。
为什么一些程序频繁发生GC？有如下原因：l         程序内调用了System.gc()或Runtime.gc()。l         一些中间件软件调用自己的GC方法，此时需要设置参数禁止这些GC。l         Java的Heap太小，一般默认的Heap值都很小。l         频繁实例化对象，Release对象。此时尽量保存并重用对象，例如使用StringBuffer()和String()。如果你发现每次GC后，Heap的剩余空间会是总空间的50%，这表示你的Heap处于健康状态。许多Server端的Java程序每次GC后最好能有65%的剩余空间。经验之谈：1．Server端JVM最好将-Xms和-Xmx设为相同值。为了优化GC，最好让-Xmn值约等于-Xmx的1/3[2]。2．一个GUI程序最好是每10到20秒间运行一次GC，每次在半秒之内完成[2]。注意：1．增加Heap的大小虽然会降低GC的频率，但也增加了每次GC的时间。并且GC运行时，所有的用户线程将暂停，也就是GC期间，Java应用程序不做任何工作。2．Heap大小并不决定进程的内存使用量。进程的内存使用量要大于-Xmx定义的值，因为Java为其他任务分配内存，例如每个线程的Stack等。2．Stack的设定每个线程都有他自己的Stack。
-Xss 每个线程的Stack大小

Stack的大小限制着线程的数量。如果Stack过大就好导致内存溢漏。-Xss参数决定Stack大小，例如-Xss1024K。如果Stack太小，也会导致Stack溢漏。3．硬件环境硬件环境也影响GC的效率，例如机器的种类，内存，swap空间，和CPU的数量。如果你的程序需要频繁创建很多transient对象，会导致JVM频繁GC。这种情况你可以增加机器的内存，来减少Swap空间的使用[2]。4．4种GC第一种为单线程GC，也是默认的GC。，该GC适用于单CPU机器。第二种为Throughput GC，是多线程的GC，适用于多CPU，使用大量线程的程序。第二种GC与第一种GC相似，不同在于GC在收集Young区是多线程的，但在Old区和第一种一样，仍然采用单线程。-XX:+UseParallelGC参数启动该GC。第三种为Concurrent Low Pause GC，类似于第一种，适用于多CPU，并要求缩短因GC造成程序停滞的时间。这种GC可以在Old区的回收同时，运行应用程序。-XX:+UseConcMarkSweepGC参数启动该GC。第四种为Incremental Low Pause GC，适用于要求缩短因GC造成程序停滞的时间。这种GC可以在Young区回收的同时，回收一部分Old区对象。-Xincgc参数启动该GC。

 　　import java.security.*;

 　　import java.io.*;

 　　import java.util.*;

 　　import java.security.*;

 　　import java.security.cert.*;

 　　import sun.security.x509.*

 　　import java.security.cert.Certificate;

 　　import java.security.cert.CertificateFactory;

 　　二：从文件中读取证书

 　　用keytool将.keystore中的证书写入文件中，然后从该文件中读取证书信息

 　　CertificateFactory cf=CertificateFactory.getInstance("X.509");

 　　FileInputStream in=new FileInputStream("out.csr");

 　　Certificate c=cf.generateCertificate(in);

 　　String s=c.toString();

 　　三：从密钥库中直接读取证书

 　　String pass="123456";

 　　FileInputStream in=new FileInputStream(".keystore");

 　　KeyStore ks=KeyStore.getInstance("JKS");

 　　ks.load(in,pass.toCharArray());

 　　java.security.cert.Certificate c=ks.getCertificate(alias);//alias为条目的别名

 　　四：JAVA程序中显示证书指定信息

 　　System.out.println("输出证书信息:\n"+c.toString());

 　　System.out.println("版本号:"+t.getVersion());

 　　System.out.println("序列号:"+t.getSerialNumber().toString(16));

 　　System.out.println("主体名："+t.getSubjectDN());

 　　System.out.println("签发者："+t.getIssuerDN());

 　　System.out.println("有效期："+t.getNotBefore());

 　　System.out.println("签名算法："+t.getSigAlgName());

 　　byte [] sig=t.getSignature();//签名值

 　　PublicKey pk=t.getPublicKey();

 　　byte [] pkenc=pk.getEncoded();

 　　System.out.println("公钥");

 　　for(int i=0;i<pkenc.length;i++)System.out.print(pkenc[i]+",");

 　　五：JAVA程序列出密钥库所有条目
 String pass="123456";

 　　FileInputStream in=new FileInputStream(".keystore");

 　　KeyStore ks=KeyStore.getInstance("JKS");

 　　ks.load(in,pass.toCharArray());

 　　Enumeration e=ks.aliases();

 　　while(e.hasMoreElements())

 　　java.security.cert.Certificate c=ks.getCertificate((String)e.nextElement());

 　　六：JAVA程序修改密钥库口令

 　　String oldpass="123456";

 　　String newpass="654321";

 　　FileInputStream in=new FileInputStream(".keystore");

 　　KeyStore ks=KeyStore.getInstance("JKS");

 　　ks.load(in,oldpass.toCharArray());

 　　in.close();

 　　FileOutputStream output=new FileOutputStream(".keystore");

 　　ks.store(output,newpass.toCharArray());

 　　output.close();

 　　七：JAVA程序修改密钥库条目的口令及添加条目

 　　FileInputStream in=new FileInputStream(".keystore");

 　　KeyStore ks=KeyStore.getInstance("JKS");

 　　ks.load(in,storepass.toCharArray());

 　　Certificate [] cchain=ks.getCertificate(alias);获取别名对应条目的证书链

 　　PrivateKey pk=(PrivateKey)ks.getKey(alias,oldkeypass.toCharArray());获取别名对应条目的私钥

 　　ks.setKeyEntry(alias,pk,newkeypass.toCharArray(),cchain);向密钥库中添加条目

 　　第一个参数指定所添加条目的别名，假如使用已存在别名将覆盖已存在条目，使用新别名将增加一个新条目，第二个参数为条目的私钥，第三个为设置的新口令，第四个为该私钥的公钥的证书链

 　　FileOutputStream output=new FileOutputStream("another");

 　　ks.store(output,storepass.toCharArray())将keystore对象内容写入新文件

 　　八：JAVA程序检验别名和删除条目

 　　FileInputStream in=new FileInputStream(".keystore");

 　　KeyStore ks=KeyStore.getInstance("JKS");

 　　ks.load(in,storepass.toCharArray());
 ks.containsAlias("sage");检验条目是否在密钥库中，存在返回true

 　　ks.deleteEntry("sage");删除别名对应的条目

 　　FileOutputStream output=new FileOutputStream(".keystore");

 　　ks.store(output,storepass.toCharArray())将keystore对象内容写入文件,条目删除成功

 九：JAVA程序签发数字证书

 　　（1）从密钥库中读取CA的证书

 　　FileInputStream in=new FileInputStream(".keystore");

 　　KeyStore ks=KeyStore.getInstance("JKS");

 　　ks.load(in,storepass.toCharArray());

 　　java.security.cert.Certificate c1=ks.getCertificate("caroot");

 　　（2）从密钥库中读取CA的私钥

 　　PrivateKey caprk=(PrivateKey)ks.getKey(alias,cakeypass.toCharArray());

 　　（3）从CA的证书中提取签发者的信息

 　　byte[] encod1=c1.getEncoded();　　提取CA证书的编码

 　　X509CertImpl cimp1=new X509CertImpl(encod1);　用该编码创建X509CertImpl类型对象

 　　X509CertInfo cinfo1=(X509CertInfo)cimp1.get(X509CertImpl.NAME+"."+X509CertImpl.INFO);　获取X509CertInfo对象

 　　X500Name issuer=(X500Name)cinfo1.get(X509CertInfo.SUBJECT+"."+CertificateIssuerName.DN_NAME); 获取X509Name类型的签发者信息

 　　（4）获取待签发的证书

 　　CertificateFactory cf=CertificateFactory.getInstance("X.509");

 　　FileInputStream in2=new FileInputStream("user.csr");

 　　java.security.cert.Certificate c2=cf.generateCertificate(in);

 　　（5）从待签发的证书中提取证书信息

 　　byte [] encod2=c2.getEncoded();

 　　X509CertImpl cimp2=new X509CertImpl(encod2);　用该编码创建X509CertImpl类型对象

 　　X509CertInfo cinfo2=(X509CertInfo)cimp2.get(X509CertImpl.NAME+"."+X509CertImpl.INFO);　获取X509CertInfo对象

 　　（6）设置新证书有效期

 　　Date begindate=new Date(); 获取当前时间

 　　Date enddate=new Date(begindate.getTime()+3000*24*60*60*1000L); 有效期为3000天
 CertificateValidity cv=new CertificateValidity(begindate,enddate); 创建对象

 　　cinfo2.set(X509CertInfo.VALIDITY,cv);　设置有效期

 　　（7）设置新证书序列号

 　　int sn=(int)(begindate.getTime()/1000);　　以当前时间为序列号

 　　CertificateSerialNumber csn=new CertificateSerialNumber(sn);

 　　cinfo2.set(X509CertInfo.SERIAL_NUMBER,csn);

 　　（8）设置新证书签发者

 　　cinfo2.set(X509CertInfo.ISSUER+"."+CertificateIssuerName.DN_NAME,issuer);应用第三步的结果

 　　（9）设置新证书签名算法信息

 　　AlgorithmId algorithm=new AlgorithmId(AlgorithmId.md5WithRSAEncryption_oid);

 　　cinfo2.set(CertificateAlgorithmId.NAME+"."+CertificateAlgorithmId.ALGORITHM,algorithm);

 　　（10）创建证书并使用CA的私钥对其签名

 　　X509CertImpl newcert=new X509CertImpl(cinfo2);

 　　newcert.sign(caprk,"MD5WithRSA"); 使用CA私钥对其签名

 　　（11）将新证书写入密钥库

 　　ks.setCertificateEntry("lf_signed",newcert);

 　　FileOutputStream out=new FileOutputStream("newstore");

 　　ks.store(out,"newpass".toCharArray());　这里是写入了新的密钥库，也可以使用第七条来增加条目

 　　十：数字证书的检验

 　　（1）验证证书的有效期

 　　（a）获取X509Certificate类型对象

 　　CertificateFactory cf=CertificateFactory.getInstance("X.509");

 　　FileInputStream in1=new FileInputStream("aa.crt");

 　　java.security.cert.Certificate　c1=cf.generateCertificate(in1);

 　　X509Certificate t=(X509Certificate)c1;

 　　in2.close();

 　　（b）获取日期

 　　Date TimeNow=new Date();

 　　（c）检验有效性

 　　try{

 　　t.checkValidity(TimeNow);

 　　System.out.println("OK");

 　　}catch(CertificateExpiredException e){　//过期

 　　System.out.println("Expired");
 System.out.println(e.getMessage());

 　　}catch((CertificateNotYetValidException e){ //尚未生效

 　　System.out.println("Too early");

 　　System.out.println(e.getMessage());}

 　　（2）验证证书签名的有效性

 　　（a）获取CA证书

 　　CertificateFactory cf=CertificateFactory.getInstance("X.509");

 　　FileInputStream in2=new FileInputStream("caroot.crt");

 　　java.security.cert.Certificate　cac=cf.generateCertificate(in2);

 　　in2.close();

 　　（c）获取CA的公钥

 　　PublicKey pbk=cac.getPublicKey();

 　　（b）获取待检验的证书（上步已经获取了，就是C1）

 　　（c）检验证书

 　　boolean pass=false;

 　　try{

 　　c1.verify(pbk);

 　　pass=true;

 　　}catch(Exception e){

 　　pass=false;

 　　System.out.println(e);

 插入排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;
 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class InsertSort implements SortUtil.Sort{

     /* (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         int temp;
         for(int i=1;i<data.length;i++){
             for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                 SortUtil.swap(data,j,j-1);
             }
         }        
     }

 }
 冒泡排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class BubbleSort implements SortUtil.Sort{

     /* (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         int temp;
         for(int i=0;i<data.length;i++){
             for(int j=data.length-1;j>i;j--){
                 if(data[j]<data[j-1]){
                     SortUtil.swap(data,j,j-1);
                 }
             }
         }
     }

 }

 选择排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class SelectionSort implements SortUtil.Sort {

     /*
      * (non-Javadoc)
      * 
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         int temp;
         for (int i = 0; i < data.length; i++) {
             int lowIndex = i;
             for (int j = data.length - 1; j > i; j--) {
                 if (data[j] < data[lowIndex]) {
                     lowIndex = j;
                 }
             }
             SortUtil.swap(data,i,lowIndex);
         }
     }

 }

 Shell排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class ShellSort implements SortUtil.Sort{

     /* (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         for(int i=data.length/2;i>2;i/=2){
             for(int j=0;j<i;j++){
                 insertSort(data,j,i);
             }
         }
         insertSort(data,0,1);
     }

     /**
      * @param data
      * @param j
      * @param i
      */
     private void insertSort(int[] data, int start, int inc) {
         int temp;
         for(int i=start+inc;i<data.length;i+=inc){
             for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
                 SortUtil.swap(data,j,j-inc);
             }
         }
     }

 }

 快速排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class QuickSort implements SortUtil.Sort{

     /* (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         quickSort(data,0,data.length-1);        
     }
     private void quickSort(int[] data,int i,int j){
         int pivotIndex=(i+j)/2;
         //swap
         SortUtil.swap(data,pivotIndex,j);
         
         int k=partition(data,i-1,j,data[j]);
         SortUtil.swap(data,k,j);
         if((k-i)>1) quickSort(data,i,k-1);
         if((j-k)>1) quickSort(data,k+1,j);
         
     }
     /**
      * @param data
      * @param i
      * @param j
      * @return
      */
     private int partition(int[] data, int l, int r,int pivot) {
         do{
            while(data[++l]<pivot);
            while((r!=0)&&data[--r]>pivot);
            SortUtil.swap(data,l,r);
         }
         while(l<r);
         SortUtil.swap(data,l,r);        
         return l;
     }

 }
 改进后的快速排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class ImprovedQuickSort implements SortUtil.Sort {

     private static int MAX_STACK_SIZE=4096;
     private static int THRESHOLD=10;
     /* (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         int[] stack=new int[MAX_STACK_SIZE];
         
         int top=-1;
         int pivot;
         int pivotIndex,l,r;
         
         stack[++top]=0;
         stack[++top]=data.length-1;
         
         while(top>0){
             int j=stack[top--];
             int i=stack[top--];
             
             pivotIndex=(i+j)/2;
             pivot=data[pivotIndex];
             
             SortUtil.swap(data,pivotIndex,j);
             
             //partition
             l=i-1;
             r=j;
             do{
                 while(data[++l]<pivot);
                 while((r!=0)&&(data[--r]>pivot));
                 SortUtil.swap(data,l,r);
             }
             while(l<r);
             SortUtil.swap(data,l,r);
             SortUtil.swap(data,l,j);
             
             if((l-i)>THRESHOLD){
                 stack[++top]=i;
                 stack[++top]=l-1;
             }
             if((j-l)>THRESHOLD){
                 stack[++top]=l+1;
                 stack[++top]=j;
             }
             
         }
         //new InsertSort().sort(data);
         insertSort(data);
     }
     /**
      * @param data
      */
     private void insertSort(int[] data) {
         int temp;
         for(int i=1;i<data.length;i++){
             for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                 SortUtil.swap(data,j,j-1);
             }
         }       
     }

 }

 归并排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class MergeSort implements SortUtil.Sort{

     /* (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         int[] temp=new int[data.length];
         mergeSort(data,temp,0,data.length-1);
     }
     
     private void mergeSort(int[] data,int[] temp,int l,int r){
         int mid=(l+r)/2;
         if(l==r) return ;
         mergeSort(data,temp,l,mid);
         mergeSort(data,temp,mid+1,r);
         for(int i=l;i<=r;i++){
             temp[i]=data[i];
         }
         int i1=l;
         int i2=mid+1;
         for(int cur=l;cur<=r;cur++){
             if(i1==mid+1)
                 data[cur]=temp[i2++];
             else if(i2>r)
                 data[cur]=temp[i1++];
             else if(temp[i1]<temp[i2])
                 data[cur]=temp[i1++];
             else
                 data[cur]=temp[i2++];            
         }
     }

 }

 改进后的归并排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class ImprovedMergeSort implements SortUtil.Sort {

     private static final int THRESHOLD = 10;

     /*
      * (non-Javadoc)
      * 
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         int[] temp=new int[data.length];
         mergeSort(data,temp,0,data.length-1);
     }

     private void mergeSort(int[] data, int[] temp, int l, int r) {
         int i, j, k;
         int mid = (l + r) / 2;
         if (l == r)
             return;
         if ((mid - l) >= THRESHOLD)
             mergeSort(data, temp, l, mid);
         else
             insertSort(data, l, mid - l + 1);
         if ((r - mid) > THRESHOLD)
             mergeSort(data, temp, mid + 1, r);
         else
             insertSort(data, mid + 1, r - mid);

         for (i = l; i <= mid; i++) {
             temp[i] = data[i];
         }
         for (j = 1; j <= r - mid; j++) {
             temp[r - j + 1] = data[j + mid];
         }
         int a = temp[l];
         int b = temp[r];
         for (i = l, j = r, k = l; k <= r; k++) {
             if (a < b) {
                 data[k] = temp[i++];
                 a = temp[i];
             } else {
                 data[k] = temp[j--];
                 b = temp[j];
             }
         }
     }

     /**
      * @param data
      * @param l
      * @param i
      */
     private void insertSort(int[] data, int start, int len) {
         for(int i=start+1;i<start+len;i++){
             for(int j=i;(j>start) && data[j]<data[j-1];j--){
                 SortUtil.swap(data,j,j-1);
             }
         }
     }

 }
 堆排序:

 package org.rut.util.algorithm.support;

 import org.rut.util.algorithm.SortUtil;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class HeapSort implements SortUtil.Sort{

     /* (non-Javadoc)
      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
      */
     public void sort(int[] data) {
         MaxHeap h=new MaxHeap();
         h.init(data);
         for(int i=0;i<data.length;i++)
             h.remove();
         System.arraycopy(h.queue,1,data,0,data.length);
     }

 
      private static class MaxHeap{
          
         
         void init(int[] data){
             this.queue=new int[data.length+1];
             for(int i=0;i<data.length;i++){
                 queue[++size]=data[i];
                 fixUp(size);
             }
         }
          
         private int size=0;

        private int[] queue;
                 
         public int get() {
             return queue[1];
         }

         public void remove() {
             SortUtil.swap(queue,1,size--);
             fixDown(1);
         }
         //fixdown
         private void fixDown(int k) {
             int j;
             while ((j = k << 1) <= size) {
                 if (j < size && queue[j]<queue[j+1])
                     j++; 
                 if (queue[k]>queue[j]) //不用交换
                     break;
                 SortUtil.swap(queue,j,k);
                 k = j;
             }
         }
         private void fixUp(int k) {
             while (k > 1) {
                 int j = k >> 1;
                 if (queue[j]>queue[k])
                     break;
                 SortUtil.swap(queue,j,k);
                 k = j;
             }
         }

     }

 }

 SortUtil:

 package org.rut.util.algorithm;

 import org.rut.util.algorithm.support.BubbleSort;
 import org.rut.util.algorithm.support.HeapSort;
 import org.rut.util.algorithm.support.ImprovedMergeSort;
 import org.rut.util.algorithm.support.ImprovedQuickSort;
 import org.rut.util.algorithm.support.InsertSort;
 import org.rut.util.algorithm.support.MergeSort;
 import org.rut.util.algorithm.support.QuickSort;
 import org.rut.util.algorithm.support.SelectionSort;
 import org.rut.util.algorithm.support.ShellSort;

 /**
  * @author treeroot
  * @since 2006-2-2
  * @version 1.0
  */
 public class SortUtil {
     public final static int INSERT = 1;

     public final static int BUBBLE = 2;

     public final static int SELECTION = 3;

     public final static int SHELL = 4;

     public final static int QUICK = 5;

     public final static int IMPROVED_QUICK = 6;

     public final static int MERGE = 7;

     public final static int IMPROVED_MERGE = 8;

     public final static int HEAP = 9;

     public static void sort(int[] data) {
         sort(data, IMPROVED_QUICK);
     }
     private static String[] name={
             "insert","bubble","selection","shell","quick","improved_quick","merge","improved_merge","heap"
     };
     
     private static Sort[] impl=new Sort[]{
             new InsertSort(),
             new BubbleSort(),
             new SelectionSort(),
             new ShellSort(),
             new QuickSort(),
             new ImprovedQuickSort(),
             new MergeSort(),
             new ImprovedMergeSort(),
             new HeapSort()
     };

     public static String toString(int algorithm){
         return name[algorithm-1];
     }
     
     public static void sort(int[] data, int algorithm) {
         impl[algorithm-1].sort(data);
     }

     public static interface Sort {
         public void sort(int[] data);
     }

     public static void swap(int[] data, int i, int j) {
         int temp = data[i];
         data[i] = data[j];
         data[j] = temp;
     }
 }

首先对SimpleDateFormat有所了解，以下摘自java-doc中

Letter  Date or Time Component  Presentation  Examples  
G  Era designator  Text  AD  
y  Year  Year   1996 ;  96   
M  Month in year  Month  July; Jul;  07   
w  Week in year  Number   27   
W  Week in month  Number   2   
D  Day in year  Number   189   
d  Day in month  Number   10   
F  Day of week in month  Number   2   
E  Day in week  Text  Tuesday; Tue  
a  Am / pm marker  Text  PM  
H  Hour in day ( 0 - 23 )  Number   0   
k  Hour in day ( 1 - 24 )  Number   24   
K  Hour in am / pm ( 0 - 11 )  Number   0   
h  Hour in am / pm ( 1 - 12 )  Number   12   
m  Minute in hour  Number   30   
s  Second in minute  Number   55   
S  Millisecond  Number   978   
z  Time zone  General time zone  Pacific Standard Time; PST; GMT - 08 : 00   
Z  Time zone  RFC  822  time zone   - 0800   

对中国人来说，普遍使用的是"yyyy-MM-dd"。

贴出代码：

import  java.util. * ;
import  java.text. * ;
public   class  weekDay 
{
  public   static   void  main(String[] args) 
  {
   //  ----------------------
   // 实现给定某日期，判断是星期几。
   // ------------------------
  SimpleDateFormat formatYMD  =   new  SimpleDateFormat( " yyyy-MM-dd " );
   // formatYMD表示的是yyyy-MM-dd格式
  SimpleDateFormat formatD  =   new  SimpleDateFormat( " E " );
   // "E"表示"day in week"
  Date d  =   null ;
   try
   {
   d  =  formatYMD.parse( " 2005-11-8 " );
    // 将String 转换为符合格式的日期
  }
   catch (Exception e)
   {
   e.printStackTrace();
  }
  System.out.println(formatD.format(d));
   // 将日期中的day of week打印
  
  
  
   // ---------------------------
   // 测试一下一些想法，跟主题无关
   // Date在java.util中Date类
   // 原来java中1月用0代表，弄的测了半天
   // ---------------------------
  Date testDate  =   new  Date();
  SimpleDateFormat format1  =   new  SimpleDateFormat( " yyyy-MM-dd " );
  System.out.println(testDate);
  System.out.println(format1.format(testDate));
  System.out.println(testDate.getMonth());
  
  Calendar cal  =  Calendar.getInstance();
  cal.get(Calendar.MONTH);
  
 }

}