swap(int a, int b) {
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
} 
/**
* 求平方根
* @param value 定義域
* @return 值域
*/
final public static int sqrt(int value) {
    int sqrt = 0;
    for (int k = 0x100000; k != 0; k >>= 2) {
        int tmp = sqrt + k;
        sqrt >>= 1;
        if (tmp <= value) {
            value -= tmp;
            sqrt += k;
        }
    }
    return sqrt;
} 
//原理：先按行縮放，再按列縮放
//測試結果，在50MS以下

package com.gts.Util;


import javax.microedition.lcdui.*;


public class GImageUtil {

    /**
     * 本次縮放操作的所用時間
     * 以毫秒的形式
     */
    public static long timecost = 0;



    /**
     * 快速縮放一個圖片
     * 得到一個不帶透明色的縮放後的圖片
     * 一般耗時在 50ms 以下
     * @param imgSrc - 原始圖片
     * @param scale100 - 縮放比率，以百分比的形式，比如輸入200，表示放大到原始的200%；輸入75，表示縮小到原始的
     75%
     * @return
     */
    public static final Image fastScale(Image imgSrc, int scale100) {
        int width = imgSrc.getWidth();
        int height = imgSrc.getHeight();

        width *= scale100;
        width /= 100;
        height *= scale100;
        height /= 100;

//              return scale(imgSrc, width, height);
        return fastScale(imgSrc, width, height);
    }



    /**
     * 快速縮放
     * @param imgSrc - 原始圖片
     * @param w_new  - 新寬度
     * @param h_new - 新高度
     * @return - 縮放后的圖片
     */
    public static final Image fastScale(Image src, int dstW, int dstH) {
        long time = System.currentTimeMillis();

        int srcW = src.getWidth();
        int srcH = src.getHeight();

        Image tmp = Image.createImage(dstW, srcH);
        Graphics g = tmp.getGraphics();

        int delta = (srcW << 16) / dstW;
        int pos = delta >> 1;

        for (int x = 0; x < dstW; x++) {
            g.setClip(x, 0, 1, srcH);
            g.drawImage(src, x - (pos >> 16), 0, Graphics.LEFT |
                        Graphics.TOP);
            pos += delta;
        }

        Image dst = Image.createImage(dstW, dstH);
        g = dst.getGraphics();

        delta = (srcH << 16) / dstH;
        pos = delta >> 1;

        for (int y = 0; y < dstH; y++) {
            g.setClip(0, y, dstW, 1);
            g.drawImage(tmp, 0, y - (pos >> 16), Graphics.LEFT |
                        Graphics.TOP);
            pos += delta;
        }

//        return dst;


        tmp = null;
        timecost = System.currentTimeMillis() - time;

        return dst;
    }
} 
    /**輪詢次數計數器*/
    static int sort_counter = 0;

    /**交換次數計數器*/
    static int swap_counter = 0;


    /**
     * 冒泡排序法
     * 從小到大
     * @param data - 原始數據
     * @param smallToBig - true if 從小到大; false if 從大到小
     */
    public static final void bubbleSort(int[] data, boolean smallToBig) {
        int high = data.length;

        int sort_start = sort_counter;
        int swap_start = swap_counter;

        for (int i = 0; i < high; i++) {
            for (int j = i; j < high; j++) {
                ++sort_counter;
                if (smallToBig) {
                    if (data[i] > data[j]) {
                        swapData(data, i, j);
                    }
                } else {
                    if (data[i] < data[j]) {
                        swapData(data, i, j);
                    }
                }

            }
        }

        Util.debug("bubbleSort::Sort_Counter::" + (sort_counter -
                sort_start) + "::swap_counter::" + (swap_counter - swap_start));
    }


    /**
     * Quick sort 來排序一個數組
     * 從小到大
     * @param data - 要排序的數組
     * @param smallToBig - true if 從小到大; false if 從大到小
     */
    public static final void quickSort(int[] data, boolean smallToBig) {
        int low = 0;
        int high = data.length - 1;

        int sort_start = sort_counter;
        int swap_start = swap_counter;

        quickSort(data, low, high, smallToBig);

        Util.debug("quickSort::Sort_Counter::" + (sort_counter -
                                                  sort_start) +
                   "::swap_counter::" + (swap_counter - swap_start));
    }


    /**
     * 快速排序
     * @param data - 原始數組
     * @param low -
     * @param high
     */
    private static final void quickSort(int[] data, int low, int high,
                                        boolean smallToBig) {
        if (low < high) {
            int pivot = partition(data, low, high, smallToBig);
            quickSort(data, low, pivot - 1, smallToBig);
            quickSort(data, pivot + 1, high, smallToBig);
        }
    }


    /**
     * 分割點
     * @param data
     * @param low
     * @param high
     * @return
     */
    private static final int partition(int[] data, int low, int high,
                                       boolean smallToBig) {
        //當前位置為第一個元素所在位置
        int pos = low;
        //采用第一個元素位軸
        int pivot = data[pos];

        for (int i = low + 1; i <= high; i++) {
            ++sort_counter;
            if (smallToBig) {
                //從小到大
                if (data[i] < pivot) {
                    ++pos;
                    swapData(data, pos, i);
                }
            } else {
                //從大到小
                if (data[i] > pivot) {
                    ++pos;
                    swapData(data, pos, i);
                }
            }
        }

        swapData(data, low, pos);

        return pos;
    }



    /**
     * 交換數據
     * @param data - 原始數組
     * @param i
     * @param j
     */
    private static final void swapData(int[] data, int i, int j) {
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;

        ++swap_counter;
    }


    /**
     * Build a 8-byte array from a long.  No check is performed on the
     * array length.
     *
     * @param n The number to convert.
     * @param b The array to fill.
     * @return A byte[].
     */
    public static byte[] toBytes(long n, byte[] b) {
        b[7] = (byte) (n);
        n >>>= 8;
        b[6] = (byte) (n);
        n >>>= 8;
        b[5] = (byte) (n);
        n >>>= 8;
        b[4] = (byte) (n);
        n >>>= 8;
        b[3] = (byte) (n);
        n >>>= 8;
        b[2] = (byte) (n);
        n >>>= 8;
        b[1] = (byte) (n);
        n >>>= 8;
        b[0] = (byte) (n);

        return b;
    }


    /**
     * Build a long from first 8 bytes of the array.
     *
     * @param b The byte[] to convert.
     * @return A long.
     */
    public static long toLong(byte[] b) {
        return ((((long) b[7]) & 0xFF)
                + ((((long) b[6]) & 0xFF) << 8)
                + ((((long) b[5]) & 0xFF) << 16)
                + ((((long) b[4]) & 0xFF) << 24)
                + ((((long) b[3]) & 0xFF) << 32)
                + ((((long) b[2]) & 0xFF) << 40)
                + ((((long) b[1]) & 0xFF) << 48)
                + ((((long) b[0]) & 0xFF) << 56));
    }

  

j2me小練習，教學用