谁与争锋刀剑啸（诚挚结交天下好友）

是在猴哥和阿土的帮助下得到的，直接贴代码，原版只有一个入口是字符串入口，在实际使用中，此入口在计算文件的MD5时会有问题，所以我加了一个byte[]入口。

/*手机博客客户端.MD5码计算
开发：李果
开发开始日期：２００６年５月８日
*/
public class MD5 {

    /* 下面这些S11-S44实际上是一个4*4的矩阵，在原始的C实现中是用#define 实现的,这里把它们

    /* 实现成为static final是表示了只读，切能在同一个进程空间内的多个Instance间共享*/

    static final int S11 = 7;

    static final int S12 = 12;

    static final int S13 = 17;

    static final int S14 = 22;

    static final int S21 = 5;

    static final int S2 = 9;

    static final int S23 = 14;

    static final int S24 = 20;

    static final int S31 = 4;

    static final int S32 = 11;

    static final int S33 = 16;

    static final int S34 = 23;

    static final int S41 = 6;

    static final int S42 = 10;

    static final int S43 = 15;

    static final int S44 = 21;

    static final byte[] PADDING = {-128, 0, 0, 0, 0, 0, 0, 0, 0,

                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

    /* 下面的三个成员是MD5计算过程中用到的3个核心数据，在原始的C实现中 */

    /*   被定义到MD5_CTX结构中 */

    private long[] state = new long[4];  // state (ABCD)

    private long[] count = new long[2];  // number of bits, modulo 2^64 (lsb first)

    private byte[] buffer = new byte[64]; // input buffer

    /* digestHexStr是MD5的唯一一个公共成员，是最新一次计算结果的16进制ASCII表示. */

    public String digestHexStr;

    /* digest,是最新一次计算结果的2进制内部表示，表示128bit的MD5值. */

    private byte[] digest = new byte[16];

    /*  getMD5ofStr是类MD5最主要的公共方法，入口参数是你想要进行MD5变换的字符串 */

    /*  返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的．*/

    public String getMD5ofStr(String inbuf) {

        md5Init();

        md5Update(inbuf.getBytes(), inbuf.length());

        md5Final();

        digestHexStr = "";

        for (int i = 0; i < 16; i++) {
            digestHexStr += byteHEX(digest[i]);
        }

        return digestHexStr;
    }
   
    public String getMD5ofStr(byte[] inbuf)
    {

        md5Init();

        md5Update(inbuf, inbuf.length);

        md5Final();

        digestHexStr = "";

        for (int i = 0; i < 16; i++) {
            digestHexStr += byteHEX(digest[i]);
        }

        return digestHexStr;
    }     

    /* 这是MD5这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数. */

    public MD5() {
        md5Init();
    }

    /* md5Init是一个初始化函数，初始化核心变量，装入标准的幻数 */
    private void md5Init() {

        count[0] = 0L;

        count[1] = 0L;

        ///* Load magic initialization constants.

        state[0] = 0x67452301L;

        state[1] = 0xefcdab89L;

        state[2] = 0x98badcfeL;

        state[3] = 0x10325476L;

        return;

    }

    /* F, G, H ,I 是4个基本的MD5函数，在原始的MD5的C实现中，由于它们是 */

    /* 简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，*/

    /* 我把它们实现成了private方法，名字保持了原来C中的。 */
    private long F(long x, long y, long z) {
        return (x & y) | ((~x) & z);
    }

    private long G(long x, long y, long z) {
        return (x & z) | (y & (~z));
    }

    private long H(long x, long y, long z) {
        return x ^ y ^ z;
    }

    private long I(long x, long y, long z) {
        return y ^ (x | (~z));
    }

    /* FF,GG,HH和II将调用F,G,H,I进行近一步变换 FF, GG, HH, and II transformations */

    /* for rounds 1, 2, 3, and 4. Rotation is separate from addition to prevent recomputation. */
    private long FF(long a, long b, long c, long d, long x, long s, long ac) {

        a += F(b, c, d) + x + ac;

        a = ((int) a << s) | ((int) a >>> (32 - s));

        a += b;

        return a;
    }

    private long GG(long a, long b, long c, long d, long x, long s, long ac) {

        a += G(b, c, d) + x + ac;

        a = ((int) a << s) | ((int) a >>> (32 - s));

        a += b;

        return a;
    }

    private long HH(long a, long b, long c, long d, long x, long s, long ac) {

        a += H(b, c, d) + x + ac;

        a = ((int) a << s) | ((int) a >>> (32 - s));

        a += b;

        return a;
    }

    private long II(long a, long b, long c, long d, long x, long s, long ac) {

        a += I(b, c, d) + x + ac;

        a = ((int) a << s) | ((int) a >>> (32 - s));

        a += b;

        return a;
    }

    /* md5Update是MD5的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个 */

    /* 函数由getMD5ofStr调用，调用之前需要调用md5init，因此把它设计成private */
    private void md5Update(byte[] inbuf, int inputLen) {

        int i, index, partLen;

        byte[] block = new byte[64];

      &nbs; index = (int) (count[0] >>> 3) & 0x3F;

        // /* Update number of bits */

        if ((count[0] += (inputLen << 3)) < (inputLen << 3))

            count[1]++;

        count[1] += (inputLen >>> 29);

        partLen = 64 - index;

        // Transform as many times as possible.

        if (inputLen >= partLen) {

            md5Memcpy(buffer, inbuf, index, 0, partLen);

            md5Transform(buffer);

            for (i = partLen; i + 63 < inputLen; i += 64) {

                md5Memcpy(block, inbuf, 0, i, 64);

                md5Transform(block);

            }

            index = 0;

        } else

            i = 0;

        ///* Buffer remaining input */

        md5Memcpy(buffer, inbuf, index, i, inputLen - i);

    }

    /* md5Final整理和填写输出结果 */
    private void md5Final() {

        byte[] bits = new byte[8];

        int index, padLen;

        ///* Save number of bits */

        Encode(bits, count, 8);

        ///* Pad out to 56 mod 64.

        index = (int) (count[0] >>> 3) & 0x3f;

        padLen = (index < 56) ? (56 - index) : (120 - index);

        md5Update(PADDING, padLen);

        ///* Append length (before padding) */

        md5Update(bits, 8);

        ///* Store state in digest */

        Encode(digest, state, 16);

    }

    /* md5Memcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把 */

    /* len长度的字节拷贝到output的outpos位置开始. */
    private void md5Memcpy(byte[] output, byte[] input, int outpos, int inpos, int len) {
        int i;

        for (i = 0; i < len; i++)
            output[outpos + i] = input[inpos + i];
    }

    /* md5Transform是MD5核心变换程序，有md5Update调用，block是分块的原始字节. */
    private void md5Transform(byte block[]) {
        long a = state[0], b = state[1], c = state[2], d = state[3];

        long[] x = new long[16];

        Decode(x, block, 64);

        /* Round 1 */

        a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */

        d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */

        c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */

        b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */

        a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */

        d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */

        c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */

        b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */

        a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */

        d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */

        c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */

        b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */

        a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */

        d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */

        c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */

        b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */

        /* Round 2 */

        a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */

        d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */

        c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */

        b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */

        a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */

        d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */

        c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */

        b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */

        a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */

        d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */

        c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */

        b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */

        a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */

        d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */

        c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */

        b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */

        /* Round 3 */

        a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */

        d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */

        c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */

        b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */

        a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */

        d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */

        c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */

        b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */

        a = HH(a, b, c, d x[13], S31, 0x289b7ec6L); /* 41 */

        d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */

        c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */

        b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */

        a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */

        d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */

        c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */

        b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */

        /* Round 4 */

        a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */

        d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */

        c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */

        b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */

        a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */

        d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */

        c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */

        b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */

        a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */

        d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */

        c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */

        b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */

        a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */

        d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */

        c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */

        b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */

        state[0] += a;

        state[1] += b;

        state[2] += c;

        state[3] += d;

    }

    /* Encode把long数组按顺序拆成byte数组，因为java的long类型是64bit的，*/

    /* 只拆低32bit，以适应原始C实现的用途. */
    private void Encode(byte[] output, long[] input, int len) {

        int i, j;

        for (i = 0, j = 0; j < len; i++, j += 4) {

            output[j] = (byte) (input[i] & 0xffL);

            output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);

            output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);

            output[j + 3] = (byte) ((input[i] >>> 24) & 0xffL);

        }

    }

    /* Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的，*/

    /* 只合成低32bit，高32bit清零，以适应原始C实现的用途. */
    private void Decode(long[] output, byte[] input, int len) {

        int i, j;

        for (i = 0, j = 0; j < len; i++, j += 4)

            output[i] = b2iu(input[j]) |

                    (b2iu(input[j + 1]) << 8) |

                    (b2iu(input[j + 2]) << 16) |

                    (b2iu(input[j + 3]) << 24);

        return;

    }

    /* b2iu是一个把byte按照不考虑正负号的原则的＂升位＂程序，因为java没有unsigned运算 */
    public static long b2iu(byte b) {

        return b < 0 ? b & 0x7F + 128 : b;

    }

    /* byteHEX()，用来把一个byte类型的数转换成十六进制的ASCII表示，*/

    /* 因为java中的byte的toString无法实现这一点，我们又没有C语言中的sprintf(outbuf,"%02X",ib). */
    public static String byteHEX(byte ib) {

        /* if want to output normal letter please user DigitNormal */

        char[] DigitNormal = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

                              'a', 'b', 'c', 'd', 'e', 'f'};

        /* if want to output capitalization letter please user DigitCap */

        /* char[] DigitCap = { '0','1','2','3','4','5','6','7','8','9',

        'A','B','C','D','E','F' }; */

        char[] ob = new char[2];

        ob[0] = DigitNormal[(ib >>> 4) & 0X0F];

        /* ob[0] = DigitCap[(ib >>> 4) & 0X0F]; */

        ob[1] = DigitNormal[ib & 0X0F];

        /* ob[1] = DigitCap[ib & 0X0F]; */

        String s = new String(ob);

        return s;
    }

    public byte[] getMD5(byte[] data1 , byte[] data2) {
        md5Init();

        md5Update(data1, data1.length);

        md5Update(data2, data2.length);

//        md5Update(Request.key , Request.key.length);

        md5Final();

        return digest;
    }

}

