前言：

当前B/S模式已成为应用开发的主流，而在企业办公系统中，常常有客户这样子要求：你要把我们的报表直接用Excel打开(电信系统、银行系统)。或者是：我们已经习惯用Excel打印。这样在我们实际的开发中，很多时候需要实现导入、导出Excel的应用。

目前，比较常用的实现Java导入、导出Excel的技术有两种Jakarta POI和Java Excel

下面我就分别讲解一下在springMvc（Springboot）中如何使用这两个技术实现导入、导出Excel

一：Jakarta POI方法导入导出Excel文件

Jakarta POI 是一套用于访问微软格式文档的Java API。Jakarta POI有很多组件组成，其中有用于操作Excel格式文件的HSSF和用于操作Word的HWPF，在各种组件中目前只有用于操作Excel的HSSF相对成熟。官方主页http://poi.apache.org/index.html，API文档http://poi.apache.org/apidocs/index.html

1：SXSSFWorkbook和HSSFWorkbook以及XSSFWorkbook的区别

注：
因为微软的excle大致氛围.xls和.xlsx结尾的文件，所以这里就有了XSSF和HSSF的区别，他们的比较如下，建议使用XSSF

• HSSFWorkbook:是操作Excel2003以前（包括2003）的版本，扩展名是.xls；

• XSSFWorkbook:是操作Excel2007后的版本，扩展名是.xlsx；

• SXSSFWorkbook:是操作Excel2007后的版本，扩展名是.xlsx；

比较结果：

• 文件格式
  HSSFWorkbook:是操作Excel2003以前（包括2003）的版本，扩展名是.xls；
  XSSFWorkbook:是操作Excel2007后的版本，扩展名是.xlsx；
  SXSSFWorkbook:是操作Excel2007后的版本，扩展名是.xlsx；
• 最大支持条数
  HSSFWorkbook最大支持65535条数据
  XSSFWorkbook最大支持104万条数据
  SXSSFWorkbook还没遇到限制
• 执行效率
  从POI 3.8版本开始，提供了一种基于XSSF的低内存占用的SXSSF方式。对于大型excel文件的创建，一个关键问题就是，要确保不会内存溢出。其实，就算生成很小的excel（比如几Mb），它用掉的内存是远大于excel文件实际的size的。如果单元格还有各种格式（比如，加粗，背景标红之类的），那它占用的内存就更多了。对于大型excel的创建且不会内存溢出的，就只有SXSSFWorkbook了。它的原理很简单，用硬盘空间换内存（就像hash map用空间换时间一样）。

2：导包：

官方下载：

Apache POI - Download Release Artifacts这里可以下载到它的最新版本和文档。

<!--aapache的导入导出文件工具类-->
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>4.1.2</version>
</dependency>
<dependency>
	   <groupId>org.apache.poi</groupId>
	    <artifactId>poi-ooxml-schemas</artifactId>
	    <version>4.1.2</version>
</dependency>
	<!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
<dependency>
	    <groupId>org.apache.poi</groupId>
	    <artifactId>poi-ooxml</artifactId>
	    <version>4.1.2</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3：Jakarta POI HSSF API组件详解

HSSF（用于操作Excel的组件）提供给用户使用的对象在rg.apache.poi.hssf.usermodel包中,主要部分包括Excel对象，样式和格式，还有辅助操作。有以下几种对象：

常用组件：

SXSSFWorkbook                      excel的文档对象

SXSSFSheet                         excel的表单

SXSSFRow                           excel的行

SXSSFCell                          excel的格子单元

Font                          excel字体

DataFormat                    日期格式

HSSFHeader                        sheet头

HSSFFooter                        sheet尾（只有打印的时候才能看到效果）

样式：

CellStyle                       cell样式

辅助操作包括：

HSSFDateUtil                        日期

HSSFPrintSetup                      打印

HSSFErrorConstants                  错误信息表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

4：简单地动态导出Excel

首先，理解一下一个Excel的文件的组织形式，一个Excel文件对应于一个workbook(HSSFWorkbook)，一个workbook可以有多个sheet（HSSFSheet）组成，一个sheet是由多个row（HSSFRow）组成，一个row是由多个cell（HSSFCell）组成。

