Java POI SAX 处理海量数据读取（可用）

最新推荐文章于 2024-04-15 19:09:04 发布
最新推荐文章于 2024-04-15 19:09:04 发布
阅读量5.6k 收藏 1
点赞数
分类专栏： Excel处理-Jxl & Poi

类似文章可参考 ：http://blog.csdn.net/z69183787/article/details/72637313

http://www.itdadao.com/articles/c15a420615p0.html：但无法解决 空单元格 跳过读取的问题

package excel.sax.holy;

import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.ss.usermodel.BuiltinFormats;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.xssf.eventusermodel.XSSFReader;
import org.apache.poi.xssf.model.SharedStringsTable;
import org.apache.poi.xssf.model.StylesTable;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;

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

public class ExampleEventUserModelUtil {
	private static String cs;
	private static StylesTable stylesTable;
	private static List dataList = new ArrayList();
	private static List successList = new ArrayList();
	private static List failList = new ArrayList();
	private static Map map = new HashMap();;
//	@Value("${weight}")  
//	public static String weight;  
	/**
	 * 处理一个sheet
	 * 
	 * @param filename
	 * @throws Exception
	 */
	public void processOneSheet(String filename) throws Exception {

		OPCPackage pkg = OPCPackage.open(filename);
		XSSFReader r = new XSSFReader(pkg);
		stylesTable = r.getStylesTable();
		SharedStringsTable sst = r.getSharedStringsTable();

		XMLReader parser = fetchSheetParser(sst);
		Iterator<InputStream> sheets = r.getSheetsData();
		while (sheets.hasNext()) {
			InputStream sheet = sheets.next();
			InputSource sheetSource = new InputSource(sheet);
			parser.parse(sheetSource);
			sheet.close();
		}

	}

	/**
	 * 处理所有sheet
	 * 
	 * @param filename
	 * @throws Exception
	 */
	public void processAllSheets(String filename) throws Exception {

		OPCPackage pkg = OPCPackage.open(filename);
		XSSFReader r = new XSSFReader(pkg);
		SharedStringsTable sst = r.getSharedStringsTable();

		XMLReader parser = fetchSheetParser(sst);

		Iterator<InputStream> sheets = r.getSheetsData();
		while (sheets.hasNext()) {
			System.out.println("Processing new sheet:\n");
			InputStream sheet = sheets.next();
			InputSource sheetSource = new InputSource(sheet);
			parser.parse(sheetSource);
			sheet.close();
			System.out.println("");
		}
	}

	/**
	 * 获取解析器
	 * 
	 * @param sst
	 * @return
	 * @throws org.xml.sax.SAXException
	 */
	public XMLReader fetchSheetParser(SharedStringsTable sst)
			throws SAXException {
		XMLReader parser = XMLReaderFactory
				.createXMLReader("org.apache.xerces.parsers.SAXParser");
		ContentHandler handler = new SheetHandler(sst);
		parser.setContentHandler(handler);
		return parser;
	}

	/**
	 * 自定义解析处理器 See org.xml.sax.helpers.DefaultHandler javadocs
	 */
	private static class SheetHandler extends DefaultHandler {

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

		private List<String> rowlist = new ArrayList<String>();
		private int curRow = 0;
		private int curCol = 0;

		// 定义前一个元素和当前元素的位置，用来计算其中空的单元格数量，如A6和A8等
		private String preRef = null, ref = null;
		// 定义该文档一行最大的单元格数，用来补全一行最后可能缺失的单元格
		private String maxRef = null;

		private CellDataType nextDataType = CellDataType.SSTINDEX;
		private final DataFormatter formatter = new DataFormatter();
		private short formatIndex;
		private String formatString;

		// 用一个enum表示单元格可能的数据类型
		enum CellDataType {
			BOOL, ERROR, FORMULA, INLINESTR, SSTINDEX, NUMBER, DATE, NULL
		}

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

