j2me小练习，教学用

有用的J2ME功能函数

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