xls To Xlsx

于 2024-08-05 11:27:21 发布
阅读量160 收藏
点赞数 3
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41672950/article/details/140922502
版权

xls 转为 Xlsx的工具类

import lombok.extern.slf4j.Slf4j;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.apache.poi.util.Units;
import org.apache.poi.xssf.usermodel.*;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
public class XlsToXlsxUtil {

    public static ByteArrayOutputStream xlsToXlsx(InputStream inputStream) throws IOException {

        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

        Workbook workbook = WorkbookFactory.create(inputStream);
        HSSFWorkbook xlsWorkbook = null;
        XSSFWorkbook xlsxWorkbook = null;
        if (workbook instanceof HSSFWorkbook){
            xlsWorkbook  = (HSSFWorkbook) workbook;
            xlsxWorkbook = new XSSFWorkbook();
        }else if (workbook instanceof XSSFWorkbook){
            //直接返回流本身
            xlsxWorkbook = (XSSFWorkbook) workbook;
            xlsxWorkbook.write(outputStream);
            return outputStream;
        }else {
            log.error("xls 文件转换 xlsx 文件异常，文件类型错误：{}",workbook.getClass());
            throw new BusinessException("xls 文件转换 xlsx 文件异常，文件类型错误！");
        }

        try {
            int sheetNum = xlsWorkbook.getNumberOfSheets();
            for (int sheetIndex = 0; sheetIndex < sheetNum; sheetIndex++) {
                HSSFSheet hssfSheet = xlsWorkbook.getSheetAt(sheetIndex);
                XSSFSheet xssfSheet = xlsxWorkbook.createSheet(hssfSheet.getSheetName());
                copySheets(hssfSheet, xssfSheet);
            }
            xlsxWorkbook.write(outputStream);
        } catch (Exception e) {
            log.error("文件转换异常", e);
            throw new IOException(e);
        }

        return outputStream;
    }

    public static void copySheets(HSSFSheet source, XSSFSheet destination) {

        int maxColumnNum = 0;
        // 获取全部的合并单元格
        List<CellRangeAddress> cellRangeAddressList = source.getMergedRegions();
        for (int i = source.getFirstRowNum(); i <= source.getLastRowNum(); i++) {
            if (i < 0 || i > 1048576){
                break;
            }
            HSSFRow srcRow = source.getRow(i);
            XSSFRow destRow = destination.createRow(i);
            if (srcRow != null) {
                // 拷贝行
                copyRow(destination, srcRow, destRow, cellRangeAddressList);
                if (srcRow.getLastCellNum() > maxColumnNum) {
                    maxColumnNum = srcRow.getLastCellNum();
                }
            }
        }
        for (int i = 0; i <= maxColumnNum; i++) {
            destination.setColumnWidth(i, source.getColumnWidth(i));
        }

        // 拷贝图片
        copyPicture(source, destination);
        // 拷贝下拉选择
        try {
            copySelect(source, destination);
        } catch (Exception e) {
            log.error("拷贝下拉异常", e);
        }

    }

    private static void copySelect(HSSFSheet source, XSSFSheet destination) {
        List<HSSFDataValidation> dataValidations = source.getDataValidations();
        for(HSSFDataValidation validation: dataValidations) {
            CellRangeAddressList addressList = validation.getRegions();
            if (addressList == null || addressList.countRanges() == 0) {
                continue;
            }
            for (int itemIndex = 0; itemIndex < addressList.countRanges(); itemIndex ++) {
                int row = addressList.getCellRangeAddress(itemIndex).getFirstRow();
                int column = addressList.getCellRangeAddress(itemIndex).getFirstColumn();
                CellRangeAddressList regions = new CellRangeAddressList(addressList.getCellRangeAddress(itemIndex).getFirstRow(), addressList.getCellRangeAddress(itemIndex).getLastRow(),
                        addressList.getCellRangeAddress(itemIndex).getFirstColumn(), addressList.getCellRangeAddress(itemIndex).getLastColumn());
                if (row > -1 && column > -1) {
                    DataValidationConstraint constraint = validation.getValidationConstraint();
                    if (constraint.getExplicitListValues() != null) {
                        DataValidationConstraint constraintnew =
                                destination
                                        .getDataValidationHelper()
                                        .createExplicitListConstraint(constraint.getExplicitListValues());
                        DataValidation dataValidation =
                                destination.getDataValidationHelper().createValidation(constraintnew, regions);
                        destination.addValidationData(dataValidation);
                    }else{

                        DataValidation dataValidation =
                                destination.getDataValidationHelper().createValidation(constraint, regions);
                        destination.addValidationData(dataValidation);
                    }

                }
            }
        }
    }

