解决：JAVA读取 2003、2007、2010 Word 和 Excel 的内容时内存溢出的问题

最新推荐文章于 2022-04-24 02:07:14 发布
最新推荐文章于 2022-04-24 02:07:14 发布
阅读量807 收藏 4
点赞数 2
分类专栏： JAVA 文章标签： java excel poi xml intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ThorLau/article/details/113247656
版权

最近在写一个获取 Word 以及 Excel 内容并进行过滤的功能，在CSDN上查了好久，好多都是关于 Excel 的，Word 的好多人建议用C写，但是最终还是被我解决掉了------本人很菜，如有可以优化的地方，可以评论区留言，请见谅，话不多说，上代码！

目录


注：以下代码是我在CSDN上查到的，然后自己做了整合

1. 代码中所用到的依赖

1.1 项目管理工具用的是Gradle

	compile group: 'org.apache.poi', name: 'poi', version: '4.0.1'
    compile group: 'org.apache.poi', name: 'poi-scratchpad', version: '4.0.1'
    compile group: 'org.apache.poi', name: 'poi-ooxml', version: '4.0.1'
    compile group: 'net.sf.jmimemagic', name: 'jmimemagic', version: '0.1.5'
    compile group: 'org.apache.ant', name: 'ant', version: '1.10.9'
    compile group: 'dom4j', name: 'dom4j', version: '1.6.1'

2. 以下就是用到的代码片段

注：代码会比较长，请见谅，而且因为我对代码做了修改，因此我会将我在CSDN上用到的资料贴在文章的最后

2.1 ExcelXlsReader：用于解决Excel2003版本大数据量问题

import org.apache.poi.hssf.eventusermodel.*;
import org.apache.poi.hssf.eventusermodel.dummyrecord.*;
import org.apache.poi.hssf.model.HSSFFormulaParser;
import org.apache.poi.hssf.record.*;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

import java.io.InputStream;
import java.util.*;

/**
 * @Author ThorLau
 * @CreateTime 2021/1/26 15:19
 * @Desc 用于解决Excel2003版本大数据量问题
 */
public class ExcelXlsReader implements HSSFListener {
    Boolean filter = false;
    List<String> keyword;

    private int minColums = -1;

    private POIFSFileSystem fs;

    /**
     * 总行数
     */
    private int totalRows = 0;

    /**
     * 上一行row的序号
     */
    private int lastRowNumber;

    /**
     * 上一单元格的序号
     */
    private int lastColumnNumber;

    /**
     * 是否输出formula，还是它对应的值
     */
    private boolean outputFormulaValues = true;

    /**
     * 用于转换formulas
     */
    private EventWorkbookBuilder.SheetRecordCollectingListener workbookBuildingListener;

    //excel2003工作簿
    private HSSFWorkbook stubWorkbook;

    private SSTRecord sstRecord;

    private FormatTrackingHSSFListener formatListener;

    private final HSSFDataFormatter formatter = new HSSFDataFormatter();

    //表索引
    private int sheetIndex = 0;

    private BoundSheetRecord[] orderedBSRs;

    private ArrayList boundSheetRecords = new ArrayList();

    private int nextRow;

    private int nextColumn;

    private boolean outputNextStringRecord;

    //当前行
    private int curRow = 0;

    //存储一行记录所有单元格的容器
    private List<String> cellList = new ArrayList<String>();

    /**
     * 判断整行是否为空行的标记
     */
    private boolean flag = false;

    private String sheetName;

    public List<String> getKeyword() {
        return keyword;
    }

    public void setKeyword(List<String> keyword) {
        this.keyword = keyword;
    }

    public Boolean getFilter() {
        return filter;
    }

    public void setFilter(Boolean filter) {
        this.filter = filter;
    }

    /**
     * @Author ThorLau
     * @CreateTime 2021/1/26 15:20
     * @Desc 遍历excel下所有的sheet
     * @Params [java.io.InputStream, java.util.List<java.lang.String>]
     * @Return int
     */
    public int process(InputStream inputStream, List<String> keyWord) throws Exception {
        setKeyword(keyWord);
        HSSFEventFactory factory = new HSSFEventFactory();
        HSSFRequest request = new HSSFRequest();

        this.fs = new POIFSFileSystem(inputStream);
        MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(this);
        formatListener = new FormatTrackingHSSFListener(listener);
        if (outputFormulaValues) {
            request.addListenerForAllRecords(formatListener);
        } else {
            workbookBuildingListener = new EventWorkbookBuilder.SheetRecordCollectingListener(formatListener);
            request.addListenerForAllRecords(workbookBuildingListener);
        }
        factory.processWorkbookEvents(request, fs);

        return totalRows; //返回该excel文件的总行数，不包括首列和空行
    }