不多说了，直接贴代码

 /*图像变换*/
 public Image scaleImage(Image src,int scales1,int scales2)
 {
  return transImage(src,src.getWidth()*scales1/scales2,src.getHeight()*scales1/scales2);
 }
 public Image transImage(Image src, int w, int h)
 {
    int srcW = src.getWidth();
    int srcH = src.getHeight();
    int dstW=w,dstH=h;
    Image tmp = Image.createImage(dstW, srcH);
    Graphics g = tmp.getGraphics();
    int scale=16;   
  int delta = (srcW << scale) / dstW;//扫描长度
    int pos = delta / 2;//扫描位置
    for (int x = 0; x < dstW; x++)
    {
      g.setClip(x, 0, 1, srcH);
      g.drawImage(src, x - (pos >> scale), 0, Graphics.LEFT | Graphics.TOP);
      pos += delta;
    }
    Image dst = Image.createImage( dstW, dstH);
    g = dst.getGraphics();
    delta = (srcH << scale) / dstH;
    pos = delta / 2;
    for (int y = 0; y < dstH; y++)
    {
      g.setClip(0,y, dstW, 1);
      g.drawImage(tmp, 0, y - (pos >> scale), Graphics.LEFT | Graphics.TOP);
      pos += delta;
    }
    return dst;
 } 