    // 拷贝行
    public static void copyRow(XSSFSheet destSheet, HSSFRow srcRow, XSSFRow destRow,
                               List<CellRangeAddress> cellRangeAddressList) {

        // 拷贝行高
        destRow.setHeight(srcRow.getHeight());

        for (int j = srcRow.getFirstCellNum(); j <= srcRow.getLastCellNum(); j++) {
            if (j < 0) {
                continue;
            }
            HSSFCell oldCell = srcRow.getCell(j);
            XSSFCell newCell = destRow.getCell(j);
            if (oldCell != null) {
                if (newCell == null) {
                    newCell = destRow.createCell(j);
                }
                // 拷贝单元格
                copyCell(oldCell, newCell, destSheet);

                // 获取原先的合并单元格
                CellRangeAddress mergedRegion = getMergedRegion(cellRangeAddressList, srcRow.getRowNum(),
                        (short) oldCell.getColumnIndex());

                if (mergedRegion != null) {
                    // 参照创建合并单元格
                    CellRangeAddress newMergedRegion = new CellRangeAddress(mergedRegion.getFirstRow(),
                            mergedRegion.getLastRow(), mergedRegion.getFirstColumn(), mergedRegion.getLastColumn());
                    destSheet.addMergedRegion(newMergedRegion);
                }
            }
        }

    }

    // 拷贝单元格
    public static void copyCell(HSSFCell oldCell, XSSFCell newCell, XSSFSheet destSheet) {

        HSSFCellStyle sourceCellStyle = oldCell.getCellStyle();
        XSSFCellStyle targetCellStyle = destSheet.getWorkbook().createCellStyle();

        if (sourceCellStyle == null) {
            sourceCellStyle = oldCell.getSheet().getWorkbook().createCellStyle();
        }

        targetCellStyle.setFillForegroundColor(sourceCellStyle.getFillForegroundColor());
        // 设置对齐方式
        targetCellStyle.setAlignment(sourceCellStyle.getAlignment());
        targetCellStyle.setVerticalAlignment(sourceCellStyle.getVerticalAlignment());

        // 设置字体
        XSSFFont xssfFont = destSheet.getWorkbook().createFont();
        HSSFFont hssfFont = sourceCellStyle.getFont(oldCell.getSheet().getWorkbook());
        copyFont(xssfFont, hssfFont);
        targetCellStyle.setFont(xssfFont);
        // 文本换行
        targetCellStyle.setWrapText(sourceCellStyle.getWrapText());

        targetCellStyle.setBorderBottom(sourceCellStyle.getBorderBottom());
        targetCellStyle.setBorderLeft(sourceCellStyle.getBorderLeft());
        targetCellStyle.setBorderRight(sourceCellStyle.getBorderRight());
        targetCellStyle.setBorderTop(sourceCellStyle.getBorderTop());
        targetCellStyle.setBottomBorderColor(sourceCellStyle.getBottomBorderColor());
        targetCellStyle.setFillBackgroundColor(sourceCellStyle.getFillBackgroundColor());
        targetCellStyle.setFillPattern(sourceCellStyle.getFillPattern());

        targetCellStyle.setHidden(sourceCellStyle.getHidden());
        targetCellStyle.setIndention(sourceCellStyle.getIndention());
        targetCellStyle.setLeftBorderColor(sourceCellStyle.getLeftBorderColor());
        targetCellStyle.setLocked(sourceCellStyle.getLocked());
        targetCellStyle.setQuotePrefixed(sourceCellStyle.getQuotePrefixed());
        targetCellStyle.setReadingOrder(ReadingOrder.forLong(sourceCellStyle.getReadingOrder()));
        targetCellStyle.setRightBorderColor(sourceCellStyle.getRightBorderColor());
        targetCellStyle.setRotation(sourceCellStyle.getRotation());

        //设置单元格格式 映射需要从XSSFDataFormat中获取
        String dataFormatString = oldCell.getCellStyle().getDataFormatString();
        XSSFDataFormat dataFormat = destSheet.getWorkbook().createDataFormat();
        short format = dataFormat.getFormat(dataFormatString);
        targetCellStyle.setDataFormat(format);

        newCell.setCellStyle(targetCellStyle);

        switch (oldCell.getCellType().getCode()) {
            case 1:
                newCell.setCellValue(oldCell.getStringCellValue());
                break;
            case 0:
                newCell.setCellValue(oldCell.getNumericCellValue());
                break;
            case 3:
                newCell.setCellType(CellType.BLANK);
                break;
            case 4:
                newCell.setCellValue(oldCell.getBooleanCellValue());
                break;
            case 5:
                newCell.setCellErrorValue(oldCell.getErrorCellValue());
                break;
            case 2:
                newCell.setCellFormula(oldCell.getCellFormula());
                break;
            default:
                break;
        }

    }

