导出.xxl类型的Excel的工具类

最新推荐文章于 2023-04-13 10:36:15 发布
最新推荐文章于 2023-04-13 10:36:15 发布
阅读量226 收藏
点赞数
分类专栏： 开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43318174/article/details/114599465
版权

Controller.java

    /**
     * 预约信息数据导出
     * @param exportAO
     * @param request
     * @param response
     */
    @SelectMapping(op = "exportBookingPhoneCard", desc = "预约信息数据导出")
    public void exportBookingPhoneCard(@RequestBody RpcBookingPhoneCardExportAO exportAO, HttpServletRequest request, HttpServletResponse response) {
        logger.info("预约信息数据导出入参，exportAO:{}", JsonUtil.toJson(exportAO));

        try {
            if(exportAO == null || CollectionUtils.isEmpty(exportAO.getIds())){
                throw new ArgsException(AnwserCode.PARAMETER_ERROR);
            }
            //要导出的最终数据【实体里的字段和excel标题个数一样】
            List<RpcBookingPhoneCardExportVO> vos = rpcBookingPhoneCardService.selectBookingPhoneByIds(exportAO.getIds());
            try {
                String fileName = "预约信息数据表";
                //Header一定要这样写，[字段名列名]否则导不出来，而且一定要有小驼峰标识
                String[] HEADER = {"[bookingName]姓名","[provinceName]省份","[cityName]城市","[detailAddress]详细地址","[userPhone]手机号","[bookingPhone]预选号码","[isBenefitPhone]是否为靓号"};
                ExcelUtil.exportExcel(fileName,HEADER , vos, null, request, response);
            } catch (IOException e) {
                logger.error("预约信息数据表导出失败, {}", e);
            }

        } catch (BusinessException e) {
            logger.error(">>> 预约信息数据导出  AwardAndDeductionsController/downloadDeductionsExcel <<<", e);
        } catch (Exception e) {
            logger.error(">>> 预约信息数据导出  AwardAndDeductionsController/downloadDeductionsExcel <<<", e);
            e.printStackTrace();
        }
    }

前端传过来的参数【主键id的List，根据主键id查询库里导出的数据】

@Data
@Accessors(chain = true)
public class RpcBookingPhoneCardExportAO implements Serializable{

    /**
     * 主键id
     */
    private List<Long> ids;

}

导出的数据pojo类型

import lombok.Data;

import java.io.Serializable;

@Data
public class RpcBookingPhoneCardExportVO implements Serializable{
    /**
     * 预约用户姓名
     */
    private String bookingName;

    /**
     * 省名称
     */
    private String provinceName;

    /**
     * 城市名称
     */
    private String cityName;

    /**
     * 详细地址
     */
    private String detailAddress;

    /**
     * 预约用户手机号
     */
    private String userPhone;

    /**
     * 预选号段
     */
    private String bookingPhone;

    /**
     * 是否靓号 0否1是
     */
    private String isBenefitPhone;

}

ExcelUtil.java

import org.slf4j.Logger;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.net.URLEncoder;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConversionException;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;

public class ExcelUtil {
    private static final Logger logger = Logger.getLogger(ExcelUtil.class);
    private static final String FILE_SUFFIX = ".xlsx";

    public ExcelUtil() {
    }

    public static List<Map<String, Object>> importExcel(InputStream input, String[] keys, String fileName, DecimalFormat df) throws Exception {
        Workbook wb = getWorkbook(input, fileName);
        Sheet sheet = wb.getSheetAt(0);
        List<Map<String, Object>> list = new ArrayList();

        for(int rownum = 1; rownum <= sheet.getLastRowNum(); ++rownum) {
            Row row = sheet.getRow(rownum);
            if (row != null) {
                Map<String, Object> map = new HashMap();

                for(int cellnum = 0; cellnum < row.getLastCellNum(); ++cellnum) {
                    Cell cell = row.getCell(cellnum);
                    if (cell != null) {
                        int valType = cell.getCellType();
                        if (valType == 1) {
                            if (cellnum >= keys.length) {
                                break;
                            }

                            map.put(keys[cellnum], cell.getStringCellValue());
                        } else if (valType == 4) {
                            if (cellnum >= keys.length) {
                                break;
                            }

                            map.put(keys[cellnum], cell.getBooleanCellValue());
                        } else if (valType == 0) {
                            if (cellnum >= keys.length) {
                                break;
                            }

                            if (HSSFDateUtil.isCellDateFormatted(cell)) {
                                Date d = cell.getDateCellValue();
                                DateFormat formater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                map.put(keys[cellnum], formater.format(d));
                            } else if (df == null) {
                                map.put(keys[cellnum], cell.getNumericCellValue());
                            } else {
                                map.put(keys[cellnum], df.format(cell.getNumericCellValue()));
                            }
                        }
                    }
                }

                if (!map.isEmpty()) {
                    list.add(map);
                }
            }
        }

        return list;
    }