用法举例:

1.将一张图片pic转换成176*208的图

pic=transImage(pic,176,208);

2.将一张图片pic转换成原来的两倍大

pic=scaleImage(pic,2,1);

3.将一张图片pic转换成原来的三分之二

pic=scaleImage(pic,2,3);

从上面的例子，大家应该知道怎么用了吧，呵呵

这段时间因为开发上要用到本地文件，因此开始接触Jsr75的包，Jsr75分两个部分，一部分是File，即本地文件系统，一部分是PIM，说白了就是电话本之类的信息，我先学习的是File部分，通过import javax.microedition.io.file.*里的包，可以实现自由访问本机的文件系统，就跟Windos里的资源管理器一样，在这里我介绍几个我写的方法

一.获取指定路径的目录和文件列表

 /*目录文件列表*/
 public Vector list(String path)
 {
  try
  {
   FileConnection fc=(FileConnection)(Connector.open(path));
   if(fc.exists())
   {
    Vector listVec=new Vector(0,1);
    Enumeration en=fc.list();
    while(en.hasMoreElements())
    {
     listVec.addElement((String)(en.nextElement()));
    }
    return listVec;
   }
   else
   return null;
  }
  catch(Exception e)
  {
   System.out.println("listErr:"+e.toString());
   return null;   
  }
 }

方法里的path参数就是要查找的路径，比如file:///c:/pictures/，切记，如果是目录Path，那么后面的/一定不能省，否则会查找不到内容。这个方法返回的是一个包含了指定Path下的所有目录名和文件名的向量。

二.建立或者保存一个文件到指定路径

 /*保存文件*/
 public void saveFile(String path,byte[] fileData)
 {
  try
  {
   FileConnection fc=(FileConnection)(Connector.open(path));
   fc.create();
   fc.setWritable(true);
   OutputStream os=fc.openOutputStream();
   os.write(fileData);
   os.close();
  }
  catch(Exception e)
  {
   System.out.println("saveFileErr:"+e.toString());
  }
 } 

fileData是需要保存的文件内容，可以是声音，也可以是图像，或者文字之类

三.删除指定文件

 /*删除文件*/
 public void deleteFile(String path)
 {
  try
  {
   FileConnection fc=(FileConnection)(Connector.open(path));
   if(fc.exists())
   fc.delete();
  }
  catch(Exception e)
  {
   System.out.println("deleteFileErr:"+e.toString());
  }
 }

这个方法就不用多解释了

四.读取指定文件

 /*读取文件*/
 public byte[] readFile(String path)
 {
  try
  {
   FileConnection fc=(FileConnection)(Connector.open(path));
   if(fc.exists())
   {
    InputStream is=fc.openInputStream();
    byte[] temp=new byte[is.available()];
    is.read(temp);
    is.close();
    return temp;
   }
   else
   return null;
  }
  catch(Exception e)
  {
   System.out.println("readFileErr:"+path+e.toString());
   return null;
  }
 }

此方法也不用多解释了。

以上是关于文件操作的最基本的一些功能，也是第一期的学习笔记研究到的内容，更多的内容，过几天继续研究继续写吧，呵呵。