    // 拷贝字体设置
    public static void copyFont(XSSFFont xssfFont, HSSFFont hssfFont) {
        xssfFont.setFontName(hssfFont.getFontName());
        xssfFont.setBold(hssfFont.getBold());
        xssfFont.setFontHeight(hssfFont.getFontHeight());
        xssfFont.setCharSet(hssfFont.getCharSet());
        xssfFont.setColor(hssfFont.getColor());
        xssfFont.setItalic(hssfFont.getItalic());
        xssfFont.setUnderline(hssfFont.getUnderline());
        xssfFont.setTypeOffset(hssfFont.getTypeOffset());
        xssfFont.setStrikeout(hssfFont.getStrikeout());
    }

    // 根据行列获取合并单元格
    public static CellRangeAddress getMergedRegion(List<CellRangeAddress> cellRangeAddressList, int rowNum, short cellNum) {
        for (int i = 0; i < cellRangeAddressList.size(); i++) {
            CellRangeAddress merged = cellRangeAddressList.get(i);
            if (merged.isInRange(rowNum, cellNum)) {
                // 已经获取过不再获取
                cellRangeAddressList.remove(i);
                return merged;
            }
        }
        return null;
    }

    // 拷贝图片
    public static void copyPicture(HSSFSheet source, XSSFSheet destination) {
        // 获取sheet中的图片信息
        List<Map<String, Object>> mapList = getPicturesFromHSSFSheet(source);
        XSSFDrawing drawing = destination.createDrawingPatriarch();

        for (Map<String, Object> pictureMap: mapList) {

            HSSFClientAnchor hssfClientAnchor = (HSSFClientAnchor) pictureMap.get("pictureAnchor");

            HSSFRow startRow = source.getRow(hssfClientAnchor.getRow1());
            float startRowHeight = startRow == null ? source.getDefaultRowHeightInPoints() : startRow.getHeightInPoints();

            HSSFRow endRow = source.getRow(hssfClientAnchor.getRow1());

            float endRowHeight = endRow == null ? source.getDefaultRowHeightInPoints() : endRow.getHeightInPoints();

            // hssf的单元格，每个单元格无论宽高，都被分为 宽 1024个单位 高 256个单位。
            // 32.00f 为默认的单元格单位宽度 单元格宽度 / 默认宽度 为像素宽度
            XSSFClientAnchor xssfClientAnchor = drawing.createAnchor(
                    (int) (source.getColumnWidth(hssfClientAnchor.getCol1()) / 32.00f
                            / 1024 * hssfClientAnchor.getDx1() * Units.EMU_PER_PIXEL),
                    (int) (startRowHeight / 256 * hssfClientAnchor.getDy1() * Units.EMU_PER_POINT),
                    (int) (source.getColumnWidth(hssfClientAnchor.getCol2()) / 32.00f
                            / 1024 * hssfClientAnchor.getDx2() * Units.EMU_PER_PIXEL),
                    (int) (endRowHeight / 256 * hssfClientAnchor.getDy2() * Units.EMU_PER_POINT),
                    hssfClientAnchor.getCol1(),
                    hssfClientAnchor.getRow1(),
                    hssfClientAnchor.getCol2(),
                    hssfClientAnchor.getRow2());
            xssfClientAnchor.setAnchorType(hssfClientAnchor.getAnchorType());

            drawing.createPicture(xssfClientAnchor,
                    destination.getWorkbook().addPicture((byte[])pictureMap.get("pictureByteArray"),
                            Integer.parseInt(pictureMap.get("pictureType").toString())));

            System.out.println("imageInsert");
        }
    }