    public static <T> void exportExcel(String fileName, String[] keys, List<T> list, SimpleDateFormat dateFormat, HttpServletRequest request, HttpServletResponse response) throws Exception {
        //根据浏览器的不同，设置不同的编码格式，避免乱码，获得excel文件名称，
        setFileDownloadHeader(request, response, fileName);
        OutputStream os = response.getOutputStream();
        SXSSFWorkbook wb = new SXSSFWorkbook(1000);
        Sheet sheet1 = wb.createSheet("sheet1");
        Row titleRow = sheet1.createRow(0);

        int j;
        //表头
        for(j = 0; j < keys.length; ++j) {
            //去掉[]，得到剩余的表头
            titleRow.createCell(j).setCellValue(keys[j].replaceAll("\\[.*?\\]", ""));
        }

        //每一列填充对应的List数据
        for(j = 0; j < list.size(); ++j) {
            Row row1 = sheet1.createRow(sheet1.getLastRowNum() + 1);
            
            //每一列
            for(int i = 0; i < keys.length; ++i) {
                String fieldName = "";
                //设置Pattern满足的正则表达式
                Pattern ptn = Pattern.compile("\\[(.+?)\\]");
                //进行匹配，是否包含[]这个的内容
                Matcher matcher = ptn.matcher(keys[i]);
                if (matcher.find()) {
                    //获得分组[]这里边的内容，拿到指定字符内容
                    fieldName = matcher.group(1);
                }
                //反射获得字段值
                Object obj = getFieldValueByName(fieldName, list.get(j));
                if (null != obj) {
                    if (obj instanceof Date) {
                        row1.createCell(i).setCellValue(dateFormat.format(obj));
                    } else {
                        row1.createCell(i).setCellValue(obj.toString());
                    }
                }
            }
        }

        wb.write(os);
        os.flush();
        os.close();
    }

    public static <T> void uploadExcel(String[] keys, List<T> list, String path, String fileName, SimpleDateFormat dateFormat) throws Exception {
        OutputStream os = null;
        File folder = new File(path);
        if (!folder.exists()) {
            folder.mkdirs();
        }

        File file = new File(path + "/" + fileName + ".xlsx");
        os = new FileOutputStream(file);
        SXSSFWorkbook wb = new SXSSFWorkbook(1000);
        wb.setCompressTempFiles(true);
        Sheet sheet1 = wb.createSheet("sheet1");
        Row titleRow = sheet1.createRow(0);

        int j;
        for(j = 0; j < keys.length; ++j) {
            titleRow.createCell(j).setCellValue(keys[j].replaceAll("\\[.*?\\]", ""));
        }

        for(j = 0; j < list.size(); ++j) {
            Row row1 = sheet1.createRow(sheet1.getLastRowNum() + 1);

            for(int i = 0; i < keys.length; ++i) {
                String fieldName = "";
                Pattern ptn = Pattern.compile("\\[(.+?)\\]");
                Matcher matcher = ptn.matcher(keys[i]);
                if (matcher.find()) {
                    fieldName = matcher.group(1);
                }

                Object obj = getFieldValueByName(fieldName, list.get(j));
                if (null != obj) {
                    if (obj instanceof Date) {
                        obj = dateFormat.format(obj);
                    }

                    row1.createCell(i).setCellValue(obj.toString());
                }
            }
        }

        wb.write(os);
        if (os != null) {
            os.close();
            os.flush();
        }

    }