有不少朋友问我为什么摩托的手机在音效方面会有问题，典型的表现是声音在模拟器上打开和关闭不会有问题，但在真机上就会出现关闭声音后无法再开启的问题，其原因很大可能是大家在关闭音效的时候只是调用了stop()，却没有调用deallocate()方法，摩托和NOKIA在这一点不同，NOKIA是不能用Deallocate，MOTO却是必须调用，否则下次打开声音会发生问题。

      不知不觉，从游戏转到应用上已经快三个月了，这三个月来的工作，只能用一个词--惬意来形容，再也不用像过去那样成天担心移动的评审，上线，成天面对公司的催活，一个月出N个游戏了，现在一个项目要做好几个月，每一行代码都是自己的心血，都带着一种浓浓的成就感，而不像过去那样写来写去都是换皮之作，没有多少东西是属于自己的。这样的工作，才让人有进取心，有动力去写。

    昨天晚上的兰牙大战，赛前本来还期待是一场比较精彩的比赛，毕竟这是开赛以来第一次种子队在淘汰赛里对决，结果，96分钟下来，上演的是一场裁判的个人秀和火药味十足的群殴。不过这对于我们这些熬夜看球的真球迷或者伪球迷来说，倒也是一场“经典”的比赛。

    整场比赛从C罗被荷兰狂踹下场，荷兰球员却只领到一张黄牌开始就步入了野蛮，可以说这是裁判最大的失误，由此开始，裁判已经控制不住场上的局势，之后葡萄牙的6号积极申请红牌，菲哥一怒之下染黄，荷兰人肘击菲哥吃红，荷兰人在葡萄牙队员疗伤回场后不把球开回葡萄牙，被愤怒的
Deco狂铲倒地，双方各吃一黄，再以后。。。剪刀腿，铁头功，满天飞的黄红牌把这场比赛演变成了一场黑社会火拼大戏，但相对而言，荷兰人更为无耻，尤其是某队员在射门结束后并不收腿，硬生生踹在里卡多身上还装作啥事没有的镜头，让BBS全版愤怒了，声讨之文充斥版面，荷兰踢球之脏，从小组赛里跟大象对决开始就表现得越发的嚣张，那一场比赛里有裁判的偏袒，使荷兰人越发的不可收拾，有个网友说得好，荷兰人要技术没技术，要力量没力量，于是只有靠犯规了，这么肮脏的踢法，最终还是没有扭转他们被葡萄牙淘汰的命运，真是可叹，巴斯腾也该好好反省一下了。

这两天心情不知道怎么回事，莫名的感到不爽，总感觉有什么东西压在心上，却又捉摸不清．按说刚换了工作，一切是个新的开始，应该会意气风发，但我却觉得自己的心里有一种很沧桑的滋味在涌动，为什么这么累呢，从早到晚都在听着伤感的歌，脑子里跟灌了铅似的，无法思考任何东西．

     辞职两个周了，下星期该去新公司上班了，这两星期一直在家玩儿，也算是放松一下自己的心情，结果今天突然听风过说Move2008出事了，我一听头就大了，因为我一直很支持他们，对狼狼（亚俊兄）也是一直很佩服和支持的一个人，没想到这事是因他而起。当然，事情的真相以及内幕，我做为一个局外人，是无从得知的，只是从他的博客的文章还有别人的评议中能知道知言片语，看到这么多人攻击狼狼，我也很难受，人最郁闷的事情就是在自己辛苦拼搏的过程中却出现这么多不和谐甚至是让人悲伤的坎坷，很多事情确实不是自己所期望的，也不是自己意料得到的，一件不经意的小事，也许会酿成很大的风波。

     再联想到自己，虽然暂时还没有出现到类似的事情，但不能保证不会有这么一天也成为众矢之的，不过担心又有什么用呢，唯一可行的就是不断的修行，提高自己，不光是做事，也有做人，虽然人生是曲折的，但努力把这些曲折尽量减少便是一种成功吧。