    /**
     * @Author ThorLau
     * @CreateTime 2021/1/26 15:21
     * @Desc HSSFListener 监听方法，处理Record，处理每个单元格
     * @Params [org.apache.poi.hssf.record.Record]
     * @Return void
     */
    public void processRecord(Record record) {
        int thisRow = -1;
        int thisColumn = -1;
        String thisStr = null;
        String value = null;
        switch (record.getSid()) {
            case BoundSheetRecord.sid:
                boundSheetRecords.add(record);
                break;
            case BOFRecord.sid: //开始处理每个sheet
                BOFRecord br = (BOFRecord) record;
                if (br.getType() == BOFRecord.TYPE_WORKSHEET) {
                    //如果有需要，则建立子工作簿
                    if (workbookBuildingListener != null && stubWorkbook == null) {
                        stubWorkbook = workbookBuildingListener.getStubHSSFWorkbook();
                    }

                    if (orderedBSRs == null) {
                        orderedBSRs = BoundSheetRecord.orderByBofPosition(boundSheetRecords);
                    }
                    sheetName = orderedBSRs[sheetIndex].getSheetname();
                    sheetIndex++;
                }
                break;
            case SSTRecord.sid:
                sstRecord = (SSTRecord) record;
                break;
            case BlankRecord.sid: //单元格为空白
                BlankRecord brec = (BlankRecord) record;
                thisRow = brec.getRow();
                thisColumn = brec.getColumn();
                thisStr = "";
                cellList.add(thisColumn, thisStr);
                break;
            case BoolErrRecord.sid: //单元格为布尔类型
                BoolErrRecord berec = (BoolErrRecord) record;
                thisRow = berec.getRow();
                thisColumn = berec.getColumn();
                thisStr = berec.getBooleanValue() + "";
                cellList.add(thisColumn, thisStr);
                checkRowIsNull(thisStr);  //如果里面某个单元格含有值，则标识该行不为空行
                break;
            case FormulaRecord.sid://单元格为公式类型
                FormulaRecord frec = (FormulaRecord) record;
                thisRow = frec.getRow();
                thisColumn = frec.getColumn();
                if (outputFormulaValues) {
                    if (Double.isNaN(frec.getValue())) {
                        outputNextStringRecord = true;
                        nextRow = frec.getRow();
                        nextColumn = frec.getColumn();
                    } else {
                        thisStr = '"' + HSSFFormulaParser.toFormulaString(stubWorkbook, frec.getParsedExpression()) + '"';
                    }
                } else {
                    thisStr = '"' + HSSFFormulaParser.toFormulaString(stubWorkbook, frec.getParsedExpression()) + '"';
                }
                cellList.add(thisColumn, thisStr);
                checkRowIsNull(thisStr);  //如果里面某个单元格含有值，则标识该行不为空行
                break;
            case StringRecord.sid: //单元格中公式的字符串
                if (outputNextStringRecord) {
                    StringRecord srec = (StringRecord) record;
                    thisStr = srec.getString();
                    thisRow = nextRow;
                    thisColumn = nextColumn;
                    outputNextStringRecord = false;
                }
                break;
            case LabelRecord.sid:
                LabelRecord lrec = (LabelRecord) record;
                curRow = thisRow = lrec.getRow();
                thisColumn = lrec.getColumn();
                value = lrec.getValue().trim();
                value = value.equals("") ? "" : value;
                cellList.add(thisColumn, value);
                checkRowIsNull(value);  //如果里面某个单元格含有值，则标识该行不为空行
                break;
            case LabelSSTRecord.sid: //单元格为字符串类型
                LabelSSTRecord lsrec = (LabelSSTRecord) record;
                curRow = thisRow = lsrec.getRow();
                thisColumn = lsrec.getColumn();
                if (sstRecord == null) {
                    cellList.add(thisColumn, "");
                } else {
                    value = sstRecord.getString(lsrec.getSSTIndex()).toString().trim();
                    value = value.equals("") ? "" : value;
                    cellList.add(thisColumn, value);
                    checkRowIsNull(value);  //如果里面某个单元格含有值，则标识该行不为空行
                }
                break;
            case NumberRecord.sid: //单元格为数字类型
                NumberRecord numrec = (NumberRecord) record;
                curRow = thisRow = numrec.getRow();
                thisColumn = numrec.getColumn();

                //第一种方式
                //value = formatListener.formatNumberDateCell(numrec).trim();//这个被写死，采用的m/d/yy h:mm格式，不符合要求

                //第二种方式，参照formatNumberDateCell里面的实现方法编写
                Double valueDouble = ((NumberRecord) numrec).getValue();
                String formatString = formatListener.getFormatString(numrec);
                if (formatString.contains("m/d/yy")) {
                    formatString = "yyyy-MM-dd hh:mm:ss";
                }
                int formatIndex = formatListener.getFormatIndex(numrec);
                value = formatter.formatRawCellContents(valueDouble, formatIndex, formatString).trim();

                value = value.equals("") ? "" : value;
                //向容器加入列值
                cellList.add(thisColumn, value);
                checkRowIsNull(value);  //如果里面某个单元格含有值，则标识该行不为空行
                break;
            default:
                break;
        }

        //遇到新行的操作
        if (thisRow != -1 && thisRow != lastRowNumber) {
            lastColumnNumber = -1;
        }

        //空值的操作
        if (record instanceof MissingCellDummyRecord) {
            MissingCellDummyRecord mc = (MissingCellDummyRecord) record;
            curRow = thisRow = mc.getRow();
            thisColumn = mc.getColumn();
            cellList.add(thisColumn, "");
        }

        //更新行和列的值
        if (thisRow > -1)
            lastRowNumber = thisRow;
        if (thisColumn > -1)
            lastColumnNumber = thisColumn;

        //行结束时的操作
        if (record instanceof LastCellOfRowDummyRecord) {
            if (minColums > 0) {
                //列值重新置空
                if (lastColumnNumber == -1) {
                    lastColumnNumber = 0;
                }
            }
            lastColumnNumber = -1;

            if (flag && curRow != 0) { //该行不为空行且该行不是第一行，发送（第一行为列名，不需要）
                for (String key : getKeyword()) {
                    if (cellList.indexOf(key) != -1) {
                        setFilter(true);
                    }
                }
                totalRows++;
            }
            //清空容器
            cellList.clear();
            flag = false;
        }
    }

