语源科技BlogJava-Johnny

迅雷下载开放引擎Demo的 Java版本+注释版

瓢菝的雨夜 — Fri, 02 Nov 2012 09:44:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->package skj.thunder;import com.sun.jna.Native;import com.sun.jna.NativeLong;import ... 阅读全文

瓢菝的雨夜 2012-11-02 17:44 发表评论

POI Excel小工具类

瓢菝的雨夜 — Sun, 21 Oct 2012 09:43:00 GMT

1 package poi.excel;
  2
  3 import java.awt.Graphics;
  4 import java.awt.Image;
  5 import java.awt.image.BufferedImage;
  6 import java.io.ByteArrayOutputStream;
  7 import java.io.FileInputStream;
  8 import java.io.IOException;
  9 import javax.imageio.ImageIO;
10 import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
11 import org.apache.poi.hssf.usermodel.HSSFPatriarch;
12 import org.apache.poi.hssf.usermodel.HSSFPicture;
13 import org.apache.poi.hssf.usermodel.HSSFSheet;
14 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
15
16 /**
17  * poi HSSF 提取点方法
18  * @author sikaijian
19  */
20 public class Excel03Util {
21     /**
22      * 画图片
23      * @param sheet
24      * @param wb
25      * @param startCol
26      * @param startRow
27      * @param endCol
28      * @param endRow
29      * @param pictureIndex 图片索引号需要先在workbook中加入图片资源
30      * @throws IOException
31      * @author sikaijian
32      */
33     public static void drawPicture(HSSFSheet sheet, HSSFWorkbook wb,
34             short startCol, int startRow, short endCol, int endRow,
35             int pictureIndex) throws IOException {
36         // 图片容器
37         HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
38
39         // 锚点容器下锚位置
40         HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 0, 255, startCol,
41                 startRow, endCol, endRow);
42         anchor.setAnchorType(2);
43
44         // 容器下锚，并载入图片
45         HSSFPicture picture = patriarch.createPicture(anchor, pictureIndex);
46
47         picture.resize();
48         picture.setLineStyle(picture.LINESTYLE_DASHDOTGEL);
49     }
50
51     /**
52      * 加载图片
53      * @param img 图片对象
54      * @param wb
55      * @return 图片索引号
56      * @throws IOException
57      * @author sikaijian
58      */
59     public static int loadPicture(Image img, HSSFWorkbook wb)
60             throws IOException {
61         int pictureIndex;
62         ByteArrayOutputStream arrayOut = null;
63         try {
64             arrayOut = new ByteArrayOutputStream();
65             BufferedImage buImage = new BufferedImage(img.getWidth(null), img
66                     .getHeight(null), BufferedImage.TYPE_INT_RGB);
67             Graphics g = buImage.getGraphics();
68             g.drawImage(img, 0, 0, null);
69             ImageIO.write(buImage, "png", arrayOut);
70
71             byte[] data = arrayOut.toByteArray();
72
73             pictureIndex = wb.addPicture(data, HSSFWorkbook.PICTURE_TYPE_PNG);
74         } finally {
75             if (null != arrayOut) {
76                 arrayOut.close();
77             }
78         }
79
80         return pictureIndex;
81     }
82
83     /**
84      * 加载图片
85      * @param path 图片路径
86      * @param wb
87      * @return 图片索引号
88      * @throws IOException
89      */
90     public static int loadPicture(String path, HSSFWorkbook wb)
91             throws IOException {
92         int pictureIndex;
93         FileInputStream fis = null;
94         ByteArrayOutputStream bos = null;
95         try {
96             fis = new FileInputStream(path);
97             bos = new ByteArrayOutputStream();
98             int c;
99             while ((c = fis.read()) != -1)
100                 bos.write(c);
101             pictureIndex = wb.addPicture(bos.toByteArray(),
102                     HSSFWorkbook.PICTURE_TYPE_PNG);
103         } finally {
104             if (fis != null)
105                 fis.close();
106             if (bos != null)
107                 bos.close();
108         }
109         return pictureIndex;
110     }
111 }
112

瓢菝的雨夜 2012-10-21 17:43 发表评论