2.0提供了对Image更多的信息的操作，因此可以方便的实现半透明的效果，这里就给出一个创建半透明图的方法

 /*得到指定透明度的一张图的透明图*/
 public Image createARGBImage(Image src,int Alpha)
 {
  int[] rgb=new int[src.getWidth()*src.getHeight()];
  menuBg.getRGB(rgb,0,src.getWidth(),0,0,src.getWidth(),src.getHeight());
  for(int i=0;i  rgb[i]+=Alpha;
  return(Image.createRGBImage(rgb,src.getWidth(),src.getHeight(),true));  
 }

用这个方法可以方便的得到一张指定透明度的图，但相应的，这样得到的带透明度的图所占用的内存大概是直接创建一张普通图片的内存的2倍。

在游戏中经常要用到一些图片翻转的效果，在１。０里可以用NOKIA的API，或者用２。０的标准API，但由于用２。０的API经常会被移动打回来，所以我写了一个１。０的标准Api实现图片翻转的方法，如下：

 /*图片翻转效果*/
 public void drawTransImage(Graphics g1,Image image,int x,int y,int type)
 {
  if(type==0)//左右翻转
  {
   for(int i=0;i   drawClipImage(g1,image,x+i,y,1,image.getHeight(),image.getWidth()-i,0);
  }
  else
  {
   for(int i=0;i   drawClipImage(g1,image,x,y+i,image.getWidth(),1,0,image.getHeight()-i);
  }
 }

 /*画小图*/
 public void drawClipImage(Graphics g,Image a,int clipx,int clipy,int clipw,int cliph,int offx,int offy)
 {
  int x,y,w,h;
  x=g.getClipX();
  y=g.getClipY();
  w=g.getClipWidth();
  h=g.getClipHeight();
  g.setClip(clipx,clipy,clipw,cliph);
  g.drawImage(a,clipx-offx,clipy-offy,0);
  g.setClip(x,y,w,h);
 } 

这些天有不少朋友问到我同一个Bug，就是游戏中经常会出现线程变快的情况，比如在游戏界面中退出到菜单再点击“继续游戏”后进入到游戏界面后，整个画面都变快了，其这个问题很简单，都是TimerTask惹的祸。不少人喜欢用TimerTask来做为线程实现方式，而一般在点击开始游戏或者继续游戏时都执行了线程的启动方法，其直接结果就是让同一个TimerTask对象被启动了多次，而他们都执行着同样的任务，这就使得整个游戏界面都变快了，解决的办法也很简单，方法一，在退出到主菜单的时候都调用一下该TimerTask的Cancel方法，方法二，退出到主菜单的时候让该线程空跑（即让该线程的Run方法不执行任何操作），而在点击开始游戏或继续游戏时要判断该线程是不是处于Cancel状态，如果不是，就不再启动该线程，这样一般就能够解决这个问题了。：）

春花如梦去，

秋月踏云来，

把酒愁销尽，

独醉难释怀，

长袖何处舞，

短歌且当哭，

拔剑心戚戚，

千杯无人扶。

悲己空寂寞，

油尽灯欲枯，

聚时不知味，

散时方忆福

风舞九天叶飘零，

长夜当歌醉独行，

赤足未觉泥中刺，

醒时已是血淋淋。

怒时长剑啸向天，

狂沙乱草改容颜，

路人冷笑摇手去，

力尽衰倒大道边

这个算法比先前的算法效率提高了１０倍

import java.lang.*;
import javax.microedition.lcdui.*;
import java.util.*;
import javax.microedition.rms.*;
import java.io.*;
class MainPit extends Canvas implements Runnable
{
 
Graphics gb;
Image bufImg;

private int nWidth = getWidth();
private int nHeight = getHeight();
int[] x;
int[] y;
int[] id;
int top,bottom;
public MainPit()
{
try{
bufImg = Image.createImage(nWidth,nHeight);
}catch(Exception e){System.out.println(e+" createImage");}
gb = bufImg.getGraphics();
}

public void paint(Graphics g)
{
g.drawImage(bufImg,0,0,0);
}

int nodes[][] = {//8/
{20,100},//0
{100,40},//1
{150,80},//2
{60,50},
//{150,110},//3
{150,150},//4
//{160,150},//5
//{110,110},//6
{50,130},//7
{160,140},
{60,139},
{110,45}
};
public void sort(int nodes[][])
{
 int i=nodes.length;
 int temp1=0;
 int temp2=0;
 for(int m=0;m for(int n=0;n {
  if(nodes[n][0]>nodes[n+1][0]||(nodes[n][0]==nodes[n+1][0]&&nodes[n][1]>nodes[n+1][1]))
  {
   temp1=nodes[n][0];
   temp2=nodes[n][1];
   nodes[n][0]=nodes[n+1][0];
   nodes[n][1]=nodes[n+1][1];
   nodes[n+1][0]=temp1;
   nodes[n+1][1]=temp2;
  }
 }
}
public void sortTang(int nodes[][])
{
 id=new int[nodes.length-1];
 int[] high=new int[id.length];
 int[] low=new int[id.length];
 for(int i=0;i {
  id[i]=-1;//序号数组
  high[i]=-1;
  low[i]=-1;
 }
 int Htag,Ltag;
 Htag=0;
 Ltag=0;
 for(int i=1;i {
  if(nodes[i][1]<=nodes[0][1])
  high[Htag++]=i;
  else
  low[Ltag++]=i;
 }
 for(int i=0;i {
  if(high[i]>0)
  id[i]=high[i];
  else
  id[i]=low[Ltag-1-i+Htag];
 }
 top=0;
 bottom=id.length-1;
}
/*判断点x2,y2是不是在指定的线段上*/
public boolean cut(int x0,int y0,int x1,int y1,int x2,int y2)
{
 if(((y1-y0)*(x2-x0)<=(y2-y0)*(x1-x0))&&((y1-y0)*(x2-x0)>=(y2-1-y0)*(x1-x0)))
 return true;
 else
 return false;
}
public int findNextPoint(int[][] nodes,int a,boolean s)
{
 if(a==nodes.length-3)
 return a+2;
 else
 {    if(id[top]==a+1)
    {
     top++;
     return id[bottom];
    }
    else
    {
     bottom--;
     return id[top];
    }
 }
}
public void fillPolygon(int nodes[][])
{
 gb.setColor(0xff0000);
 int tempy1=nodes[0][1];
 int tempy2=0;
 int nextP=0;
 int p1=0;
 int p2=0;
 int p3=0;
 int p4=0;
 int scanp1=-1;
 int scanp2=-1;
 for(int i=0;i {
  nextP=0;
  if(nodes[i][0]  {
   if(tempy1!=nodes[i][1])
   nextP=findNextPoint(nodes,i,tempy1>=nodes[i][1]?true:false);
   else
   if((nodes[i+1][1]-nodes[i][1])*(nodes[i+2][0]-nodes[i][0])<(nodes[i+2][1]-nodes[i][1])*(nodes[i+1][0]-nodes[i][0]))
   nextP=findNextPoint(nodes,i,true);
   else
   nextP=findNextPoint(nodes,i,false);
   if((nodes[i+1][1]-nodes[nextP][1])*(nodes[i][1]-tempy1)>=0)
   p3=tempy1;
   else
   p3=nodes[i][1];
   for(int j=0;j   {
    if(cut(nodes[i][0],p3,nodes[nextP][0],nodes[nextP][1],nodes[i+1][0],j))
    {
     tempy2=j;
     break;
    }
   }
   p1=nodes[i][1]>tempy1?tempy1:nodes[i][1];
   p2=p1!=tempy1?tempy1:nodes[i][1];
   p3=nodes[i+1][1]>tempy2?tempy2:nodes[i+1][1];
   p4=p3!=tempy2?tempy2:nodes[i+1][1];
   scanp1=p1;
   scanp2=p2;
   for(int j=nodes[i][0];j<=nodes[i+1][0];j++)
   {
    for(int m=scanp1>p3?p3:scanp1;m<=(scanp1>p3?scanp1:p3);m++)
    {
     if(cut(nodes[i][0],p1,nodes[i+1][0],p3,j,m))
     {
      scanp1=m;
      break;
     }
    }
    for(int m=scanp2>p4?p4:scanp2;m<=(scanp2>p4?scanp2:p4);m++)
    {
     if(cut(nodes[i][0],p2,nodes[i+1][0],p4,j,m))
     {
      scanp2=m;
      break;
     }
    }   
    gb.drawLine(j,scanp1,j,scanp2);
   }
   tempy1=tempy2;
  }
  else
  {
   gb.drawLine(nodes[i][0],nodes[i][1],nodes[i+1][0],nodes[i+1][1]);
   tempy1=nodes[i][1];
   bottom--;
  }
 }
}
private void drawPolygon(int nodes[][])
{
gb.setColor(0x0000ff00);
for(int i = 0; i < nodes.length; i++){
gb.drawLine(nodes[i][0],nodes[i][1],nodes[i][0],nodes[i][1]);
gb.drawString(String.valueOf(nodes[i][0])+"."+String.valueOf(nodes[i][1]),nodes[i][0],nodes[i][1],0);
}
}
public void run()
{
x=new int[nodes.length];
y=new int[nodes.length];
for(int i=0;i{
 x[i]=nodes[i][0];
 y[i]=nodes[i][1];
} 
gb.setColor(0x00ffffff);
gb.fillRect(0,0,nWidth,nHeight);
gb.setColor(0);
long time1=0;
long time2=0;
sort(nodes);
sortTang(nodes);
time1=System.currentTimeMillis();
//fillPolygon(gb,x,y);
fillPolygon(nodes);
time2=System.currentTimeMillis();
System.out.println(time2-time1);
drawPolygon(nodes);
System.out.println("done1");
repaint();
}

private void pause(long t)
{
try{Thread.sleep(t);}catch(Exception e){}
}
public void keyPressed(int keyCode)
  {

} 
}

import java.lang.*;
import javax.microedition.lcdui.*;
import java.util.*;
import javax.microedition.rms.*;
import java.io.*;
class MainPit extends Canvas implements Runnable
{
Graphics gb;
Image bufImg;

private int nWidth = getWidth();
private int nHeight = getHeight();

public MainPit()
{
try{
bufImg = Image.createImage(nWidth,nHeight);
}catch(Exception e){System.out.println(e+" createImage");}
gb = bufImg.getGraphics();
}

public void paint(Graphics g)
{
g.drawImage(bufImg,0,0,0);
}

int nodes[][] = {//8/
{20,100},//0
{100,40},//1
{150,80},//2
{60,50},
//{150,110},//3
{150,150},//4
//{160,150},//5
//{110,110},//6
{50,130},//7
{160,140},
{60,139},
{110,45}
};
public void sort(int nodes[][])
{
 int i=nodes.length;
 int temp1=0;
 int temp2=0;
 for(int m=0;m for(int n=0;n {
  if(nodes[n][0]>nodes[n+1][0]||(nodes[n][0]==nodes[n+1][0]&&nodes[n][1]>nodes[n+1][1]))
  {
   temp1=nodes[n][0];
   temp2=nodes[n][1];
   nodes[n][0]=nodes[n+1][0];
   nodes[n][1]=nodes[n+1][1];
   nodes[n+1][0]=temp1;
   nodes[n+1][1]=temp2;
  }
 }
}
/*判断点x2,y2是不是在指定的线段上*/
public boolean cut(int x0,int y0,int x1,int y1,int x2,int y2)
{
 if(((y1-y0)*(x2-x0)<=(y2-y0)*(x1-x0))&&((y1-y0)*(x2-x0)>=(y2-1-y0)*(x1-x0)))
 return true;
 else
 return false;
}
public int findNextPoint(int[][] nodes,int a,boolean s)
{
 int min=0;
 int max=0; 
 if(a==nodes.length-3)
 return a+2;
 else
 {
  min=a+1;
  max=a+1;
  for(int j=a+2;j &nsp;{
   if((nodes[j][1]-nodes[a][1])*(nodes[min][0]-nodes[a][0])<(nodes[min][1]-nodes[a][1])*(nodes[j][0]-nodes[a][0]))
   {
    min=j;
   }
   if((nodes[j][1]-nodes[a][1])*(nodes[max][0]-nodes[a][0])>(nodes[max][1]-nodes[a][1])*(nodes[j][0]-nodes[a][0]))
   {
    max=j;
   }
  }
  if(nodes[min][0]-nodes[max][0]>0)
  return min;
  else
  if(nodes[min][0]-nodes[max][0]<0)
  return max;
  else
  if(min==a+1)
  return max;
  else
  return min;
 }
}
public void fillPolygon(int nodes[][])
{
 sort(nodes);
 gb.setColor(0xff0000);
 int tempy1=nodes[0][1];
 int tempy2=0;
 int nextP=0;
 int p1=0;
 int p2=0;
 int p3=0;
 int p4=0;
 for(int i=0;i {
  nextP=0;
  if(nodes[i][0]  {
   if(tempy1!=nodes[i][1])
   nextP=findNextPoint(nodes,i,tempy1>=nodes[i][1]?true:false);
   else
   if((nodes[i+1][1]-nodes[i][1])*(nodes[i+2][0]-nodes[i][0])<(nodes[i+2][1]-nodes[i][1])*(nodes[i+1][0]-nodes[i][0]))
   nextP=findNextPoint(nodes,i,true);
   else
   nextP=findNextPoint(nodes,i,false);
   if((nodes[i+1][1]-nodes[nextP][1])*(nodes[i][1]-tempy1)>=0)
   p3=tempy1;
   else
   p3=nodes[i][1];
   for(int j=0;j   {
    if(cut(nodes[i][0],p3,nodes[nextP][0],nodes[nextP][1],nodes[i+1][0],j))
    {
     tempy2=j;
     break;
    }
   }
    if((nodes[i][1]-tempy1)*(nodes[i+1][1]-tempy2)>=0)
    p3=nodes[i+1][1];
    else
    p3=tempy2;
    if(p3==nodes[i+1][1])
    p4=tempy2;
    else
    p4=nodes[i+1][1];
    
   for(int j=nodes[i][0];j<=nodes[i+1][0];j++)
   {

    for(int m=1;m<=nHeight;m++)
    {
     if(cut(nodes[i][0],nodes[i][1],nodes[i+1][0],p3,j,m))
     p1=m;
     if(cut(nodes[i][0],tempy1,nodes[i+1][0],p4,j,m))
     p2=m;
    }   
    gb.drawLine(j,p1,j,p2);
   }
   tempy1=tempy2;
  }
  else
  {
   gb.drawLine(nodes[i][0],nodes[i][1],nodes[i+1][0],nodes[i+1][1]);
   tempy1=nodes[i][1];
  }
 }
}
private void drawPolygon(int nodes[][])
{
gb.setColor(0x0000ff00);
for(int i = 0; i < nodes.length; i++){
gb.drawLine(nodes[i][0],nodes[i][1],nodes[i][0],nodes[i][1]);
gb.drawString(String.valueOf(nodes[i][0])+"."+String.valueOf(nodes[i][1]),nodes[i][0],nodes[i][1],0);
}
}
public void run()
{
gb.setColor(0x00ffffff);
gb.fillRect(0,0,nWidth,nHeight);
fillPolygon(nodes);
drawPolygon(nodes);
System.out.println("done1");
repaint();
}

private void pause(long t)
{
try{Thread.sleep(t);}catch(Exception e){}
}
public void keyPressed(int keyCode)
  {

} 
}
 

      血色浪漫，也只有鲜血的颜色和夕阳完美的融和在一起的时候，你才会从心底感动，虽然，你眼里早已是汪洋。

      这本来就是个弱肉强食的社会，不懂得生存，早晚就成了别人锅里的一盘菜。

     不要太多埋怨，埋怨只能证明你就是个弱者，只能眼巴巴看着别人的碗等着有口汤喝，那你除了渣味，还能尝到啥呢。

    村子很穷，一到晚上，汉子们就拉着婆娘们在炕上折腾，很多孩子就是因为父母的无聊而来到这个世上，也不知道等待他们的是什么样的生活。

    这段经典的话让我呆了很久，我不知道我们自己的无聊催生了些什么东西，有什么产物或许会在某一天突然缠在自己身旁，让你目瞪口呆。

    冬天已经越走越近，这一年，又将结束了，天气倒还没有变冷，但我现在的心很冷，上面还有依稀的血迹。不知道有什么东西堵在胸口，是对自己的憎恨，还是对未来的茫然，我突然觉得自己有必要在一个无人的角落大哭一场，把所有抑郁的悲愤统统深埋进黑暗的阴影里，不让别人知晓。我的视野里出现了这么一出场景，无人的天空，空旷的原野，偶尔传来几声狼的声音，鸟也不知道去哪了，或者还会从哪里跳出几只兔子，还带着B4的神情同情的看着我，那模样像是说，小样的，新来的吧。周围除了石头还是石头，也不知道咋还能长出几根枯草，没有生气，但也没死掉，颤微微的在风里舞着，我心里不由跳出一句，活着，真他妈好。还有啥能比活着更幸福？贪婪，让人已经忽略了自己活着的这个事实。

    冬天好慢，还没飘雪，干涩的空气让人难以下咽，偶尔会有几片落叶，轻轻的打着转落下来，砸到一头熟睡的猪，猪没醒，口水哗哗的，估计在怀念自己的祖先，那个挥着九齿耙抱着女人四处Soho的八大爷，娘的，这种好事咋就不能代代相传呢。不过丫也够轻松的了，吃了睡睡了吃，虽然难免挨上一刀，其实。。这世间的万物，包括人，又能逃过一刀么？活一辈子，伤痕累累，行将入土的时候数着身上的刀口，倒还可以骂一句，老子TMD也还是个男人。

百宝箱的游戏都需要有游戏菜单，游戏关于和游戏帮助的信息，为了能够自适应不同的手机，方便作这些信息的显示，我写了如下的类

/*游戏中的一些常用的框架*/
import javax.microedition.lcdui.*;
import java.util.Vector;
class showContent
{
 int w,h;//屏幕的长和宽
 int cw;//字体的宽
 int page,maxPage;//帮助信息中的页码/最大页码
 int rn;//每行最大字数
 int maxR;//每屏最多显示的行数
 int cr;//字体行距
 Vector about;
 Vector help;
 public showContent(int wid,int hei,int charw,int charR,String[] aboutText,String[] helpText)
 {
  about=new Vector(0,1);
  help=new Vector(0,1);
  w=wid;h=hei;cw=charw;cr=charR;
  rn=w/cw;
  maxR=(h-20)/cr;
  page=0;
  for(int m=0;m  {
   int i=1+(aboutText[m].length()-1)/rn;
   for(int p=0;p   {
    if(p    about.addElement((String)(aboutText[m].substring(p*rn,(p+1)*rn)));
    else
    about.addElement((String)(aboutText[m].substring(p*rn)));
   }
  }
  for(int m=0;m  {
   int i=1+(helpText[m].length()-1)/rn;
   for(int p=0;p   {
    if(p    help.addElement((String)(helpText[m].substring(p*rn,(p+1)*rn)));
    else
    help.addElement((String)(helpText[m].substring(p*rn)));
   }
  }
  maxPage=(help.size()-1)/maxR;
 }
 public void showAbout(Graphics g1,int x,int y)//显示关于
 {
  g1.setColor(0);
  g1.fillRect(0,0,w,h);
  g1.setColor(0xffffff);
  for(int i=0;i  {
   g1.drawString((String)(about.elementAt(i)),x,y+i*cr,0);
  }
 }
 /*显示暂停*/
  public void drawPause(Graphics g1)
  {
   g1.setColor(0);
   g1.fillRect(w/2-30,h/2-6,60,30);
   g1.setColor(0xffffff);
   g1.drawRect(w/2-30,h/2-6,60,30);
   g1.drawString("暂停中",w/2-20,h/2,0);
  } 
 public void showHelp(Graphics g1,int x,int y)//显示帮助
 {
  g1.setColor(0);
  g1.fillRect(0,0,w,h);
  g1.setColor(0xffffff);  
  for(int i=0;i  {
   if(page*maxR+i   g1.drawString((String)(help.elementAt(page*maxR+i)),x,y+i*cr,0);
  }
  g1.setColor(0xffff00);
  g1.drawString("按上下方向键翻页",20,h-20,0);
 }
  public void drawMenu(Graphics g1,int x,int y,int row,int w,String[] arrayStr,int no)//显示菜单
  {
     g1.setColor(0xffff00);
     g1.fillRect(x,y,w,arrayStr.length*row);
     g1.setColor(0xffffff);
     g1.drawRect(x,y,w,arrayStr.length*row);
     for(int m=0;m     {
      if(no==m)
      g1.setColor(0x0000ff);
      else
      g1.setColor(0);
      g1.drawString(arrayStr[m],x+5,y+5+m*row,0);
     }  
 }   
}

呵呵，这个类的用法就不细说了，应该很容易看明白的。

在应用中有时候需要用到随机的自然数序列，比如拼图游戏的初始状态的图片顺序，将这个问题简单来说就是将0~n-1的n个数的排列顺序随机打乱，得到新的一个数字序列．下面给出我的做法．

设数组source,goal分别对应打乱前的源序列和最后要得到的新序列

for(int i=0;i{
int pos=rand(source.length-1-i);
goal[i]=source[pos];
source[pos]=source[source.length-1-i];
}  

这种做法只用了一次循环，效率应该比较高（我认为，呵呵），或者也可以用Vector来做．

NOKIA播放OTT的方法 /*创建播放器 S为音乐文件路径 type为类型,1为Tone,5为Wav */ public Sound createPlayer(String s,int type) {     try   {    byte[] byte1,byte2;    byte1=new byte[1000];        InputStream is=getClass().getResourceAsStream(s);    int i =is.read(byte1);    byte2 =new byte[i];    System.arraycopy(byte1,0,byte2,0,byte2.length);    is.close();   return(new Sound(byte2,type));     }   catch(Exception e)   {    return null;   } } 通过这个方法可以创建一个播放器,然后用play()方法就能播放了