		/**
		 * 解析一个element的开始时触发事件
		 */
		public void startElement(String uri, String localName, String name,
				Attributes attributes) throws SAXException {

			map.put("flag", "start");
			// c => cell
			if (name.equals("c")) {
				// 前一个单元格的位置
				if (preRef == null) {
					preRef = attributes.getValue("r");
				} else {
					preRef = ref;
				}
				// 当前单元格的位置
				ref = attributes.getValue("r");

				this.setNextDataType(attributes);

				// Figure out if the value is an index in the SST
				String cellType = attributes.getValue("t");
				// if(cellType != null && cellType.equals("s")) {
				// nextIsString = true;
				// } else {
				// nextIsString = false;
				// }
				if (cellType == null) { //处理空单元格问题
					nextIsString = true;
					cs = "x";
				} else if (cellType != null && cellType.equals("s")) {
					cs = "s";
					nextIsString = true;
				} else {
					nextIsString = false;
					cs = "";
				}

			}
			// Clear contents cache
			lastContents = "";
		}

		/**
		 * 根据element属性设置数据类型
		 * 
		 * @param attributes
		 */
		public void setNextDataType(Attributes attributes) {

			nextDataType = CellDataType.NUMBER;
			formatIndex = -1;
			formatString = null;
			String cellType = attributes.getValue("t");
			String cellStyleStr = attributes.getValue("s");
			if ("b".equals(cellType)) {
				nextDataType = CellDataType.BOOL;
			} else if ("e".equals(cellType)) {
				nextDataType = CellDataType.ERROR;
			} else if ("inlineStr".equals(cellType)) {
				nextDataType = CellDataType.INLINESTR;
			} else if ("s".equals(cellType)) {
				nextDataType = CellDataType.SSTINDEX;
			} else if ("str".equals(cellType)) {
				nextDataType = CellDataType.FORMULA;
			}
			if (cellStyleStr != null) {
				int styleIndex = Integer.parseInt(cellStyleStr);
				XSSFCellStyle style = stylesTable.getStyleAt(styleIndex);
				formatIndex = style.getDataFormat();
				formatString = style.getDataFormatString();
				if ("m/d/yy" == formatString) {
					nextDataType = CellDataType.DATE;
					// full format is "yyyy-MM-dd hh:mm:ss.SSS";
					formatString = "yyyy-MM-dd";
				}
				if (formatString == null) {
					nextDataType = CellDataType.NULL;
					formatString = BuiltinFormats.getBuiltinFormat(formatIndex);
				}
			}
		}

		/**
		 * 解析一个element元素结束时触发事件
		 */
		public void endElement(String uri, String localName, String name)
				throws SAXException {
			// Process the last contents as required.
			// Do now, as characters() may be called more than once
			String flag =(String)map.get("flag");
			
			if (nextIsString) {
				if ("s".equals(cs)) {
					int idx = Integer.parseInt(lastContents);
					lastContents = new XSSFRichTextString(sst.getEntryAt(idx))
							.toString();
					nextIsString = false;
				}
				if ("c".equals(name) && "x".equals(cs)) {
					if("start".equals(flag)){
						rowlist.add(curCol, "");
						curCol++;
					}
					
				}
			}
			
			map.put("flag", "end");

			// v => contents of a cell
			// Output after we've seen the string contents
			if ("v".equals(name) || "t".equals(name)) {
				String value = this.getDataValue(lastContents.trim(), "");
				// 补全单元格之间的空单元格
				if (!ref.equals(preRef)) {
					int len = countNullCell(ref, preRef);
					for (int i = 0; i < len; i++) {
						rowlist.add(curCol, "");
						curCol++;
					}
				}
				rowlist.add(curCol, value);
				curCol++;
			} else {
				// 如果标签名称为 row，这说明已到行尾，调用 optRows() 方法
				if (name.equals("row")) {
					String value = "";
					// 默认第一行为表头，以该行单元格数目为最大数目
					if (curRow == 0) {
						maxRef = ref;
					}
					// 补全一行尾部可能缺失的单元格
					if (maxRef != null) {
						int len = countNullCell(maxRef, ref);

						for (int i = 0; i <= len; i++) {
							//rowlist.add(curCol, "");
							//curCol++;
						}
					}
					// 拼接一行的数据
					for (int i = 0; i < rowlist.size(); i++) {
						if (rowlist.get(i).contains(",")) {
							value += "\"" + rowlist.get(i) + "\",";

						} else {
							if (i == rowlist.size() - 1) {
								value += rowlist.get(i);
							} else {
								value += rowlist.get(i) + ",";
							}
						}
					}
					// 加换行符
					value += "\n";
					// try {
					// writer.write(value);
					// } catch (IOException e) {
					// e.printStackTrace();
					// }
					curRow++;
					// System.out.println(curRow + rowlist.toString()+"------");
					// 一行的末尾重置一些数据
					dataList.add(value);
					rowlist.clear();
					curCol = 0;
					preRef = null;
					ref = null;
				}
			}
		}

