|
|
2012年11月2日
摘要: 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年10月21日
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年9月21日
/**
* 希尔排序
* @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<len; i++){
int pCurrent = i+d;
int left = i-1;
while(pCurrent<len){
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);
}
}
/**
* 直接插入排序
* @author sikaijian
*/
public class DirectInsertSort {
public static void sort(int[] data){
int pCurrent = 1; // 认定第0个数是有序的，从第1个数开始插入排序
int n = data.length;
while(pCurrent<n){
int front = pCurrent-1;
int key = data[pCurrent];
// 当前要插入的数和左边的有序队列比较（从右往左比较，比较一次移动一次）
while(front>-1 && key<data[front]){
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(" ");
}
}
}
/**
* 冒泡排序
* @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(" "); } } }
/**
* @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(" ");
}
}
}
|