    /**
     * @Author ThorLau
     * @CreateTime 2021/1/26 15:22
     * @Desc 如果里面某个单元格含有值，则标识该行不为空行
     * @Params [java.lang.String]
     * @Return void
     */
    public void checkRowIsNull(String value) {
        if (value != null && !"".equals(value)) {
            flag = true;
        }
    }
}

2.2 ExcelXlsxReader ：解析大数据量Excel07及10的工具类

import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.xssf.eventusermodel.XSSFReader;
import org.apache.poi.xssf.model.SharedStringsTable;
import org.xml.sax.*;
import org.xml.sax.helpers.XMLReaderFactory;

import java.io.InputStream;
import java.util.*;

/**
 * @Author ThorLau
 * @CreateTime 2021/1/26 15:22
 * @Desc 解析大数据量Excel07及10的工具类
 */
public class ExcelXlsxReader {
    private SheetHandler sheetHandler;
    Boolean filter = false;

    public Boolean getFilter() {
        return filter;
    }

    public void setFilter(Boolean filter) {
        this.filter = filter;
    }

    public void setSheetHandler(SheetHandler sheetHandler) {
        this.sheetHandler = sheetHandler;
    }

    /**
     * @Author ThorLau
     * @CreateTime 2021/1/26 15:23
     * @Desc excel07及10处理多个sheet
     * @Params [java.io.InputStream, java.util.List<java.lang.String>]
     * @Return void
     */
    public void processAllSheets(InputStream is, List<String> keyword) throws Exception {
        OPCPackage pkg = null;
        InputStream sheet = null;
        try {
            pkg = OPCPackage.open(is);
            XSSFReader r = new XSSFReader(pkg);
            SharedStringsTable sst = r.getSharedStringsTable();
            XMLReader parser = fetchSheetParser(sst);
            sheetHandler.setKeyword(keyword);
            Iterator<InputStream> sheets = r.getSheetsData();
            while (sheets.hasNext()) {
                sheet = sheets.next();
                InputSource sheetSource = new InputSource(sheet);
                parser.parse(sheetSource);
                if (sheetHandler.getFilter()) {
                    setFilter(true);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {
            if (pkg != null) {
                pkg.close();
            }
            if (sheet != null) {
                sheet.close();
            }
        }
    }

    public XMLReader fetchSheetParser(SharedStringsTable sst) throws SAXException {
        XMLReader parser =
                XMLReaderFactory.createXMLReader(
                        "com.sun.org.apache.xerces.internal.parsers.SAXParser"
                );
        setSheetHandler(new SheetHandler(sst));
        ContentHandler handler = (ContentHandler) sheetHandler;
        parser.setContentHandler(handler);
        return parser;
    }
}

2.3 SheetHandler：从SheetHandler类中处理从excle获取的数据

import org.apache.poi.xssf.model.SharedStringsTable;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;

import java.util.List;

public class SheetHandler extends DefaultHandler {
    /**
     * @Author ThorLau
     * @CreateTime 2021/1/26 15:29
     * @Desc SheetHandler类中处理从excle获取的数据，
     * 官方文档中 SheetHandler以内部类形式，
     * 为保证更新代码减少内部类class文件忘记打包，
     * 改为一般java类
     */
    List<String> keyword;
    Boolean filter = false;

    private SharedStringsTable sst;
    private String lastContents;
    private boolean nextIsString;
    private String cellPosition;

    public List<String> getKeyword() {
        return keyword;
    }

    public void setKeyword(List<String> keyword) {
        this.keyword = keyword;
    }

    public Boolean getFilter() {
        return filter;
    }

    public void setFilter(Boolean filter) {
        this.filter = filter;
    }

    public SheetHandler(SharedStringsTable sst) {
        this.sst = sst;
    }

    public void startElement(String uri, String localName, String name,
                             Attributes attributes) throws SAXException {
        if (name.equals("c")) {
            cellPosition = attributes.getValue("r");
            String cellType = attributes.getValue("t");
            if (cellType != null && cellType.equals("s")) {
                nextIsString = true;
            } else {
                nextIsString = false;
            }
        }
        // 清除缓存内容
        lastContents = "";
    }

    public void endElement(String uri, String localName, String name) throws SAXException {
        if (nextIsString) {
            int idx = Integer.parseInt(lastContents);
            lastContents = new XSSFRichTextString(sst.getEntryAt(idx)).toString();
            nextIsString = false;
        }
        if (name.equals("v")) {
            //数据读取结束后，将单元格坐标,内容存入map中
            //不保存第一行数据  && !"1".equals(cellPosition.substring(1))
            if (!(cellPosition.length() == 2) || (cellPosition.length() == 2)) {
                //获取内容，直接过滤
                for (String key : getKeyword()) {
                    if (lastContents.indexOf(key) != -1) {
                        setFilter(true);
                    }
                }
            }
        }
    }

    public void characters(char[] ch, int start, int length)
            throws SAXException {
        lastContents += new String(ch, start, length);
    }
}

2.4 过滤Excel和Word（末尾的这个注释要耐心读完）

	/**
     * @Author ThorLau
     * @CreateTime 2021/1/26 15:24
     * @Desc 过滤2003、2007、2010的word
     * @Params [com.jdwa.jfilesync.file.IFileSystem, java.lang.String, java.util.List<java.lang.String>]
     * @Return boolean
     */
    public void SearchContentKeyByWorld(InputStream inputStream, String filePath, List<String> keyword) throws Throwable {
        WordExtractor wordExtractor = null;
        XWPFDocument docx = null;
        String[] paragraphs = null;
        try {
            if (filePath.endsWith("doc") || filePath.endsWith("DOC")) {
                wordExtractor = new WordExtractor(inputStream);
                paragraphs = wordExtractor.getParagraphText();
                for (String paragraph : paragraphs) {
                    for (String key : keyword) {
                        if (paragraph.indexOf(key) != -1) {
                            filter = true;
                        }
                    }
                }
            } else if (filePath.endsWith("docx") || filePath.endsWith("DOCX")) {
                docx = new XWPFDocument(inputStream);
                List<XWPFParagraph> list = docx.getParagraphs();
                for (XWPFParagraph paragraph : list) {
                    for (String key : keyword) {
                        if (paragraph.getText().indexOf(key) != -1) {
                            filter = true;
                        }
                    }
                }
            }
        } catch (Throwable e) {
            System.out.println("[Search ContentKey By Excel Or World] error : {}" + e);
            throw e;
        }
    }

	/**
     * @Author ThorLau
     * @CreateTime 2021/1/27 16:37
     * @Desc 过滤2003、2007、2010的表格
     * @Params [java.io.InputStream, java.lang.String, java.util.List<java.lang.String>]
     * @Return void
     */
    public void SearchContentKeyByExcel(InputStream inputStream, String filePath, List<String> keyWord) throws Throwable {
        ExcelXlsReader excelXls = new ExcelXlsReader();
        ExcelXlsxReader example = new ExcelXlsxReader();
        try {
            if (filePath.endsWith("xls") || filePath.endsWith("XLS")) {
                excelXls.process(inputStream, keyWord);
                if (excelXls.getFilter()) {
                    filter = true;
                }
            } else if (filePath.endsWith("xlsx") || filePath.endsWith("XLSX")) {
                example.processAllSheets(inputStream, keyWord);
                if (example.getFilter()) {
                    filter = true;
                }
            }
        } catch (Throwable e) {
            System.out.println("有问题！！！");
            throw e;
        }
    }

注：过滤Excel的时候直接获取上面写好的类就行了，过滤Word的时候直接用的.getParagraphText()方法，因为以前用的.getText()方法，所以内存溢出了，但是还有一种情况，就是InputStream 过大会导致在读.docx，也就是07、10版本的时候，因为要用XWPFDocument去解析这个文件，因此会内存溢出。但是，还有一种解决办法因为07以后都可以看作是一种压缩形式，可以用解压软件解压出来(如下图所示)。因此可以用ZipFile读到它然后获取document.xml去解析xml就可以获取到内容了，具体的代码CSDN上可以搜得到
这是解压之后的效果，点击打卡word文件夹

打开Document.xml这里面显示的就是Word的文本内容

3. 参考资料

https://blog.csdn.net/weixin_44259233/article/details/109613292
注：这个是对 Excel 03、07、10都生效的一篇个人觉得比较nice的文章

ThorLau
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
java 大文件 内存溢出_java读取超大文件方法 利用缓冲区分段读取 防止内存溢出异常...
weixin_39843215的博客
02-12 1494
[java]代码库import java.io.BufferedReader;import java.io.File;import java.io.FileReader;import java.io.RandomAccessFile;import java.nio.ByteBuffer;import java.nio.MappedByteBuffer;import java.nio.channel...
java读取word2003
05-14
java读取word2003，很好用的额
java docx 内存溢出_常见的内存溢出的三种情况
weixin_42518874的博客
03-06 267
1、JVM Heap(堆)溢出：java.lang.OutOfMemoryError: Java heap spaceJVM在启动的时候会自动设置JVM Heap的值， 可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。Heap的大小是Young Generation 和Tenured Generaion 之和。在JVM中如果98%的时间是用于GC,且可用的Heap size 不足...
java docx 内存溢出_JVM内存溢出与排错..docx
weixin_32589877的博客
03-01 146
JVM内存溢出与排错.JVM内存溢出与排错一、JVM堆内存溢出Java堆用于存储对象实例，我们只要不断创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制来清除这些对象，就会在对象数量达到最大队的容量限制后产生内存溢出异常。代码：[java] view plaincopyprint?/** * Java堆内存溢出 * @author jiangtong * */ public ...
Java 读取word2003 文档内容
0808xyj的专栏
03-01 569
import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import org.apache.poi.hwpf.HWPFDocument; impo...
Java通过POI读取Excel遍历数据，批量生成word文档
04-09
Apache POI是一个开源项目，它允许Java开发者处理Microsoft Office格式的文件，如Excel（.xlsx或.xls）和Word（.docx）。 首先，我们需要导入Apache POI的相关依赖。在Maven项目中，可以在pom.xml文件中添加以下...
PIO导入大量数据时的解决内存溢出问题.doc
05-05
PIO 是一个 Java 库，用来读取和写入 Microsoft Office 文档，如 Excel、Word 等。然而，在导入大量数据时，PIO 经常会出现内存溢出的问题。这种情况下，我们需要找到一种方法来解决这个问题。 解决方法之一是使用...
Java Poi流 根据Word模板插入相应的文本、表格和图片，生成新的Word报告
09-27
Java POI库是Apache软件基金会开发的一个开源项目，专门用于读写Microsoft Office格式的文件，如Word（.doc和.docx）、Excel（.xls和.xlsx）等。在本主题中，我们将深入探讨如何使用Java POI流处理Word模板，插入...
java文档excel、word、pdf、ppt转图片
03-17
在Java编程环境中，将文档（如Excel、Word、PDF、PPT）转换为图片是一种常见的需求，这在处理大量文档预览、数据可视化或者移动设备兼容性问题时尤其有用。以下是一些关于如何使用Java实现这种转换的关键知识点： 1...
android 读取word、excel等文件(文件内容不太全，只为借鉴即可）
01-25
以下是一些关于如何在Android中读取Word和Excel文件的关键知识点： 1. **Apache POI库**： Apache POI是一个流行的开源项目，它提供了API来处理Microsoft Office格式的文件，包括Word（.doc/.docx）和Excel（.xls/...
java读取word2003和word2007所需jar包
10-14
dom4j-1.6.1.jar geronimo-stax-api_1.0_spec-1.0.jar ooxml-schemas-1.0.jar openxml4j-bin-beta.jar poi-3.13-20150929.jar poi-ooxml-3.13-20150929.jar poi-scratchpad-3.13-20150929.jar xmlbeans-2.6.0.jar
关于Word内存占了90%的解决办法
m0_60599444的博客
04-24 3133
关于Word内存占了90%的解决办法 打开任务管理器，如果出现两个word，并且关掉word后还有一个word在运行，那么很有可能是加载项有重复的，如NoteExpress等12，要删掉一个。删掉之后，在任务管理器管理器中把word全部结束掉，然后重新打开关掉再看看，一般就能解决。 也可以事先检查一下3，这样的检查，只要能很快速的打开word就行了，不需要能编辑。一般来说都是加载项的问题。 对于只有一个word程序运行，还是内存很高，很有可能是拼写检查导致的，把相关设置关掉就好。4 关于Micro
用java读取word2003和word2007的内容
weixin_33762321的博客
11-29 194
需要使用apache的poi开源项目包；下载地址：http://poi.apache.org/download.html 引入其中的6个包poi-3.8-20120326.jar；poi-ooxml-3.8-20120326.jar；poi-ooxml-schemas-3.8-20120326.jar；poi-scratchpad-3.8-20120326.jar；xmlb...
Java读取操作word2003 word2007 word2010文档
husj_506808的博客
03-12 1530
package com.adj.readwordfile; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import org.apache.poi.POIXMLDocument; import org.apache.poi.POIXMLText
java word 2003_POI 读取word (word 2003 和 word 2007) （转）
weixin_34204530的博客
02-24 535
最近在给客户做系统的时候，用户提出需求，要能够导入 word 文件，现在 microsoft word 有好几个版本 97、2003、2007的，这三个版本存储数据的格式上都有相当大的差别，而现在 97 基本上已经退出市场，几乎没有人用这个版本了， 所以在我们的系统中只考虑 2003 版本和 2007 版本的，因为我们只要求能够读取 word 中的文字内容即可，其中的文字样式、图片等信息可以忽略，...
常见内存溢出问题以及解决方法
zhoumimi_comeon123的博客
09-02 456
1：死循环 或者是循环创建大量的重复的对象实例；----尽量不要在循环里创建对象实例 2：数组、集合里面对象没有清除，导致jvm不能回收----及时清除 3：内存中加载的数据量过大导致，比如：一次性从数据库取数据过多  ----采取分页查询方式 4：JVM启动参数内存值设置过小。----修改jvm内存参数值 5: 使用第三方软件中的bug。...
使用poi HSSFWorkbook导出报表内存溢出问题解决
OliverCaro的博客
11-29 2224
问题： 在使用HSSFWorkbook或XSSFWorkbook导出大数据量时，报OutOfMemoryError：Javaheap space内存溢出，直接宕机。 解决： 请使用SXSSFworkbook api。
java poi word bookmarks_java poi XWPF word - 在新文档中创建书签
weixin_29050829的博客
02-26 613
直到现在，才在apache poi的高级别类中实现此功能。因此，需要低级别CTP和CTBookmark。示例：import java.io.FileOutputStream;import org.apache.poi.xwpf.usermodel.*;import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBookmark;i...
JAVA内存溢出问题总结
01-14
在Java中，解决内存溢出问题的方法主要包括调整容器参数和改进程序代码编写。 从容器方面解决内存溢出问题，可以通过调整容器参数来优化内存的使用情况。第一种情况是查询数据库时递归循环导致内存溢出，可以尽量...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值