		/**
		 * 根据数据类型获取数据
		 * 
		 * @param value
		 * @param thisStr
		 * @return
		 */
		public String getDataValue(String value, String thisStr)

		{
			switch (nextDataType) {
			// 这几个的顺序不能随便交换，交换了很可能会导致数据错误
			case BOOL:
				char first = value.charAt(0);
				thisStr = first == '0' ? "FALSE" : "TRUE";
				break;
			case ERROR:
				thisStr = "\"ERROR:" + value.toString() + '"';
				break;
			case FORMULA:
				thisStr = '"' + value.toString() + '"';
				break;
			case INLINESTR:
				XSSFRichTextString rtsi = new XSSFRichTextString(
						value.toString());
				thisStr = rtsi.toString();
				rtsi = null;
				break;
			case SSTINDEX:
				String sstIndex = value.toString();
				thisStr = value.toString();
				break;
			case NUMBER:
				if (formatString != null) {
					thisStr = formatter.formatRawCellContents(
							Double.parseDouble(value), formatIndex,
							formatString).trim();
				} else {
					thisStr = value;
				}
				thisStr = thisStr.replace("_", "").trim();
				break;
			case DATE:
				try {
					thisStr = formatter.formatRawCellContents(
							Double.parseDouble(value), formatIndex,
							formatString);
				} catch (NumberFormatException ex) {
					thisStr = value.toString();
				}
				thisStr = thisStr.replace(" ", "");
				break;
			default:
				thisStr = "";
				break;
			}
			return thisStr;
		}

		/**
		 * 获取element的文本数据
		 */
		public void characters(char[] ch, int start, int length)
				throws SAXException {
			lastContents += new String(ch, start, length);
		}

		/**
		 * 计算两个单元格之间的单元格数目(同一行)
		 * 
		 * @param ref
		 * @param preRef
		 * @return
		 */
		public int countNullCell(String ref, String preRef) {
			// excel2007最大行数是1048576，最大列数是16384，最后一列列名是XFD
			String xfd = ref.replaceAll("\\d+", "");
			String xfd_1 = preRef.replaceAll("\\d+", "");

			xfd = fillChar(xfd, 3, '@', true);
			xfd_1 = fillChar(xfd_1, 3, '@', true);

			char[] letter = xfd.toCharArray();
			char[] letter_1 = xfd_1.toCharArray();
			int res = (letter[0] - letter_1[0]) * 26 * 26
					+ (letter[1] - letter_1[1]) * 26
					+ (letter[2] - letter_1[2]);
			return res - 1;
		}

		/**
		 * 字符串的填充
		 * 
		 * @param str
		 * @param len
		 * @param let
		 * @param isPre
		 * @return
		 */
		String fillChar(String str, int len, char let, boolean isPre) {
			int len_1 = str.length();
			if (len_1 < len) {
				if (isPre) {
					for (int i = 0; i < (len - len_1); i++) {
						str = let + str;
					}
				} else {
					for (int i = 0; i < (len - len_1); i++) {
						str = str + let;
					}
				}
			}
			return str;
		}
	}

	static BufferedWriter writer = null;

