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