基本操作步骤：

1、用HSSFWorkbook打开或者创建“Excel文件对象”
2、用HSSFWorkbook对象返回或者创建Sheet对象
3、用Sheet对象返回行对象，用行对象得到Cell对象
4、对Cell对象读写。

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;
import org.junit.Test;

import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author wkl
 * @create 2022-06-26 10:46
 */
public class TestExsel {
    @Test
    public void test1(){
        //创建HSSFWorkbook对象
        HSSFWorkbook wb = new HSSFWorkbook();
        //创建HSSFSheet对象
        HSSFSheet sheet = wb.createSheet("sheet0");
        //创建HSSFRow对象
        HSSFRow row = sheet.createRow(0);
        //创建HSSFCell对象
        HSSFCell cell=row.createCell(0);
        //设置单元格的值
        cell.setCellValue("单元格中的中文");
        //输出Excel文件
        try {
            FileOutputStream output=new FileOutputStream("d:\\workbook.xls");
            wb.write(output);
            output.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

HSSF读取文件同样还是使用这几个对象，只是把相应的createXXX方法变成了getXXX方法即可。可见只要理解了其中原理，不管是读还是写亦或是特定格式都可以轻松实现，正所谓知其然更要知其所以然。

5：完整实例

1：创建生成excel工具类

package com.macro.mall;

import com.alibaba.fastjson.JSONArray;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellUtil;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFDataFormat;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestExsel {

    public  InputStream exportLargeExcelOfBS(List<String> titles, JSONArray data, Map<String,String> fileSMap) throws IOException {
        InputStream input = null;
        SXSSFWorkbook sxssfWorkbook =null;
        ByteArrayOutputStream os =null;
        try {
            sxssfWorkbook = new SXSSFWorkbook();

            //这些都是设置样式的，不设置都可以
            XSSFCellStyle xssfCellStyleHeader = getAndSetXSSFCellStyleHeader(sxssfWorkbook);
            XSSFCellStyle xssfCellStyleOne = getAndSetXSSFCellStyleOne(sxssfWorkbook);
            XSSFCellStyle xssfCellStyleTwo = getAndSetXSSFCellStyleTwo(sxssfWorkbook);


            Sheet first = sxssfWorkbook.createSheet();
            if(Objects.isNull(fileSMap)){
                for (int i = 0; i < data.size() + 1; i++) {
                    Row row = first.createRow(i);
                    for (int j = 0; j < titles.size(); j++) {
                        //在此可以根据奇偶行调整样式--没啥用
    //                    Cell cell = row.createCell(j);
    //                    cell.setCellStyle(xssfCellStyleOne);
                        if (i == 0) {
                            // 首行
                            Cell cell = row.createCell(j);
                            cell.setCellValue(titles.get(j));
                        } else {

    //                        CellUtil.createCell(row, j, data.getJSONObject(i - 1).getString(titles.get(j)));
                            Cell cell = row.createCell(j);
                            cell.setCellValue(titles.get(j));
                        }
                    }
                }
            }else {
                for (int i = 0; i < data.size() + 1; i++) {
                    Row row = first.createRow(i);
                    for (int j = 0; j < titles.size(); j++) {
                        if (i == 0) {
                            // 首行
                            Cell cell = row.createCell(j);
                            cell.setCellValue(fileSMap.get(titles.get(j)));
                        } else {
                            CellUtil.createCell(row, j, data.getJSONObject(i - 1).getString(titles.get(j)));
                        }
                    }
                }
            }
            setSheet(first);

            //输出Excel文件
            //将workbook转换为流的形式
            input = null;
            os = new ByteArrayOutputStream();
            sxssfWorkbook.write(os);
            input = new ByteArrayInputStream(os.toByteArray());

            //将文件输出本地
//		FileOutputStream output=new FileOutputStream("d:\\workbook.xls");
//		sxssfWorkbook.write(output);
//		output.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                if(sxssfWorkbook != null) {
                    // dispose of temporary files backing this workbook on disk -> 处
                    //     理SXSSFWorkbook导出excel时，产生的临时文件
                    sxssfWorkbook.dispose();
                }
                if(input != null) {
                    input.close();
                }
                if(os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return input;
    }


    /**
     * 设置sheet
     */
    private void setSheet(Sheet sheet) {
        // 设置各列宽度(单位为:字符宽度的1/256)
        sheet.setColumnWidth(0, 32 * 256);
        sheet.setColumnWidth(1, 32 * 256);
        sheet.setColumnWidth(2, 20 * 256);
        sheet.setColumnWidth(3, 20 * 256);
        sheet.setColumnWidth(4, 20 * 256);
        sheet.setColumnWidth(5, 20 * 256);
        sheet.setColumnWidth(6, 20 * 256);
        sheet.setColumnWidth(7, 20 * 256);
        sheet.setColumnWidth(8, 20 * 256);
        sheet.setColumnWidth(9, 20 * 256);
        sheet.setColumnWidth(10, 32 * 256);
    }

    /**
     * 获取并设置header样式
     */
    private XSSFCellStyle getAndSetXSSFCellStyleHeader(SXSSFWorkbook sxssfWorkbook) {
        XSSFCellStyle xssfCellStyle = (XSSFCellStyle) sxssfWorkbook.createCellStyle();
        Font font = sxssfWorkbook.createFont();
        // 字体大小
        font.setFontHeightInPoints((short) 14);
        // 将字体应用到样式上面
        xssfCellStyle.setFont(font);
        // 是否自动换行
        xssfCellStyle.setWrapText(false);
        // 水平居中
        xssfCellStyle.setAlignment(HorizontalAlignment.CENTER);
        // 垂直居中
        xssfCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        return xssfCellStyle;
    }

    /**
     * 获取并设置样式一
     */
    private XSSFCellStyle getAndSetXSSFCellStyleOne(SXSSFWorkbook sxssfWorkbook) {
        XSSFCellStyle xssfCellStyle = (XSSFCellStyle) sxssfWorkbook.createCellStyle();
        XSSFDataFormat format = (XSSFDataFormat)sxssfWorkbook.createDataFormat();
        // 是否自动换行
        xssfCellStyle.setWrapText(false);
        // 水平居中
        xssfCellStyle.setAlignment(HorizontalAlignment.CENTER);
        // 垂直居中
        xssfCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        // 前景颜色
        xssfCellStyle.setFillForegroundColor(IndexedColors.AQUA.getIndex());
        // 边框
        xssfCellStyle.setBorderBottom(BorderStyle.THIN);
        xssfCellStyle.setBorderRight(BorderStyle.THIN);
        xssfCellStyle.setBorderTop(BorderStyle.THIN);
        xssfCellStyle.setBorderLeft(BorderStyle.THIN);
        xssfCellStyle.setBottomBorderColor(IndexedColors.BLACK.getIndex());
        xssfCellStyle.setRightBorderColor(IndexedColors.BLACK.getIndex());
        xssfCellStyle.setTopBorderColor(IndexedColors.BLACK.getIndex());
        xssfCellStyle.setLeftBorderColor(IndexedColors.BLACK.getIndex());
        // 防止数字过长,excel导出后,显示为科学计数法,如:防止8615192053888被显示为8.61519E+12
        xssfCellStyle.setDataFormat(format.getFormat("0"));
        return xssfCellStyle;
    }

    /**
     * 获取并设置样式二
     */
    private XSSFCellStyle getAndSetXSSFCellStyleTwo(SXSSFWorkbook sxssfWorkbook) {
        XSSFCellStyle xssfCellStyle = (XSSFCellStyle) sxssfWorkbook.createCellStyle();
        XSSFDataFormat format = (XSSFDataFormat)sxssfWorkbook.createDataFormat();
        // 是否自动换行
        xssfCellStyle.setWrapText(false);
        // 水平居中
        xssfCellStyle.setAlignment(HorizontalAlignment.CENTER);
        // 边框
        xssfCellStyle.setBorderBottom(BorderStyle.THIN);
        xssfCellStyle.setBorderRight(BorderStyle.THIN);
        xssfCellStyle.setBorderTop(BorderStyle.THIN);
        xssfCellStyle.setBorderLeft(BorderStyle.THIN);
        xssfCellStyle.setBottomBorderColor(IndexedColors.BLACK.getIndex());
        xssfCellStyle.setRightBorderColor(IndexedColors.BLACK.getIndex());
        xssfCellStyle.setTopBorderColor(IndexedColors.BLACK.getIndex());
        xssfCellStyle.setLeftBorderColor(IndexedColors.BLACK.getIndex());
        // 垂直居中
        xssfCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        // 防止数字过长,excel导出后,显示为科学计数法,如:防止8615192053888被显示为8.61519E+12
        xssfCellStyle.setDataFormat(format.getFormat("0"));
        return xssfCellStyle;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199

2：B/S中输出到客户端

public Response excelPoiWeb() throws IOException {
       //开始封装Excel
        InputStream fileInputStream = null;
        ResponseEntity<byte[]> stringResponseEntity = null;
        try {
            fileInputStream = ExporterExcelUtil.exportLargeExcelOfBS(titles, data,fileSMap);
            byte[] tmp = new byte[fileInputStream.available()];

            fileInputStream.read(tmp);
            fileInputStream.close();

            //设置请求头，制定文件类型和文件名称
            String fileName = "导出_"+System.currentTimeMillis();
            MultiValueMap headers = new HttpHeaders();
            headers.add("Content-disposition", "attachment;filename=" + new String(fileName.getBytes("utf-8"), "ISO8859-1") + ".xlsx");

            stringResponseEntity = new ResponseEntity<byte[]>(tmp, headers, HttpStatus.OK);
        } catch (IOException e) {
            LOGGER.error("导出异常：",e);
        }
    }
    这部分代码是B/S模式中采用的输出方式，而不是输出到本地指定的磁盘目录。该代码表示将details.xls的Excel文件通过应答实体（ResponseEntity）输出给请求的客户端浏览器，客户端可保存或直接打开。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

也可以使用如下：

httpResponse.setHeader("Content-Disposition", "attachment;filename=" + fileName + ".xlsx");
        response.setContentType("application/octet-stream;charset=UTF-8");
        OutputStream osOut = response.getOutputStream();
        workbook.write(osOut);
        osOut.flush();
        osOut.close();
1
2
3
4
5
6

6：样式设置

在实际应用中导出的Excel文件往往需要阅读和打印的，这就需要对输出的Excel文档进行排版和样式的设置，主要操作有合并单元格、设置单元格样式、设置字体样式等。

1：单元格合并

    使用HSSFSheet的addMergedRegion()方法
1

public int addMergedRegion(CellRangeAddress region)

参数CellRangeAddress 表示合并的区域，构造方法如下：
1

CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol)

  构造参数依次表示起始行，截至行，起始列， 截至列。
1

2：设置单元格

1、创建HSSFCellStyle

XSSFCellStyle cellStyle= (XSSFCellStyle) sxssfWorkbook.createCellStyle();
1

2、设置样式

// 设置单元格的横向和纵向对齐方式，具体参数就不列了，参考HSSFCellStyle
 
 cellStyle.setAlignment(HSSFCellStyle.ALIGN_JUSTIFY); 
 cellStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
 
 /* 设置单元格的填充方式，以及前景颜色和背景颜色 
  三点注意： 
  1.如果需要前景颜色或背景颜色，一定要指定填充方式，两者顺序无所谓； 
  2.如果同时存在前景颜色和背景颜色，前景颜色的设置要写在前面； 
  3.前景颜色不是字体颜色。 
 */ 
 //设置填充方式(填充图案)
 
 cellStyle.setFillPattern(HSSFCellStyle.DIAMONDS);
 
 //设置前景色 
 cellStyle.setFillForegroundColor(HSSFColor.RED.index);
 
 //设置背景颜色 
 cellStyle.setFillBackgroundColor(HSSFColor.LIGHT_YELLOW.index);
 
 // 设置单元格底部的边框及其样式和颜色 
 // 这里仅设置了底边边框，左边框、右边框和顶边框同理可设 
 cellStyle.setBorderBottom(HSSFCellStyle.BORDER_SLANTED_DASH_DOT); 
 cellStyle.setBottomBorderColor(HSSFColor.DARK_RED.index);
 
 //设置日期型数据的显示样式 
 cellStyle.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy h:mm"));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3、将样式应用于单元格

cell.setCellStyle(cellStyle);

//将样式应用到行，但有些样式只对单元格起作用

row.setRowStyle(cellStyle);
1
2
3
4
5

3：设置字体

1、创建HSSFFont对象（调用HSSFWorkbook 的createFont方法）

HSSFWorkbook wb=new HSSFWorkbook(); 
HSSFFont  fontStyle=wb.createFont();
1
2

2、设置字体各种样式

//设置字体样式 
  fontStyle.setFontName("宋体");   
  //设置字体高度 
  fontStyle.setFontHeightInPoints((short)20);   
  //设置字体颜色 
  font.setColor(HSSFColor.BLUE.index); 
  //设置粗体 
  fontStyle.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD); 
  //设置斜体 
font.setItalic(true); 
//设置下划线 
font.setUnderline(HSSFFont.U_SINGLE);
1
2
3
4
5
6
7
8
9
10
11
12

3、将字体设置到单元格样式

//字体也是单元格格式的一部分，所以从属于HSSFCellStyle

// 将字体对象赋值给单元格样式对象 
cellStyle.setFont(font); 
// 将单元格样式应用于单元格 
cell.setCellStyle(cellStyle);
1
2
3
4

7：导入excel

实现将已存在的Excel文件中的数据导入到系统中的基本步骤同导出十分的类似，关键在于要了解要导入Excel文件的结构，比如数据有哪些列、读取数据起始位置（有效数据从第几行几列开始）等。

//解析Excel
    public void readExcel(String filePath) throws IOException {
        List temp = new ArrayList();
        FileInputStream fileIn = new FileInputStream(filePath);
        //根据指定的文件输入流导入Excel从而产生Workbook对象
        Workbook wb0 = new HSSFWorkbook(fileIn);
        //获取Excel文档中的第一个表单
        Sheet sht0 = wb0.getSheetAt(0);
        //对Sheet中的每一行进行迭代
        for (Row r : sht0) {
            System.out.println("第"+r+"行-----------");
            //如果当前行的行号（从0开始）未达到2（第三行）则从新循环
            if (r.getRowNum() < 1) {
                continue;
            }
            for (int i = 0; i<5; i++) {
                //取出当前行第1个单元格数据
                String stringCellValue = r.getCell(i).getStringCellValue();
                System.out.println(i+":"+stringCellValue);
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

二：java Excel操作Excel文件

Java Excel是一开放源码项目，通过它Java开发人员可以读取Excel文件的内容、创建新的Excel文件、更新已经存在的Excel文件。jxl 由于其小巧 易用的特点, 逐渐已经取代了 POI-excel的地位, 成为了越来越多的java开发人员生成excel文件的首选。Java Excel的特征：

• 支持Excel 95-2000的所有版本

• 生成Excel 2000标准格式

• 支持字体、数字、日期格式化操作

• 支持对单元格加阴影和加色彩；

• 修改存在的工作表；

• 支持图像和图表

• 日志记录可以定制

• 更小更快更省内存

该说以上功能已经能够大致满足我们的需要。最关键的是这套API是纯Java的，并不依赖Windows系统，即使运行在Linux下，它同样能够正确的处理Excel文件。另外需要说明的是，这套API对图形和图表的支持很有限，而且仅仅识别PNG格式。在线帮助文档http://jexcelapi.sourceforge.net/resources/javadocs/2_6_10/docs/index.html

在这里我们将通过一些实例，学习掌握读取、新建、更新，其中也包括常见格式的设置:字体、颜色、背景、合并单元格等操作，有这些其实已经基本足够应付大部分问题了。

1：导包

下载地址 http://www.andykhan.com/jexcelapi/

<!-- https://mvnrepository.com/artifact/net.sourceforge.jexcelapi/jxl -->
        <dependency>
            <groupId>net.sourceforge.jexcelapi</groupId>
            <artifactId>jxl</artifactId>
            <version>2.6.12</version>
        </dependency>
1
2
3
4
5
6

2：实例

 //使用Java Excel Api 导出 Excel文件
    public void ExcelJxl(String filename) throws IOException, WriteException {
        //获得输出流，该输出流的输出介质是客户端浏览器
//        OutputStream output = response.getOutputStream();
 
//        response.reset();
//
//        response.setHeader("Content-disposition", "attachment;           filename=temp.xls");
//
//        response.setContentType("application/msexcel");
 
        FileOutputStream os = new FileOutputStream(filename);
 
        //创建可写入的Excel工作薄，且内容将写入到输出流，并通过输出流输出给客户端浏览
 
        WritableWorkbook wk = Workbook.createWorkbook(os);
        ///创建可写入的Excel工作表
 
        WritableSheet sheet = wk.createSheet("成绩表", 0);
        //把单元格（column, row）到单元格（column1, row1）进行合并。
        //mergeCells(column, row, column1, row1);
        sheet.mergeCells(0, 0, 4, 0);//单元格合并方法
 
        //创建WritableFont 字体对象，参数依次表示黑体、字号12、粗体、非斜体、不带下划线、亮蓝色
        WritableFont titleFont = new WritableFont(WritableFont.createFont("黑体"), 12, WritableFont.BOLD, false, UnderlineStyle.NO_UNDERLINE, Colour.LIGHT_BLUE);
 
        //创建WritableCellFormat对象，将该对象应用于单元格从而设置单元格的样式
 
        WritableCellFormat titleFormat = new WritableCellFormat();
 
        //设置字体格式
        titleFormat.setFont(titleFont);
        //设置文本水平居中对齐
        titleFormat.setAlignment(Alignment.CENTRE);
        //设置文本垂直居中对齐
        titleFormat.setVerticalAlignment(VerticalAlignment.CENTRE);
        //设置背景颜色
        titleFormat.setBackground(Colour.GRAY_25);
        //设置自动换行
        titleFormat.setWrap(true);
 
        //添加Label对象，参数依次表示在第一列，第一行，内容，使用的格式
        Label lab_00 = new Label(0, 0, "学员考试成绩一览表", titleFormat);
 
        //将定义好的Label对象添加到工作表上，这样工作表的第一列第一行的内容为‘学员考试成绩一览表’并应用了titleFormat定义的样式
        sheet.addCell(lab_00);
 
        WritableCellFormat cloumnTitleFormat = new WritableCellFormat();
        cloumnTitleFormat.setFont(new WritableFont(WritableFont.createFont("宋体"), 10, WritableFont.BOLD, false));
 
        cloumnTitleFormat.setAlignment(Alignment.CENTRE);
 
        Label lab_01 = new Label(0, 1, "姓名", cloumnTitleFormat);
 
        Label lab_11 = new Label(1, 1, "班级", cloumnTitleFormat);
 
        Label lab_21 = new Label(2, 1, "笔试成绩", cloumnTitleFormat);
 
        Label lab_31 = new Label(3, 1, "上机成绩", cloumnTitleFormat);
        Label lab_41 = new Label(4, 1, "考试日期", cloumnTitleFormat);
 
        sheet.addCell(lab_01);
 
        sheet.addCell(lab_11);
 
        sheet.addCell(lab_21);
 
        sheet.addCell(lab_31);
 
        sheet.addCell(lab_41);
 
        sheet.addCell(new Label(0, 2, "李明"));
 
        sheet.addCell(new Label(1, 2, "As178"));
        //定义数字格式
 
        NumberFormat nf = new NumberFormat("0.00");
 
        WritableCellFormat wcf = new WritableCellFormat(nf);
 
        //类似于Label对象，区别Label表示文本数据，Number表示数值型数据
 
        Number numlab_22 = new Number(2, 2, 78, wcf);
 
        sheet.addCell(numlab_22);
 
        sheet.addCell(new Number(3, 2, 87, new WritableCellFormat(new NumberFormat("#.##"))));
 
 
        //定义日期格式
 
        DateFormat df = new DateFormat("yyyy-MM-dd hh:mm:ss");
 
        //创建WritableCellFormat对象
        WritableCellFormat datewcf = new WritableCellFormat(df);
 
        //类似于Label对象，区别Label表示文本数据，DateTime表示日期型数据
        DateTime dtLab_42 = new DateTime(4, 2, new Date(), datewcf);
        sheet.addCell(dtLab_42);
        //将定义的工作表输出到之前指定的介质中（这里是客户端浏览器）
 
        wk.write();
        os.flush();
        //操作完成时，关闭对象，释放占用的内存空间
 
        wk.close();
 
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

3：jxl的样式和高级操作

1：数据格式化

在Excel中不涉及复杂的数据类型，能够比较好的处理字串、数字和日期已经能够满足一般的应用即可。

数据的格式化涉及到的是字体、粗细、字号等元素，这些功能主要由 WritableFont和WritableCellFormat类来负责。例如：

//指定了字串格式：字体为宋体，字号16，加粗显示。WritableFont有非常丰富的构造子，供不同情况下使用
① WritableFont font=new WritableFont(WritableFont.createFont("宋体"),12,WritableFont.NO_BOLD );
 
//代码使用了WritableCellFormat类，这个类非常重要，通过它可以指定单元格的各种属性
② WritableCellFormat format1=new WritableCellFormat(font);
 
//使用了Label类的构造子，指定了显示的位置，文本内容，字串被赋予的格式
③ Label label=new Label(0,0,”data 4 test”,format1);
1
2
3
4
5
6
7
8

与Label类似的Number、DateTime，区别Label表示文本数据；Number表示数值数据，可使NumberFormat格式化数据；用DateTime表示日期型数据，可应用DateFormat格式化数据。

2：单元格操作

Excel中很重要的一部分是对单元格的操作，比如行高、列宽、单元格合并等，所幸jExcelAPI提供了这些支持。这些操作相对比较简单，下面只介绍一下相关的API。

1：合并单元格

WritableSheet.mergeCells(int m,int n,int p,int q); 
//作用是从(m,n)到(p,q)的单元格全部合并，比如： 
WritableSheet sheet=book.createSheet(“第一页”,0); 
//合并第一列第一行到第六列第一行的所有单元格 
sheet.mergeCells(0,0,5,0); 
//合并既可以是横向的，也可以是纵向的。合并后的单元格不能再次进行合并，否则会触发异常。
1
2
3
4
5
6

2：行高和列宽

writableSheet.setRowView(int i,int height); 
//作用是指定第i+1行的高度，比如： 
// 将第一行的高度设为200 
sheet.setRowView(0,200); 
WritableSheet.setColumnView(int i,int width); 
//作用是指定第i+1列的宽度，比如： 
//将第一列的宽度设为30 
sheet.setColumnView(0,30);
1
2
3
4
5
6
7
8

4：读取excel文件

public void readExcel(String xlsPath) throws IOException, BiffException {
        FileInputStream fis = new FileInputStream(xlsPath);
        Workbook wk = Workbook.getWorkbook(fis);
        //获取第一张Sheet表
        Sheet sheet = wk.getSheet(0);
        //获取总行数
        int rowNum = sheet.getRows();
 
        //从数据行开始迭代每一行
        for (int i = 2; i < rowNum; i++) {
            //getCell(column,row)，表示取得指定列指定行的单元格（Cell）
            //getContents()获取单元格的内容，返回字符串数据。适用于字符型数据的单元格
            //第i行第一列
            String contents = sheet.getCell(0, i).getContents();
            //第i行第二列
            String contents1 = sheet.getCell(1, i).getContents();
 
            //判断单元格(第i行，第3列)的类型，单元格主要类型LABEL、NUMBER、DATE                 
            if (sheet.getCell(2, i).getType() == CellType.NUMBER) {
 
                //转化为数值型单元格
                NumberCell numCell = (NumberCell) sheet.getCell(2, i);
                //NumberCell的getValue()方法取得单元格的数值型数据
                double value = numCell.getValue();
            }
 
            //第i行，第4列
            if(sheet.getCell(3,i).getType()==CellType.NUMBER){
                NumberCell numCell=(NumberCell)sheet.getCell(3,i);
                double value = numCell.getValue();
            }
 
            if(sheet.getCell(4,i).getType()==CellType.DATE){
                DateCell dateCell=(DateCell)sheet.getCell(4,i);
                //DateCell的getDate()方法取得单元格的日期型数据
                Date date = dateCell.getDate();
            }
 
        }
 
        //关闭流
        fis.close();
        wk.close();
 
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45