    /**
     * 获取图片和位置 (xls)
     */
    public static List<Map<String, Object>> getPicturesFromHSSFSheet (HSSFSheet sheet) {
        List<Map<String, Object>> mapList = new ArrayList<>();
        if (sheet == null || sheet.getDrawingPatriarch() == null) {
            return mapList;
        }
        List<HSSFShape> list = sheet.getDrawingPatriarch().getChildren();
        for (HSSFShape shape : list) {
            if (shape instanceof HSSFPicture) {
                Map<String, Object> map = new HashMap<>();
                HSSFPicture picture = (HSSFPicture) shape;
                HSSFClientAnchor cAnchor = picture.getClientAnchor();
                HSSFPictureData pdata = picture.getPictureData();
                map.put("pictureAnchor", cAnchor);
                map.put("pictureByteArray", pdata.getData());
                map.put("pictureType", pdata.getPictureType());
                map.put("pictureSize", picture.getImageDimension());
                mapList.add(map);
            }
        }
        return mapList;
    }



}

码动未来
关注
XLS与XLSX互相转换
10-17
XLS与XLSX互相转换，在2003的EXCEL创造的表格在2007版本中打不开的情况下，这是一个利器。
Java实现XLS和XLSX之间的相互转换
m0_68346044的博客
09-29 4479
当你在较新版本的Microsoft Excel中打开一个XLS文件，如Excel 2016或2019，你会在文件名后的标题栏中看到 “兼容模式”。如果你想从兼容模式改为正常模式，你可以把XLS文件保存为较新的Excel文件格式，如XLSX。由于版本的不同，我们有时需要将其中一种转换为另一种。
java实现 xls转xlsx
x_iaoa_o的博客
05-19 3518
使用spark读取excel往数据库进行导数(现有插件spark-excel_2.12只支持新读取xlsx)，又因为数据源中存在大量xls类型的文件，需要开发一个功能将xls文件转为xlsx，来进行导数
Java XLS 转 XLSX
m0_49790240的博客
08-18 1604
Java XLS 转 XLSX。
Java导入导出Excel表格（xls版本、xlsx版本）
叁金Coder
11-09 7602
信息化建设的终局：不管怎么吹ERP、OA、CRM、BI或者是别的什么高大上的系统，最终都会回归到两个功能：1、从Excel导入数据，2、把数据导出成一个Excel 二、导入导出工具类：
批量xls转xlsx软件
01-21
Convert XLSX to XLS：CXS45YKL467EVB Convert XLS to XLSX：CXX34JHY87ZX4T
读取xls和xlsxjar包
10-04
Excel文件有两种主要格式：xls（Excel 97-2003工作簿）和xlsx（Excel 2007及更高版本的OpenXML工作簿）。这两种格式的文件在处理上有所不同，因此需要依赖不同的库或jar包来实现读取。 对于.xls文件，它是二进制...
java 读xls 、xlsx jar包
09-15
在Java中，我们可以使用不同的库来处理不同版本的Excel文件，如xls（Excel 97-2003格式）和xlsx（Excel 2007及以上版本的OpenXML格式）。在标题和描述中提到的"java 读xls 、xlsx jar包"，主要是指用于读取这两种...
python中xls转xlsx代码、操作说明、相关第三方库安装文件及安装方式
08-12
使用`pandas`读取xls文件，然后使用`pandas`的`to_excel`方法将其保存为xlsx格式。以下是一个简单的转换示例： ```python import pandas as pd # 读取xls文件 xls_data = pd.read_excel('input_file.xls') ...
Python学习_几种存取xls/xlsx文件的方法总结
09-20
在这篇文章中，我们了解到如何使用Python语言来处理和操作xls/xlsx文件。对于数据科学家和程序员来说，这是一个常见的需求，特别是在需要将数据持久化到电子表格格式时。文章提供了几种不同的方法来完成这一任务，...
使用poi将xls转为xlsx，所有样式完美转换
09-11
使用poi将xls格式的Excel转为xlsx，文件中的所有样式都可以完美转换，例如合并栏、背景和单元格样式等。Java源码
java实现xls转换为xlsx
h18300103614的博客
05-10 4657
工作所需，要把xls转换为xlsx，参考了Java 复制 Excel 工作表 而改造的，亲测有效。 jdk1.5及以上 所需jar包：Spire.Office.jar 或 Spire.Xls.jar jar包下载：https://www.e-iceblue.cn/ 冰蓝科技，很不错的网站，值得研究研究。 下载步骤在 java为word添加水印，图片水印和文字水印 或者要送我分也行，嘿嘿：Spire.Office.jar 代码 import com.spire.xls.FileFormat; import c
java导入和导出excel文档（支持xls,xlsx格式）
ywb201314的专栏
12-12 2432
好久没写博客了，写个简单的估计也是常用的，欢迎评判指导交流 相关jar包，可以先百度，因为时间问题后续再补上 package main.java; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import ja
java使用poi，将xls文件转换为xlsx文件
sjyshine的博客
12-15 5075
最近产品有需求，需要在线浏览xls文件，犹豫前端的spreadJs只支持xlsx格式的浏览，所以让我们服务端，将xls文件转换为xlsx。 主要麻烦之处是图片的拷贝，花费了一些时间，先将代码贴在此处。 代码环境：jdk 1.8、poi 4.1.2 poi的目前没有原生的拷贝，所以需要自己一个个sheet、一行行、一个个单元格进行拷贝。 第一步就是选择需要拷贝的sheet，此处，遍历所有的sheet，我这边根据需求，只拷贝了，未隐藏的sheet。如果需要全部拷贝，可以去除判断，再给新的sheet设置
Java简单实现xls转xlsx
recover517的博客
03-01 4006
基于POI，已简单实现： sheet页隐藏、冻结的单元格、设置默认行高、合并单元格、下拉列表（单元格校验）、设置行高、设置列样式、设置列宽、设置单元格样式、设置单元格字体、设置单元格批注
将xls文件转换为xlsx文件 java
最新发布
weixin_41550771的博客
07-22 265
将XLS文件转换为XLSX文件：Java实现指南 在数据处理和分析领域，Excel文件格式的转换是一个常见的需求。特别是当需要将旧版本的XLS文件转换为较新的XLSX格式时，这不仅可以提高文件的兼容性，还可以利用XLSX格式提供的一些高级功能。本文将指导您如何使用Java编程语言实现这一转换过程。 准备工作 在开始之前，您...
JAVA xls转xlsx
m0_66386252的博客
03-02 413
java xls转xlsx
excel xls格式转xlsx格式-java实现
qq_41539807的博客
06-21 303
在使用java 处理excel的时候，经常会遇到xls转xlsx的问题，下面是一种实现。
python xls转xlsx
06-01
你可以使用Python的openpyxl库来将xls文件转换为xlsx文件。下面是一个简单的示例代码： ```python import openpyxl import os # 定义xls文件路径和文件名 xls_path = 'path/to/xls/file' xls_file = 'example.xls'...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值