    private static Object getFieldValueByName(String fieldName, Object o) {
        try {
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter);
            Object value = method.invoke(o);
            return value;
        } catch (Exception var6) {
            logger.error(var6.getMessage(), var6);
            return null;
        }
    }

    public static void setFileDownloadHeader(HttpServletRequest request, HttpServletResponse response, String fileName) {
        String userAgent = request.getHeader("USER-AGENT");
        fileName = fileName + ".xlsx";

        try {
            String finalFileName = null;
            if (StringUtils.contains(userAgent, "MSIE")) {
                finalFileName = URLEncoder.encode(fileName, "UTF8");
            } else if (StringUtils.contains(userAgent, "Mozilla")) {
                finalFileName = new String(fileName.getBytes(), "ISO8859-1");
            } else {
                finalFileName = URLEncoder.encode(fileName, "UTF8");
            }

            response.setContentType("application/octet-stream");
            response.setCharacterEncoding("UTF-8");
            response.setHeader("Content-Disposition", "attachment;filename=" + finalFileName);
        } catch (UnsupportedEncodingException var5) {
            logger.error("setFileDownloadHeader:", var5);
        }

    }

    public static Workbook getWorkbook(InputStream inStr, String fileName) throws Exception {
        Workbook wb = WorkbookFactory.create(inStr);
        return wb;
    }

    public static boolean isChinese(String string) {
        int n = false;

        for(int i = 0; i < string.length(); ++i) {
            int n = string.charAt(i);
            if (19968 > n || n >= '龥') {
                return false;
            }
        }

        return true;
    }

    public static void getExcelStyle(SXSSFWorkbook workbook) {
        CellStyle headerStyle = workbook.createCellStyle();
        headerStyle.setAlignment((short)2);
        headerStyle.setVerticalAlignment((short)1);
        headerStyle.setBorderTop((short)1);
        headerStyle.setBorderRight((short)1);
        headerStyle.setBorderBottom((short)1);
        headerStyle.setBorderLeft((short)1);
        headerStyle.setFillForegroundColor((short)42);
        headerStyle.setFillPattern((short)1);
        Font headerFont = workbook.createFont();
        headerFont.setFontHeightInPoints((short)12);
        headerFont.setBoldweight((short)700);
        headerStyle.setFont(headerFont);
        CellStyle cellStyle = workbook.createCellStyle();
        cellStyle.setAlignment((short)2);
        cellStyle.setVerticalAlignment((short)1);
        cellStyle.setBorderTop((short)1);
        cellStyle.setBorderRight((short)1);
        cellStyle.setBorderBottom((short)1);
        cellStyle.setBorderLeft((short)1);
        cellStyle.setWrapText(true);
        Font cellFont = workbook.createFont();
        cellFont.setBoldweight((short)400);
        cellStyle.setFont(cellFont);
    }

    public static void transMap2Bean(Map<String, Object> map, Object obj) {
        ConvertUtils.register(new Converter() {
            public Object convert(Class arg0, Object arg1) {
                if (arg1 == null) {
                    return null;
                } else if (!(arg1 instanceof String)) {
                    throw new ConversionException("只支持字符串转换 !");
                } else {
                    String str = (String)arg1;
                    if (str.trim().equals("")) {
                        return null;
                    } else {
                        SimpleDateFormat sd = new SimpleDateFormat("yyyy/MM/dd");

                        try {
                            return sd.parse(str);
                        } catch (ParseException var6) {
                            ExcelUtil.logger.info("Map<String,Object>转化Bean 日期格式化异常：" + var6);
                            return null;
                        }
                    }
                }
            }
        }, Date.class);
        if (map != null && obj != null) {
            try {
                BeanUtils.populate(obj, map);
            } catch (Exception var3) {
                logger.info("Map<String,Object>转化Bean异常：" + var3);
            }

        }
    }

    public static byte[] writeInto(Object obj) {
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;

        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);
            byte[] var3 = bos.toByteArray();
            return var3;
        } catch (IOException var17) {
            var17.printStackTrace();
            logger.info("对象转换成二级制数据失败, {}", var17);
        } finally {
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException var16) {
                    var16.printStackTrace();
                    logger.info("输出流关闭失败, {}", var16);
                }
            }

            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException var15) {
                    var15.printStackTrace();
                    logger.info("输出流关闭失败, {}", var15);
                }
            }

        }

        return null;
    }

    public static Object restore(byte[] b) {
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try {
            bis = new ByteArrayInputStream(b);
            ois = new ObjectInputStream(bis);
            Object var3 = ois.readObject();
            return var3;
        } catch (IOException | ClassNotFoundException var17) {
            logger.info("二进制数据转回对象失败, {}", var17);
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException var16) {
                    var16.printStackTrace();
                    logger.info("输出流关闭失败, {}", var16);
                }
            }

            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException var15) {
                    var15.printStackTrace();
                    logger.info("输出流关闭失败, {}", var15);
                }
            }

        }

        return null;
    }

    public static void writeExcelCom(List<Map<String, Object>> errorList, String fileName, Integer cellNum) {
        File importFile = new File(fileName);
        InputStream inputStream = null;
        FileOutputStream out = null;

        try {
            logger.error("批量回写数据获取文件名：" + importFile);
            inputStream = new FileInputStream(importFile);
            Workbook workBook = null;

            try {
                workBook = getWorkbook(inputStream, fileName);
            } catch (Exception var25) {
                logger.error("批量回写数据解析文件出错:", var25);
            }

            Sheet sheet = workBook.getSheetAt(0);
            Iterator var8 = errorList.iterator();

            while(var8.hasNext()) {
                Map map = (Map)var8.next();

                try {
                    int line = Integer.parseInt(map.get("line").toString());
                    String content = map.get("content").toString();
                    Row row = sheet.getRow(line);
                    if (row != null) {
                        Cell outPut = row.createCell(cellNum);
                        outPut.setCellValue(content);
                    }
                } catch (Exception var24) {
                    logger.error("批量回写数据文件出错for " + JsonUtil.toJson(map));
                }
            }

            out = new FileOutputStream(fileName);
            workBook.write(out);
        } catch (Exception var26) {
            logger.error("批量回写数据出错:", var26);
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException var23) {
                    logger.error("批量回写数据关闭输出流:", var23);
                }
            }

        }

    }

    public static void exportListExcel(String fileName, List<ExcelUtil.ExcelAo> excelList, SimpleDateFormat dateFormat, HttpServletRequest request, HttpServletResponse response) throws Exception {
        setFileDownloadHeader(request, response, fileName);
        OutputStream os = response.getOutputStream();
        SXSSFWorkbook wb = new SXSSFWorkbook(1000);
        Iterator var7 = excelList.iterator();

        while(var7.hasNext()) {
            ExcelUtil.ExcelAo excelAo = (ExcelUtil.ExcelAo)var7.next();
            Sheet sheet1 = wb.createSheet(excelAo.getSheet());
            Row titleRow = sheet1.createRow(0);

            int j;
            for(j = 0; j < excelAo.getKeys().length; ++j) {
                titleRow.createCell(j).setCellValue(excelAo.getKeys()[j].replaceAll("\\[.*?\\]", ""));
            }

            for(j = 0; j < excelAo.getList().size(); ++j) {
                Row row1 = sheet1.createRow(sheet1.getLastRowNum() + 1);

                for(int i = 0; i < excelAo.getKeys().length; ++i) {
                    String fieldName = "";
                    Pattern ptn = Pattern.compile("\\[(.+?)\\]");
                    Matcher matcher = ptn.matcher(excelAo.getKeys()[i]);
                    if (matcher.find()) {
                        fieldName = matcher.group(1);
                    }

                    Object obj = getFieldValueByName(fieldName, excelAo.getList().get(j));
                    if (null != obj) {
                        if (obj instanceof Date) {
                            row1.createCell(i).setCellValue(dateFormat.format(obj));
                        } else {
                            row1.createCell(i).setCellValue(obj.toString());
                        }
                    }
                }
            }
        }

        wb.write(os);
        os.flush();
        os.close();
    }

    public static class ExcelAo {
        private String sheet;
        private String[] keys;
        private List list;

        public ExcelAo() {
        }

        public String getSheet() {
            return this.sheet;
        }

        public void setSheet(String sheet) {
            this.sheet = sheet;
        }

        public String[] getKeys() {
            return this.keys;
        }

        public void setKeys(String[] keys) {
            this.keys = keys;
        }

        public List getList() {
            return this.list;
        }

        public void setList(List list) {
            this.list = list;
        }
    }
}