	public static void main(String[] args) throws Exception {
		dataList = new ArrayList();
		ExampleEventUserModelUtil example = new ExampleEventUserModelUtil();
		// String str = "Book1";
		String filename = "C:\\Users\\Administrator\\Desktop\\517\\delete_prize_winning_record.xlsx";
		System.out.println("-- 程序开始 --");
		long time_1 = System.currentTimeMillis();
		try {
			// writer = new BufferedWriter(new OutputStreamWriter(new
			// FileOutputStream("C:\\users40.xlsx")));
			example.processOneSheet(filename);
		} finally {
			// writer.close();
		}
		long time_2 = System.currentTimeMillis();
		System.out.println(dataList.size());
		System.out.println("-- 程序结束1 --");
		System.out.println("-- 耗时1 --" + (time_2 - time_1) / 1000 + "s");

		doOneRowCheck();
		System.out.println("-- 程序结束2 --");
		System.out.println("-- 耗时2--" + (time_2 - time_1) / 1000 + "s");

//		Connection connection = null;
//		try {
//			Class.forName("com.mysql.jdbc.Driver");
//			connection = DriverManager.getConnection(
//					"jdbc:mysql://127.0.0.1:3306/testpoi", "root", "root123");
//
//			connection.setAutoCommit(false);
//			PreparedStatement cmd = connection
//					.prepareStatement("insert into poinew values(?,?,?,?,?,?,?,?,?,?"
//							+ ",?,?,?,?,?,?,?,?,?,?"
//							+ ",?,?,?,?,?,?,?,?,?,?"
//							+ ",?,?,?,?,?,?,?,?,?)");
//
//			// for (int i = 0; i < 500000; i++) {//100万条数据
//			// cmd.setString(1, String.valueOf(i));
//			// cmd.setString(2, "test"+i);
//			// cmd.addBatch();
//			// if(i%5000==0){
//			// cmd.executeBatch();
//			// }
//			// }
//
//			int num = 0;
//			for (int i = 0; i < successList.size(); i++) {
//
//				String s = (String) successList.get(i);
//				String[] record = s.split(",");
//				num++;
//				int k = 0;
//
//				cmd.setString(++k, null);
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));// 10
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));// 20
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));// 30
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//				cmd.setString(++k, String.valueOf(record[k - 2]));
//
//				cmd.addBatch();
//				if (num % 3000 == 0) {
//					cmd.executeBatch();
//				}
//			}
//			cmd.executeBatch();
//			connection.commit();
//
//			cmd.close();
//			connection.close();
//		} catch (Exception e) {
//			e.printStackTrace();
//			if (connection != null) {
//				try {
//					connection.rollback();
//				} catch (SQLException e1) {
//
//				}
//			}
//		}
//
//		time_2 = System.currentTimeMillis();
//		System.out.println("-- 程序结束3 --");
//		System.out.println("-- 耗时3--" + (time_2 - time_1) / 1000 + "s");

	}

	private static void doOneRowCheck() {
	//	CustomizePropertyPlaceHolder holder = new CustomizePropertyPlaceHolder();
		
		//String str = holder.getProperty("test", "1");
	//System.out.println("BBBBBBBBBBBBBB"+weight);
		
		
	
		int num = 0;
		for (int i = 0; i < dataList.size(); i++) {
			FileErr err = new FileErr();
			if (i == 0) {
				continue;
			}
			String s = (String) dataList.get(i);
			String[] record = s.split(",");
			num++;
			
			boolean bool = true;
			//操作日期
			String   operationDate = record[8];
			
			if(bool&&!CheckUtils.isValidDate(operationDate)){
				err.setErrNo(String.valueOf(num));
				err.setErrMsg("操作日期格式不正确");
				err.setUserId(null);
				bool = false;
			}
		
			
			//计费重量
			String weight = record[14];

			if(bool&&!CheckUtils.isFloatNumber(weight)){
				err.setErrNo(String.valueOf(num));
				err.setErrMsg("计算重量格式不正确");
				err.setUserId(null);
				bool = false;
			}
			
			if(bool){
				successList.add(s);
			} else {
				failList.add(err);
			}
			
		}
		
		System.out.println(successList.toString());
		System.out.println("failList:"+failList.toString());
		
		
	}

}

