POI导出Excel(xls、xlsx均可以，也支持图片)——（三）
Jar包
aaarticlea/png;base64,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" alt="" />
有可能也需要: commons-codec-1.11.jar 这个包。
- HSSFXXXXX导出低版本Excel(以xls结尾的excel，如果导出xlsx结尾的excel，打开会报错，必须手动将后缀改为xls才可以正确打开)
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException; import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; public class POIExt03VersionExcel {
public static void main(String[] args) {
String[] title = { "id", "name", "sex" };
// 创建一个工作簿
HSSFWorkbook workbook = new HSSFWorkbook();
// 创建一个工作表sheet
HSSFSheet sheet = workbook.createSheet();
// 创建第一行
HSSFRow row = sheet.createRow(0);
// 创建一个单元格
HSSFCell cell = null;
// 创建表头
for (int i = 0; i < title.length; i++) {
cell = row.createCell(i);
cell.setCellValue(title[i]);
}
// 从第二行开始追加数据
for (int i = 1; i <= 10; i++) {
// 创建第i行
HSSFRow nextRow = sheet.createRow(i);
// 参数代表第几列
HSSFCell cell2 = nextRow.createCell(0);
cell2.setCellValue("a" + i);
cell2 = nextRow.createCell(1);
cell2.setCellValue("user" + i);
cell2 = nextRow.createCell(2);
cell2.setCellValue("男");
}
// 创建一个文件
File file = new File("G:/POI_TEST11.xlsx");
try {
file.createNewFile();
// 打开文件流
FileOutputStream outputStream = new FileOutputStream(file);
workbook.write(outputStream);
outputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } }
导出图片:
导出单个图片
package cn.qlq.test; import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream; import javax.imageio.ImageIO; import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; /**
* 导出单个图片
*
* @author liqiang
*
*/
public class ExtExcelOnePic { public static void main(String[] args) {
FileOutputStream fileOut = null;
BufferedImage bufferImg = null;
try {
ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
// 加载图片
bufferImg = ImageIO.read(new File("e:/1.jpg"));
ImageIO.write(bufferImg, "jpg", byteArrayOut);
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet1 = wb.createSheet("sheet1");
HSSFPatriarch patriarch = sheet1.createDrawingPatriarch();
/**
* dx1 - the x coordinate within the first
* cell.//定义了图片在第一个cell内的偏移x坐标，既左上角所在cell的偏移x坐标，一般可设0 dy1 - the y
* coordinate within the first
* cell.//定义了图片在第一个cell的偏移y坐标，既左上角所在cell的偏移y坐标，一般可设0 dx2 - the x
* coordinate within the second
* cell.//定义了图片在第二个cell的偏移x坐标，既右下角所在cell的偏移x坐标，一般可设0 dy2 - the y
* coordinate within the second
* cell.//定义了图片在第二个cell的偏移y坐标，既右下角所在cell的偏移y坐标，一般可设0 col1 - the
* column (0 based) of the first cell.//第一个cell所在列，既图片左上角所在列 row1 -
* the row (0 based) of the first cell.//图片左上角所在行 col2 - the column
* (0 based) of the second cell.//图片右下角所在列 row2 - the row (0 based)
* of the second cell.//图片右下角所在行
*/
HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 0, 0, (short) 2, 2, (short) 5, 8);
// 插入图片
patriarch.createPicture(anchor, wb.addPicture(byteArrayOut.toByteArray(), HSSFWorkbook.PICTURE_TYPE_JPEG));
fileOut = new FileOutputStream("e:/excel.xls");
// 输出文件
wb.write(fileOut);
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 关于HSSFClientAnchor(dx1,dy1,dx2,dy2,col1,row1,col2,row2)的参数，有必要在这里说明一下：
// dx1：起始单元格的x偏移量，
// dy1：起始单元格的y偏移量，
// dx2：终止单元格的x偏移量，
// dy2：终止单元格的y偏移量，
// col1：起始单元格列序号，从0开始计算；
// row1：起始单元格行序号，从0开始计算，
// col2：终止单元格列序号，从0开始计算；
// row2：终止单元格行序号，从0开始计算，
//添加多个图片时:多个pic应该share同一个DrawingPatriarch在同一个sheet里面。
导出多个图片，多个图片一样
package cn.qlq.test; import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream; import javax.imageio.ImageIO; import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; /**
* 导出多个图片(多个图片一样)
*
* @author liqiang
*
*/
public class ExtExcelMultiPic { public static void main(String[] args) {
FileOutputStream fileOut = null;
BufferedImage bufferImg = null;
try {
ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
// 加载图片
bufferImg = ImageIO.read(new File("e:/2.jpg"));
ImageIO.write(bufferImg, "jpg", byteArrayOut);
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet1 = wb.createSheet("sheet1");
HSSFPatriarch patriarch = sheet1.createDrawingPatriarch();
HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 0, 0, (short) 2, 2, (short) 5, 8);
// 插入图片 1
patriarch.createPicture(anchor, wb.addPicture(byteArrayOut.toByteArray(), HSSFWorkbook.PICTURE_TYPE_JPEG)); // 图片2
anchor = new HSSFClientAnchor(200, 0, 0, 0, (short) 2, 9, (short) 5, 15);
patriarch.createPicture(anchor, wb.addPicture(byteArrayOut.toByteArray(), HSSFWorkbook.PICTURE_TYPE_JPEG));
fileOut = new FileOutputStream("e:/excel.xls");
// 输出文件
wb.write(fileOut);
} catch (Exception e) {
e.printStackTrace();
}
}
}
导出多个图片，图片不一样
package cn.qlq.test; import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream; import javax.imageio.ImageIO; import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPatriarch;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook; /**
* 导出多个图片(多个图片不一样)
*
* @author liqiang
*
*/
public class ExtExcelMultiPic2 { public static void main(String[] args) {
FileOutputStream fileOut = null;
BufferedImage bufferImg = null;
BufferedImage bufferImg1 = null;
try {
ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
ByteArrayOutputStream byteArrayOut1 = new ByteArrayOutputStream();
// 加载图片
bufferImg = ImageIO.read(new File("e:/1.jpg"));
bufferImg1 = ImageIO.read(new File("e:/2.jpg"));
ImageIO.write(bufferImg, "jpg", byteArrayOut);
ImageIO.write(bufferImg1, "jpg", byteArrayOut1);
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet1 = wb.createSheet("sheet1");
HSSFPatriarch patriarch = sheet1.createDrawingPatriarch();
HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 0, 0, (short) 2, 2, (short) 5, 8);
// 插入图片 1
patriarch.createPicture(anchor, wb.addPicture(byteArrayOut.toByteArray(), HSSFWorkbook.PICTURE_TYPE_JPEG)); // 图片2
anchor = new HSSFClientAnchor(200, 0, 0, 0, (short) 2, 9, (short) 5, 15);
patriarch.createPicture(anchor, wb.addPicture(byteArrayOut1.toByteArray(), HSSFWorkbook.PICTURE_TYPE_JPEG));
fileOut = new FileOutputStream("e:/excel.xls");
// 输出文件
wb.write(fileOut);
} catch (Exception e) {
e.printStackTrace();
}
}
}
- XSSFXXXXX导出高版本Excel(以xlsx结尾的excel，如果导出xls结尾的excel，打开会报错，必须手动将后缀改为xlsx才可以正确打开)
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; public class POIExt07VersionExcel {
public static void main(String[] args) {
String[] title = { "id", "name", "sex" };
// 创建一个工作簿
XSSFWorkbook workbook = new XSSFWorkbook();
// 创建一个工作表sheet
Sheet sheet = workbook.createSheet();
// 创建第一行
Row row = sheet.createRow(0);
// 创建一个单元格
Cell cell = null;
// 创建表头
for (int i = 0; i < title.length; i++) {
cell = row.createCell(i);
cell.setCellValue(title[i]);
}
// 从第二行开始追加数据
for (int i = 1; i <= 10; i++) {
// 创建第i行
Row nextRow = sheet.createRow(i);
// 参数代表第几列
Cell cell2 = nextRow.createCell(0);
cell2.setCellValue("a" + i);
cell2 = nextRow.createCell(1);
cell2.setCellValue("user" + i);
cell2 = nextRow.createCell(2);
cell2.setCellValue("男");
}
// 创建一个文件
File file = new File("G:/POI_TEST11.xls");
try {
file.createNewFile();
// 打开文件流
FileOutputStream outputStream = new FileOutputStream(file);
workbook.write(outputStream);
outputStream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } }
最后发现相同数据的excel，以xlsx结尾的确实大小比xls的小，07年office改版的目的就是为了节约内存，所以xlsx的占用内存小:
导出图片:
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream; import javax.imageio.ImageIO; import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFDrawing;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; /**
* 导出单个图片
*
* @author liqiang
*
*/
public class ExtExcelOnePic { public static void main(String[] args) {
FileOutputStream fileOut = null;
BufferedImage bufferImg = null;
try {
ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
// 加载图片
bufferImg = ImageIO.read(new File("e:/1.jpg"));
ImageIO.write(bufferImg, "jpg", byteArrayOut);
XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet1 = wb.createSheet("sheet1");
XSSFDrawing patriarch = sheet1.createDrawingPatriarch();
/**
* dx1 - the x coordinate within the first
* cell.//定义了图片在第一个cell内的偏移x坐标，既左上角所在cell的偏移x坐标，一般可设0 dy1 - the y
* coordinate within the first
* cell.//定义了图片在第一个cell的偏移y坐标，既左上角所在cell的偏移y坐标，一般可设0 dx2 - the x
* coordinate within the second
* cell.//定义了图片在第二个cell的偏移x坐标，既右下角所在cell的偏移x坐标，一般可设0 dy2 - the y
* coordinate within the second
* cell.//定义了图片在第二个cell的偏移y坐标，既右下角所在cell的偏移y坐标，一般可设0 col1 - the
* column (0 based) of the first cell.//第一个cell所在列，既图片左上角所在列 row1 -
* the row (0 based) of the first cell.//图片左上角所在行 col2 - the column
* (0 based) of the second cell.//图片右下角所在列 row2 - the row (0 based)
* of the second cell.//图片右下角所在行
*/
XSSFClientAnchor anchor = new XSSFClientAnchor(0, 0, 0, 0, (short) 2, 2, (short) 5, 8);
// 插入图片
patriarch.createPicture(anchor, wb.addPicture(byteArrayOut.toByteArray(), XSSFWorkbook.PICTURE_TYPE_JPEG));
fileOut = new FileOutputStream("e:/excel.xlsx");
// 输出文件
wb.write(fileOut);
} catch (Exception e) {
e.printStackTrace();
}
}
}
导出多图片类似于上面，这里不再贴代码了。
导出xls用HSSFXXXXX，导出xlsx用XSSFXXXX。。。。。。
补充:
另外补充一种根据Work的类型生成对应图片到版本的Excel的文件的方法:
import java.io.FileInputStream;
import java.io.FileOutputStream; import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Drawing;
import org.apache.poi.ss.usermodel.Picture;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.usermodel.XSSFWorkbook; public class WritePicToExcel07 {
public static void main(String[] args) throws Exception {
/* 写EXCEL，将目标excel中图片写入到新的excel中 */
String basePath = "e:\\"; Workbook wb = new HSSFWorkbook();// 根据这个判断生成对应版本的图片
// Workbook wb = new XSSFWorkbook();//根据这个判断生成对应版本的图片
FileInputStream fis = new FileInputStream(basePath + "1.jpg");
byte[] bytes = IOUtils.toByteArray(fis);
int pictureIdx = wb.addPicture(bytes, wb.PICTURE_TYPE_JPEG);
fis.close(); Sheet sheet = wb.createSheet("sheet1");
// 创建一个顶级容器
Drawing drawing = sheet.createDrawingPatriarch();
CreationHelper helper = wb.getCreationHelper();
ClientAnchor anchor = helper.createClientAnchor();
anchor.setCol1(3);
anchor.setRow1(2);
Picture pict = drawing.createPicture(anchor, pictureIdx);
// auto-size picture relative to its top-left corner
pict.resize();// 该方法只支持JPEG 和 PNG后缀文件
String file = "生成的EXCEL.xls";
if (wb instanceof XSSFWorkbook)
file += "x";
FileOutputStream fos = new FileOutputStream(basePath + file); // Row row = sheet.createRow(0);//生成第一行
// row.createCell(0).setCellValue("A");
// row.createCell(1).setCellValue("B");
wb.write(fos);
fos.close();
}
}
POI导出Excel(xls、xlsx均可以，也支持图片)——（三）的更多相关文章
- 使用NPOI导入导出Excel(xls/xlsx)数据到DataTable中
using System; using System.Collections.Generic; using System.Text; using System.IO; using NPOI.SS.Us ...
- winfrom 使用NPOI导入导出Excel(xls/xlsx)数据到DataTable中
1.通过NUGET管理器下载nopi,在引入命令空间 using System; using System.Collections.Generic; using System.Text; using ...
- java poi导出EXCEL xls文件代码
String _currentPage = request.getParameter("currentPage"); Integer currentPage = 0; if(_cu ...
- 关于poi导出excel方式HSSFWorkbook(xls).XSSFWorkbook(xlsx).SXSSFWorkbook.csv的总结
1.HSSFWorkbook(xls) import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermo ...
- 使用Apache POI导出Excel小结--导出XLS格式文档
使用Apache POI导出Excel小结 关于使用Apache POI导出Excel我大概会分三篇文章去写 使用Apache POI导出Excel小结--导出XLS格式文档 使用Apache POI ...
- POI导出EXCEL经典实现
1.Apache POI简介 Apache POI是Apache软件基金会的开放源码函式库,POI提供API给Java程式对Microsoft Office格式档案读和写的功能. .NET的开发人员则 ...
- 关于poi导出excel三种方式HSSFWorkbook，SXSSFWorkbook，csv的总结
poi导出excel最常用的是第一种方式HSSFWorkbook,不过这种方式数据量大的话会产生内存溢出问题,SXSSFWorkbook是一种大数据量导出格式,csv是另一种excel导出的一种轻快的 ...
- POI导出EXCEL经典实现（转）
http://www.cnblogs.com/xwdreamer/archive/2011/07/20/2296975.html 1.Apache POI简介 Apache POI是Apache软件基 ...
- POI导出Excel和InputStream存储为文件
POI导出Excel和InputStream存储为文件 本文需要说明的两个问题 InputStream如何保存到某个文件夹下 POI生成Excel POI操作utils类 代码如下.主要步骤如下: ...
随机推荐
- day25 初始面向对象
类 有具体规范,无具体值对象 有具体的值 dict 类d = {"":""} 对象 自定义一个类格式: class 类名: # 可以跟()或者不跟 属性 = ' ...
- 自学Aruba7.1-Aruba安全认证-WPA2-PSK认证（web页面配置）
点击返回:自学Aruba之路 自学Aruba7.1-Aruba安全认证-WPA2-PSK认证(web页面配置) 步骤1 建立AP Group,命名为test-group 步骤2 将AP加入到AP G ...
- 自学Zabbix12.2 Zabbix命令-zabbix_get
点击返回:自学Zabbix之路 点击返回:自学Zabbix4.0之路 点击返回:自学zabbix集锦 自学Zabbix12.2 Zabbix命令-zabbix_get 1. zabbix_get概念 ...
- luogu3305/bzoj3130 费用流 (二分答案+dinic)
Bob肯定想挑一个流量最大的边,然后把所有的费用都加给它呗 那Alice就让流量最大的边尽量小呗 那就二分一下答案再dinic呗 #include<bits/stdc++.h> #defi ...
- Java NIO -- 缓冲区(Buffer)的数据存取
缓冲区(Buffer): 一个用于特定基本数据类型的容器.由 java.nio 包定义的,所有缓冲区都是 Buffer 抽象类的子类.Java NIO 中的 Buffer 主要用于与 NIO 通道进行 ...
- C++ 容器：顺序性容器、关联式容器和容器适配器
什么是容器 首先,我们必须理解一下什么是容器,在C++ 中容器被定义为:在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器.很简单,容器就是保存其它对象的对象 ...
- RMQ求解->ST表
ST表 这是一种神奇的数据结构,用nlogn的空间与nlongn的预处理得出O(1)的区间最大最小值(无修) 那么来看看这个核心数组:ST[][] ST[i][j]表示从i到i+(1<<j ...
- HBase基础之常用过滤器hbase shell操作
创建表 create 'test1', 'lf', 'sf' lf: column family of LONG values (binary value) -- sf: column family ...
- JavaSE学习总结（五）——封装，继承，多态很简单
java面向对象的三大特性是:封装.继承与多态,是面向对象编程的核心. 一.封装 简单说封装就是将同一类事物的特性与功能包装在一起,对外暴露调用的接口. 封装:封装也称信息隐藏,是指利用抽象数据类型把 ...
- mysql名词解释
什么是QPS? 单位时间内所处理的事务数 什么是TPS? 单位时间内所处理的查询数 响应时间 并发量 同时处理的查询请求的数量 什么是吞吐量?