希尔排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 09:30:00 GMT

/**
* 希尔排序
* @author sikaijian
*/
public class ShellSort {
    public static void sort(int[] data){
        int d = data.length/2;
        while(d!=0){
            directInsertSort(data, d);
            d/=2;
        }
    }

    /**
     * 带增量的直接插入排序
     * @param data 待排序数组
     * @param d 增量
     */
    private static void directInsertSort(int[] data, int d){
        int len = data.length;

        for(int i=0; i+d            int pCurrent = i+d;
            int left = i-1;
            while(pCurrent                int front = pCurrent-d;
                int key = data[pCurrent];
                while(front>left && data[front]>key){
                    data[front+d] = data[front];
                    front-=d;
                }
                data[front+d] = key;

                pCurrent+=d;
            }
        }
    }

    public static void showArray(int[] array){
        for (int t : array) {
            System.out.print(t);
            System.out.print(" ");
        }
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55, 111, 0 };

        showArray(data);
        System.out.println();
        System.out.println("------------------------------");
        ShellSort.sort(data);

        showArray(data);
    }
}

瓢菝的雨夜 2012-09-21 17:30 发表评论

直接插入排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 06:23:00 GMT

/**
* 直接插入排序
* @author sikaijian
*/
public class DirectInsertSort {
    public static void sort(int[] data){
        int pCurrent = 1;   // 认定第0个数是有序的，从第1个数开始插入排序
        int n = data.length;

        while(pCurrent            int front = pCurrent-1;
            int key = data[pCurrent];

            // 当前要插入的数和左边的有序队列比较（从右往左比较，比较一次移动一次）
            while(front>-1 && key                data[front+1] = data[front];
                front--;
            }

            data[front+1] = key;

            pCurrent++;
        }
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55, 111, 0 };

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("------------------------------");
        DirectInsertSort.sort(data);

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
    }
}

瓢菝的雨夜 2012-09-21 14:23 发表评论

冒泡排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 05:32:00 GMT

/**
* 冒泡排序
* @author sikaijian
*/
public class BubbleSort {
    public static void sort(int[] data){
        if(data.length<=1) return;

/**

* 每一趟排序都把最大的数字放到最后

* 下一趟排序后，最大的数不参加

* 总共n-1趟（n为数组长度）

        for (int i = data.length-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if(data[j]>data[j+1]){
                    int temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;
                }
            }
        }
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55, 111, 0 };

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("------------------------------");
        BubbleSort.sort(data);

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
    }
}

瓢菝的雨夜 2012-09-21 13:32 发表评论

快速排序Java代码

瓢菝的雨夜 — Fri, 21 Sep 2012 03:01:00 GMT

/**
* @author sikaijian
*/
public class QuickSort {

    /**
     * 快速排序算法实现
     * @param data 待排序数组
     * @param left 左边界初始0
     * @param right 右边界初始数组长度-1
     * @author sikaijian
     */
    public static void sort(int[] data, int left, int right) {
        if (left > right)
            return;
        int pHead = left;  // 头部指针
        int pTail = right;  // 尾部指针
        int key = data[left];  // 哨兵

        while (pHead < pTail) {
            // 从右往左遍历，找到比key小的数，放到前面
            while (pHead < pTail && data[pTail] > key) pTail--;
            if (pHead < pTail) data[pHead++] = data[pTail];

            // 从左往右遍历，找到比key大的数，放到后面
            while (pHead < pTail && data[pHead] < key) pHead++;
            if (pHead < pTail) data[pTail--] = data[pHead];
        }

        data[pHead] = key; // 归位

        sort(data, left, pHead-1);  // 排序左边的数组
        sort(data, pHead+1, right);  // 排序右边的数组
    }

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        int[] data = new int[] { 49, 23, 65, 13, 38, 96, 12, 33, 88, 123, 22,
                11, 9, 55 };

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
        System.out.println();
        System.out.println("------------------------------");
        QuickSort.sort(data, 0, data.length - 1);

        for (int t : data) {
            System.out.print(t);
            System.out.print(" ");
        }
    }
}

瓢菝的雨夜 2012-09-21 11:01 发表评论