贴几个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)); 
    }