OkidoGreen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
excel poi 的xml配置_使用Apache POI将内容添加到非常大的Excel文件（用尽替代方案...）...
weixin_39640372的博客
12-21 536
您可以尝试仅使用OPCPackage而不创建Workbook。但接下来我们必须在较低层次上工作org.openxmlformats.schemas.spreadsheetml.x2006.main对象。这意味着我们没有XSSF对象的支持，而将字符串值存储为数据(SharedStringsTable)并评估公式。该示例需要带有至少4张工作表的Excel工作簿。第三张工作表是你的“数据源表”。它必须存...
poi事件模式读取excel
qq_39493570的博客
10-09 1351
引入jar包 </dependencies> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi-ooxml</artifactId> <version>3.15</version> </dependency> .
java poi sax方式处理大数据量excel文件
08-25
主要介绍了java poi sax方式处理大数据量excel文件，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java应对大容量Excel：借助Apache POI SAX解析实现稳健高效读取
最新发布
java专栏
04-15 326
等方法中处理SAX事件，如行开始、行结束、单元格开始、单元格结束以及单元格文本内容等，实现对Excel数据的逐行、逐单元格处理，从而避免一次性加载整个文件到内存中导致的内存溢出问题。同时，务必关闭不再使用的输入流以释放资源。以下是一个使用Apache POI库以SAX解析方式读取大型Excel文件的Java代码示例，旨在避免内存溢出问题。代码中包含了详细的注释，解释了每一步操作的目的和逻辑。类中的方法仅用于演示目的，实际使用时应根据业务需求实现具体的逻辑。注意：上述代码示例中，
poi通过事件模式sax解析大excel文件，防止内存溢出
Shea1992的博客
10-12 964
1.解析类 package com.cetc.ExcelPoi;...
POI读取excel百万级-SAX方式解析
热门推荐
请叫我猿叔叔的博客
12-21 1万+
一. 简介 在excel解析的时候，采用SAX方方式会将excel转换为xml进行解析避免了内存溢出。 速度在3秒1W的数据写入，100W条记录，大概50M的数据，耗时大概4分半（如果不需要校验，可能会更快）； 暂时先直接将项目中的拷贝出来，使用的时候直接调工具类即可。目前正在搞自己的一个项目，后期会将导入，导出都弄上去，再优...
Java poi基于事件驱动读取excel 2007海量数据 处理空单元格
03-24
该工具类是poi基于事件驱动去读取海量excel数据，解决内存溢出以及空单元格的问题。 该压缩包里面有两个文件，TestExcel.java主要是原始的处理方法，操作简单，适合小数据量的读取。 ExampleEventUserModelUtil.java...
Java POI读取excel中数值精度损失问题解决
08-19
Java POI 读取 Excel 中数值精度损失...Java POI 读取 Excel 中数值精度损失问题解决可以通过将 Excel 单元格改为文本类型或使用 Java 处理来解决。这些方法可以确保读取到的数据是正确的，避免了数值精度损失的问题。
java poi 读取百万数据OOM优化
06-26
在Java开发中，处理大量数据是一项挑战，特别是当涉及到读取和操作百万级别的Excel数据时。Excel文件通常存储为二进制格式，如`.xls`或`.xlsx`，这些文件可以容纳大量的行和列，但当数据量过大时，可能会引发内存...
java poi 导入大数据量Excel数据 防止内存溢出处理.zip
03-20
Java中的Apache POI库是用于读取和写入Microsoft Office格式文件，特别是Excel文档的流行工具。然而，当处理大数据量的Excel文件时，POI可能会导致内存溢出（Out of Memory, OOM），因为默认情况下它会将整个工作簿...
Java POI SAX模式 读取大数据Excel
sinat_37062120的博客
02-28 7040
业务描述： 后缀为.xlsx的Excel文件，只有一个sheet页，且该sheet页对应数据库中的1张表，从A1开始有数据，第1行的数据对应表的各个字段，从第2行开始是要导入的数据，将该Excel导入到数据库中 解决方案： 因为Excel包含大量数据，如果采用POI的用户模式，会消耗大量内容，容易造成内存溢出 java.lang.OutOfMemoryError 所以这里采用SAX模式（...
java.lang.NoClassDefFoundError: Could not initialize class org.a*.poi.xssf.model.SharedStringsTable
u014259503的博客
05-10 2935
poi-ooxml-schemas包引入错误，poi包5.*版本更改了名称：poi-ooxml-schemas 改为 poi-ooxml-lite/full；更新poi-ooxml-schemas包，poi-ooxml-lite包已经在poi包里，所以只添加poi-ooxml-full。hutool-all版本太低，升级到5.*hutool-all升级后，报。解析Excel正常；
POI（一）：SAX方式之读取大数据2007版Excel（xlsx）
scofen的博客
10-18 1100
1.开发环境：jdk7,poi3.13 如图： 红色标注的jar包需要自己去下，这个是利用SAX机理处理xml的接口，而POI实现了它（我记得是这样，仅供参考） 2. 背景需求： 前台上传一个xlsx格式的Excel（超过10w条，每条20列），保存到服务器，然后在页面上分页显示出来，将不符合规则的行表红色或黄色，点击处理按钮，将所有数据插入数据库。...
POI-SAX解析EXCEL文件，动态解析，解析指定sheet
qq1141387415的博客
03-28 945
poi-sax解析大数据量，解决内存溢出，动态sheet解析
JAVA Apache POI 之sax 解析10万级大数量数据
WGH100817的博客
05-27 173
第一步让我们来看看我们的大量数据的excel 文件好的下面第二步看一下代码：package com.chinait.utils; /** * 写这个东西主要是最近做了一个联通的数据迁移工作，他们就是这样导出的数据，所以我们写了这个代码。 * 还有一个就是网上n 多都是半成品，代码不能直接运行，我这个代码能够直接运行。 * java poi 之sax 解析...
excel文本替换 poi,使用Apache POI将内容添加到非常大的Excel文件中（用完替代品......）...
weixin_42097819的博客
01-14 373
I have a large xlsx file which has an empty "data source sheet" and other sheets containing lots of formulas that use the data source sheet. My application should generate the data, open the file, fil...
解决POI事件驱动模式读取不到Java代码创建的Excel表格数据问题2
晨曦之光Wing的博客
05-17 864
【参考链接】 https://blog.csdn.net/qq_36533690/article/details/104737319 【说明】 在原先1的基础上，研究了下多个sheet，发现如果有多个，之前的方式每次都会读取最后一个sheet的数据，为了读取第一个sheet的数据，在设置rId时增加了rIdInitialized，标记是否初始化了rId 【完整代码】 package excel.read; import java.io.*; import java.util.HashMap;
POI事件模型处理execl导入功能(只支持07版本的execl)
weixin_30438813的博客
12-28 205
由于通过new XSSFWorkbook这种方式导入导致生产环境端口宕机、通过dump文件和javacore文件分析是导入功能导致的。解决办法：自己通过网上写的工具类，不知道是否存在bug。 package com.yygx.impexptemplate.utils; import java.io.IOException; import java.io.InputStream; ...
java读大数据量Excel(POI SAX事件读取)
chuangdiuzhuang6335的博客
10-24 646
本文章只针对Excel2007版本 POI读取Excel有两种模式，一种是用户模式，一种是SAX事件驱动模式，将xlsx格式的文档转换成CSV格式后进行读取。用户模式API接口丰富，使用POI的API可以很容易读取Excel，但用户模式消耗的内存很大，当遇到很大sheet、大数据网格，假空行...
java poi excel合并单元格数据读取
09-06
Java POI是一个用于操作Microsoft Office格式文件的开源库，在处理Excel文件时可以使用它来实现单元格的合并和数据读取。下面是一个使用Java POI来合并单元格并读取数据的示例： 1. 导入Java POI的相关库： ```java...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值