直接用的公司导出Excel模板，抄写一份，有的自己还不懂

推荐这两篇博客：https://blog.csdn.net/jiankang66/article/details/89040742

                              https://www.cnblogs.com/jxd283465/p/11763128.html

回忆是昨天里的海
关注
专栏目录
轻松的实现excel导出-springboot环境
北漂的IT小白菜
06-05 943
之前就一直挺反感写excel导入导出的，也不是说实现起来有多难，而是那一连串的建立表格工作簿，然后循环每一列等文件流操作着实让我喜欢不起来呀。 一个偶然的机会，看到国人写了一个xxl-excel的中间件，可以直接拿过来就好。nice。 话不多说，直接上代码。 1.maven依赖 需要说明的是，我这边使用的poi依赖是3.17版本的。 <dependency>...
这份2021Java程序员常用技术栈和工具清单，刷爆了朋友圈...
公众号-老炮说Java
02-02 7024
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达关注公众号后台回复pay或mall获取实战项目资料+视频作为一枚Java程序员，需要掌握哪些技术和工具才能完成一个JavaWeb...
excel表格导出工具类（公用）
11-29
excel表格导出工具类，就是这么个东西不用多做描述了，可以调用
java写的excel万能工具类
08-18
拿着这个工具类，再也不用每天问度娘java怎么快速读取excel了，本人Jayden，欢迎批评指正。
XXL-TOOL的excel组件使用
Z17839935459的博客
07-15 461
写此篇博客的目的是解决上次使用 poi实现导入 遗留的问题 pom.xml <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>4.1.2</version> 工具类： @Target({ElementType.FIELD}) @Retentio..
xxl使用
qq_42511550的博客
03-18 2071
1，yml配置 xxl: job: enabled: true admin: ### 调度中心部署跟地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册； addresses: executor: appname: port: 99...
poi实现对树形结构数据导出excel并合并表格
StreamlineWq的博客
04-04 6636
poi实现对树形结构数据导出excel并合并表格 最近好像得罪了poi，遇到的都是导出word、Excel、pdf的问题。下面我记录一下poi对树形结构的处理，前面先梳理整体思路，文章末尾会贴上完整代码。 首先我们看一下模板和效果图吧： 怎么样，效果还行吧，有没有达到你心目中的标准？如果你也遇到了这样的问题，那么请静下心来花费几分钟时间，我会详细的梳理出自己的思路，希望能够帮助到你。 现在开始...
利用分布式共享锁实现防止方法重复调用
04-14
"利用分布式共享锁实现防止方法重复调用"这一主题，主要涉及到如何通过分布式锁来解决这类问题。本文将深入探讨分布式锁的概念、其在防刷单场景中的应用以及如何利用Redis实现分布式锁。 分布式锁是一种在分布式...
学会这10种定时任务，我有点飘了
weixin_50580200的博客
04-12 655
前言 最近有几个读者私信给我，问我他们的业务场景，要用什么样的定时任务。确实，在不用的业务场景下要用不同的定时任务，其实我们的选择还是挺多的。我今天给大家总结10种非常实用的定时任务，总有一种是适合你的。 一. linux自带的定时任务 crontab 不知道你有没有遇到过这种场景：有时需要临时统计线上的数据，然后导出到excel表格中。这种需求有时较为复杂，光靠写sql语句是无法满足需求的，这就需要写java代码了。然后将该程序打成一个jar包，在线上环境执行，最后将生成的excel文件下载到本地
springboot前后端分离项目如何导出excel数据
Be yourself,everyone else is already taken
12-07 1402
首先前端写好点击事件 handleExport() { this.$alert( <div class="el-message-box--custom-body"> <div style="font-size:16px">确认导出所有数据？</div> </div>, "数据导出", { showCancelButton: true,
Java之——导出Excel通用工具类
热门推荐
冰河的专栏
03-22 5万+
转载请注明出处：https://blog.csdn.net/l1028386804/article/details/79659605 新版地址 https://blog.csdn.net/l1028386804/article/details/103791256 一、概述 相信大家在工作过程中，都会遇到这样一个需求，就是将相关的数据列表导出成excel，那么，有没有通用的导出方式呢，这里，...
java 实现excel批量导入导出功能
最新发布
weixin_61774511的博客
04-13 1174
java实现excel批量导入和导出
XXL-EXCEL v1.1.1 发布，Java对象和Excel转换工具
weixin_34087307的博客
10-24 119
v1.1.1 新特性 1、支持设置Field水平位置，如居中、居左； 2、底层API优化，预约多Sheet操作支持； 3、空Cell导入抛错问题修复； 4、Cell数据类型识别优化，全类型支持； 5、导入时支持空Excel；导出时限制非空，否则无法进行类型推导。 概述 XXL-EXCEL 是一个灵活的Java对象和Excel文档相互转换的工具。 一行代码完成Java对象和Excel之间的转换。...
Java对象和Excel转换工具XXL-EXCE
xiongyouqiang的博客
10-26 4394
《Java对象和Excel转换工具XXL-EXCEL》 一、简介1.1 概述XXL-EXCEL 是在 Java 对象和 Excel 文档之间进行转换的迅速而灵活的工具。一行代码完成Java对象和Excel之间的转换。1.2 特性 1、Excel导出：支持Java对象装换为Excel，并且支持File、字节数组、Workbook等多种导出方式； 2、Excel导入：支持Excel转换为Java
表格处理PoI 3.17 已过时代码对比
weixin_45689081的博客
09-02 583
PoI 3.17 已过时代码对比 颜色定义变化 旧版本 : HSSFColor.BLACK.index 新版本 : IndexedColors.BLACK.index 获取单元格格式 旧版本 : cell.getCellType 与之应对的单元格格式 HSSFCell.CELL_TYPE_BLANK 新版本 : cell.getCellTypeEnum 与之对应的单元格格式 BLANK (org.apache.poi.ss.usermodel.CellType.BLANK) 设置单元格格式 旧版本 : ro
Excel的xml表现格式
有志者事竟成
12-08 1万+
随着即将发布 微软的下一个版本®  办公室（目前代号为“Office 12的”），将有微软的Word，PowerPoint新的默认文件格式®和Excel ®。这些称为Microsoft Office Open XML格式的新格式将为Office开发人员打开一个全新的世界。默认情况下，Office文档将是开放和可访问的，因为它们将使用标准的ZIP和XML技术，并提供完整的文档，并且可以免费使用许
postman测试.csv文件导出
一寸一寸光阴
01-28 1553
1
503问题解决
一寸一寸光阴
10-15 4028
前言 问题出现：同一个服务用jenkins开始部署了一个错误的分支，后来发现错了之后，又用jenkins部署了另外一个正确的，然后接口开始出现远程调用503问题 解决 开始登录服务器的日志，然后使用ps -ef | grep 服务名称 命令查看服务器是否存活着，发现存活着，但是通过Java进程的时间发现出现了同一个服务的两个java进程，第一个java进程是开始部署错分支的java进程，第二个java进程是后来部署正确分支的进程，如下所示，后来思考是否是因为这个问题导致的503问题，然后开...
int类型转double，保留小数点后2位
一寸一寸光阴
06-03 3277
package com.wanshun.common.utils; import java.math.BigDecimal; import java.math.RoundingMode; import java.text.DecimalFormat; /** * @Author 刘长帅 * @create 2019/7/20 10:40 */ public class CurrencyUtil { /** * 保留两位 * @param d * @retu.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值