easyexcel解析excel

已于 2024-04-01 15:45:55 修改
阅读量172 收藏
点赞数 2
文章标签： excel python java
于 2024-03-26 16:28:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50836836/article/details/137045217
版权

引入easyexcel依赖

            <!-- easyexcel -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>easyexcel</artifactId>
                <version>2.2.11</version>
            </dependency>

代码如下

public interface ExcelAlphabet {
    String A = "A";
    String B = "B";
    String C = "C";
    String D = "D";
    String E = "E";
    String F = "F";
    String G = "G";
    String H = "H";
    String I = "I";
    String J = "J";
    String K = "K";
    String L = "L";
    String M = "M";
    String N = "N";
    String O = "O";
    String P = "P";
    String Q = "Q";
    String R = "R";
    String S = "S";
    String T = "T";
    String U = "U";
    String V = "V";
    String W = "W";
    String X = "X";
    String Y = "Y";
    String Z = "Z";
}

import lombok.Data;

import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;

@Data
public class ExcelEnums {

	//字母转数字
	private final static Map<Integer, String> number_to_letter = new LinkedHashMap<>();
	//数字转字母
	private final static Map<String, Integer> letter_to_number = new LinkedHashMap<>();

	private volatile static ExcelEnums single;


	public static String getForNumber(Integer number) {
		if (number == null || number <= 0) { // 检测列数是否正确
			throw new IllegalArgumentException("number is wrongful");
		}
		String letter = number_to_letter.get(number);
		if (letter == null) {
			letter = numberToLetter(number);
			number_to_letter.put(number, letter);
		}
		return letter;
	}

	public static Integer getForLetter(String letter) {
		if (letter == null) {
			throw new IllegalArgumentException("letter is null");
		}
		Integer number = letter_to_number.get(letter);
		if (letter == null) {
			number = letterToNumber(letter);
			letter_to_number.put(letter, number);
		}
		return number;
	}


	private ExcelEnums() {

	}

	public static ExcelEnums getInstance() {
		if (single == null) {
			synchronized (ExcelEnums.class) {
				if (single == null) {
					single = new ExcelEnums();
				}
			}
		}
		return single;
	}

	static {
		try {
			Class<ExcelAlphabet> excelAlphabetClass = ExcelAlphabet.class;
			Field[] declaredFields = excelAlphabetClass.getDeclaredFields();
			for (int i = 0; i < declaredFields.length; i++) {
				Field declaredField = declaredFields[i];
				String letter = (String) declaredField.get(excelAlphabetClass);
				int number = letterToNumber(letter);
				number_to_letter.put(number, letter);
				letter_to_number.put(letter, number);
			}
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 将以字母表示的Excel列数转换成数字表示
	 *
	 * @param letter 以字母表示的列数，不能为空且只允许包含字母字符
	 * @return 返回转换的数字，转换失败返回-1
	 * @author WuQianLing
	 */
	private static int letterToNumber(String letter) {
		// 检查字符串是否为空
		if (letter == null || letter.isEmpty()) {
			return -1;
		}
		String upperLetter = letter.toUpperCase(); // 转为大写字符串
		if (!upperLetter.matches("[A-Z]+")) { // 检查是否符合，不能包含非字母字符
			return -1;
		}
		long num = 0; // 存放结果数值
		long base = 1;
		// 从字符串尾部开始向头部转换
		for (int i = upperLetter.length() - 1; i >= 0; i--) {
			char ch = upperLetter.charAt(i);
			num += (ch - 'A' + 1) * base;
			base *= 26;
			if (num > Integer.MAX_VALUE) { // 防止内存溢出
				return -1;
			}
		}
		return (int) num;
	}

	/**
	 * 将数字转换成以字母表示的Excel列数
	 *
	 * @param num 表示列数的数字
	 * @return 返回转换的字母字符串，转换失败返回null
	 * @author WuQianLing
	 */
	private static String numberToLetter(int num) {
		if (num <= 0) { // 检测列数是否正确
			return null;
		}
		StringBuffer letter = new StringBuffer();
		do {
			--num;
			int mod = num % 26; // 取余
			letter.append((char) (mod + 'A')); // 组装字符串
			num = (num - mod) / 26; // 计算剩下值
		} while (num > 0);
		return letter.reverse().toString(); // 返回反转后的字符串
	}
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.TYPE, ElementType.FIELD})
public @interface ExcelSheet {

    String abscissa() default "";

    int ordinate() default -1;
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
/**
*
*
**/
@Target({ElementType.TYPE, ElementType.FIELD})
public @interface ExcelSheetRow {

    String abscissa() default "";

}

import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.metadata.CellData;
import com.yq.supervision.utils.DateDifferenceUtil;
import lombok.Data;
import org.springblade.common.constant.ExcelEnums;
import org.springblade.core.tool.utils.Func;

import javax.sql.rowset.serial.SerialBlob;
import javax.sql.rowset.serial.SerialClob;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.SQLException;
import java.sql.Time;
import java.util.*;

@Data
public abstract class ReadListenerFather<Bean> extends AnalysisEventListener<LinkedHashMap> {
	public ReadListenerFather(String letter) {
		count = 0;
		true_count = 0;
		max_row = ExcelEnums.getForLetter(letter);
		dateUtil = DateDifferenceUtil.getInstance();
	}

	/**
	 * 
	 * @param letter 第一列空数据位置
	 * @param beanClass
	 */
	public ReadListenerFather(String letter, Class<Bean> beanClass) {
		this(letter);
		this.beanClass = beanClass;
	}

	List<Map> list = new ArrayList<Map>();

	protected int max_row;
	protected DateDifferenceUtil dateUtil;

	protected int count;

	protected int true_count;

	protected int head_row_number = 1;

	protected Class<Bean> beanClass;

	protected final static ExcelEnums exception = ExcelEnums.getInstance();

	public void invokeHead(Map<Integer, CellData> headMap, AnalysisContext context) {
		checkUp(headMap, context);
		super.invokeHead(headMap, context);
		this.head_row_number++;
	}

	public void checkUp(Map headMap, AnalysisContext context) {
		if (headMap.size() >= max_row) {
			int key = 0;
			String value = null;
			try {
				Field tail = headMap.getClass().getDeclaredField("tail");
				tail.setAccessible(true);
				Map.Entry<Integer, Object> entry = (Map.Entry<Integer, Object>) tail.get(headMap);
				key = entry.getKey();
				Object values = entry.getValue();
				if (values != null) {
					value = values.toString();
				}
			} catch (NoSuchFieldException | IllegalAccessException e) {
				e.printStackTrace();
			}
			throw new IllegalStateException(
				new StringBuilder(context.readSheetHolder().getSheetName())
					.append(" Greater than length [")
					.append(ExcelEnums.getForNumber(key + 1))
					.append((true_count + 1))
					.append("] value [")
					.append(value)
					.append("]")
					.toString());
		}
		true_count++;
		count++;
	}

	@Override
	public void invoke(LinkedHashMap data, AnalysisContext context) {
		if (count == 0) {
			count = context.getCurrentRowNum();
			true_count = count;
		}
		checkUp(data, context);//count++ ; true_count++;
	}

	@Override
	public void doAfterAllAnalysed(AnalysisContext context) {

	}


	public abstract List<Bean> listToBean() throws InstantiationException, IllegalAccessException, SQLException;

	protected byte[] toByteArray(Object obj) {
		byte[] bytes = null;
		ByteArrayOutputStream bos = null;
		ObjectOutputStream oos = null;
		try {
			bos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(bos);
			oos.writeObject(obj);
			bytes = bos.toByteArray();
		} catch (IOException ex) {
			return new byte[0];
		} finally {
			try {
				if (oos != null) {
					oos.close();
					oos = null;
				}
			} catch (IOException EOss) {
				EOss.printStackTrace();
			}
			try {
				if (bos != null) {
					bos.flush();
					bos.close();
					bos = null;
				}
			} catch (IOException BOss) {
				BOss.printStackTrace();
			}
		}
		return bytes;
	}

	protected <Bean> void judgmentCategory(Field TField, Bean addT, Object getKey) throws IllegalAccessException, SQLException {
		if (getKey == null || getKey.equals("null") || "".equals(getKey)) {
			return;
		}
		if (TField.getType().isAssignableFrom(void.class) || TField.getType().isAssignableFrom(Void.class)) {
			return;
		}
		if (TField.getType().isAssignableFrom(String.class) || TField.getType().isAssignableFrom(Object.class)) {
			TField.set(addT, getKey);
			return;
		}
		if (TField.getType().isArray()) {
			if (TField.getType().isAssignableFrom(Byte[].class) || TField.getType().isAssignableFrom(byte[].class)) {
				TField.set(addT, toByteArray(getKey));
			} else {
				TField.set(addT, getKey);
			}
		}
		judgmentCategory(TField, addT, Func.toStr(getKey), false);
	}

	protected boolean isWrapClass(Class clz) {
		try {
			return ((Class) clz.getField("TYPE").get(null)).isPrimitive();
		} catch (Exception e) {
			return false;
		}
	}

	protected <Bean> void judgmentCategory(Field TField, Bean addT, String getKey, boolean meaningless) throws IllegalAccessException, SQLException {
		if (isWrapClass((Class) TField.getType()) || TField.getType().isPrimitive()) {
			if (TField.getType().isAssignableFrom(Byte.class) || TField.getType().isAssignableFrom(byte.class)) {
				TField.set(addT, Byte.parseByte(getKey));
			} else if (TField.getType().isAssignableFrom(Short.class) || TField.getType().isAssignableFrom(short.class)) {
				TField.set(addT, Short.parseShort(getKey));
			} else if (TField.getType().isAssignableFrom(Integer.class) || (TField.getType().isAssignableFrom(int.class))) {
				TField.set(addT, Integer.parseInt(getKey));
			} else if (TField.getType().isAssignableFrom(Long.class) || TField.getType().isAssignableFrom(long.class)) {
				TField.set(addT, Long.parseLong(getKey));
			} else if (TField.getType().isAssignableFrom(Float.class) || TField.getType().isAssignableFrom(float.class)) {
				TField.set(addT, Float.parseFloat(getKey));
			} else if (TField.getType().isAssignableFrom(Character.class) || TField.getType().isAssignableFrom(char.class)) {
				TField.set(addT, getKey.charAt(0));
			} else if (TField.getType().isAssignableFrom(Boolean.class) || TField.getType().isAssignableFrom(boolean.class)) {
				TField.set(addT, Boolean.parseBoolean(getKey));
			} else if (TField.getType().isAssignableFrom(Double.class) || TField.getType().isAssignableFrom(double.class)) {
				TField.set(addT, Double.parseDouble(getKey));
			} else {
				return;
			}
		} else if (TField.getType().isAssignableFrom(BigDecimal.class)) {
			TField.set(addT, new BigDecimal(getKey));
		} else {
			//date_start
			if (TField.getType().isAssignableFrom(Date.class)) {
				TField.set(addT, dateUtil.forMat(getKey, true));
			} else if (TField.getType().isAssignableFrom(java.sql.Timestamp.class)) {
				TField.set(addT, new java.sql.Timestamp(dateUtil.forMat(getKey, true).getTime()));
			}
//			else if (TField.getType().isAssignableFrom(com.sun.jmx.snmp.Timestamp.class)) {
//				TField.set(addT, new com.sun.jmx.snmp.Timestamp(dateUtil.forMat(getKey).getTime()));
//			}
			else if (TField.getType().isAssignableFrom(Time.class)) {
				TField.set(addT, new Time(dateUtil.forMat(getKey, true).getTime()));
				//date_end
			} else if (Blob.class.isAssignableFrom(TField.getType())) {
				TField.set(addT, new SerialBlob(getKey.getBytes()));
			} else if (Clob.class.isAssignableFrom(TField.getType())) {
				TField.set(addT, new SerialClob(getKey.toCharArray()));
			} else {
				return;
			}
		}

	}

}

import com.alibaba.excel.context.AnalysisContext;
import org.springblade.common.constant.ExcelSheet;

import java.lang.reflect.Field;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

//根据坐标读取
public class SheetReadListener<Bean> extends ReadListenerFather<Bean> {

	public String[] key;

	public SheetReadListener(String letter, Class<Bean> beanClass, String... key) {
		super(letter, beanClass);
		this.key = key;
	}

	public SheetReadListener(String letter, Class<Bean> beanClass) {
		super(letter, beanClass);
	}

	public SheetReadListener(String letter) {
		super(letter);
	}

	@Override
	public void invoke(LinkedHashMap data, AnalysisContext context) {
		if (key != null) {
			for (int i = 0; i < key.length; i++) {
				if (key[i].equals(data.get(0))) {
					return;
				}
			}
		}
		super.invoke(data, context);
		list.add(data);
	}

	@Override
	public void doAfterAllAnalysed(AnalysisContext context) {

	}

	@Override
	public List<Bean> listToBean() throws InstantiationException, IllegalAccessException, SQLException {
		List<Bean> arrays = new ArrayList<>();
		Class<Bean> tCalls = this.beanClass;
		if (tCalls == null) {
			throw new IllegalStateException("Class is null");
		}
		if (list.size() > 0) {
			Bean object = tCalls.newInstance();
			Field[] declaredFields = tCalls.getDeclaredFields();
			for (int i = 0; i < declaredFields.length; i++) {
				Field declaredField = declaredFields[i];
				declaredField.setAccessible(true);
				ExcelSheet annotation = declaredField.getAnnotation(ExcelSheet.class);
				if (annotation != null) {
					Map linkedHashMap = list.get(annotation.ordinate() - head_row_number);
					try {
						super.judgmentCategory(declaredField, object, linkedHashMap.get(exception.getForLetter(annotation.abscissa()) - 1));
					} catch (IllegalAccessException e) {
						throw new IllegalAccessException(tCalls + "." + declaredField.getName() + ":\t\t\t" + e.getMessage());
					}
				}
			}
			arrays.add(object);
		}
		return arrays;
	}
	

}

import com.alibaba.excel.context.AnalysisContext;
import org.springblade.common.constant.ExcelSheetRow;

import java.lang.reflect.Field;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

//数组列
public class SheetReadRowListener<Bean> extends ReadListenerFather<Bean> {

	public SheetReadRowListener(String letter, Class<Bean> beanClass, String... key) {
		super(letter, beanClass);
		this.key = key;
	}

	public SheetReadRowListener(String letter, Class<Bean> beanClass) {
		super(letter, beanClass);
	}

	public SheetReadRowListener(String letter) {
		super(letter);
	}

	public String[] key;


	@Override
	public void invoke(LinkedHashMap data, AnalysisContext context) {
		if (test(data)) {
			return;
		}
		if (key != null) {
			for (int i = 0; i < key.length; i++) {
				if (key[i].equals(data.get(0))) {
					return;
				}
			}
		}
		super.invoke(data, context);
		list.add(data);
	}

	@Override
	public void doAfterAllAnalysed(AnalysisContext context) {

	}

	@Override
	public List<Bean> listToBean() throws InstantiationException, IllegalAccessException, SQLException {
		List<Bean> arrays = new ArrayList<>();
		Class<Bean> tCalls = this.beanClass;
		if (tCalls == null) {
			throw new IllegalStateException("Class is null");
		}
		if (list.size() > 0) {
			for (Map map : list) {
				if (test(map)) {
					continue;
				}
				Bean object = tCalls.newInstance();
				Field[] declaredFields = tCalls.getDeclaredFields();
				for (int i = 0; i < declaredFields.length; i++) {
					Field declaredField = declaredFields[i];
					declaredField.setAccessible(true);
					ExcelSheetRow annotation = declaredField.getAnnotation(ExcelSheetRow.class);
					if (annotation != null) {
						try {
							super.judgmentCategory(declaredField, object, map.get(exception.getForLetter(annotation.abscissa()) - 1));
						} catch (Exception e) {
							throw new InstantiationException(declaredField.getName() + e.getMessage());
						}
					}
				}
				arrays.add(object);
			}

		}
		return arrays;
	}

	public boolean test(Map linkedHashMap) {
		for (Object obj : linkedHashMap.values()) {
			if (obj != null) {
				return false;
			}
		}
		return true;
	}

}
rootsoul
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于EasyExcel的excel解析工具类。
02-25
基于EasyExcel框架的excel解析工具类。EasyExcel是阿里的excel解析工具，使用快捷方便，轻量。封装了常用的方法。使用前需要了解easyExcel的基本用法。
EasyExcel导入excel和导出excel的demo
02-07
以下是对这个"EasyExcel导入导出demo"的详细解析： 1. **EasyExcel的基本概念**： - EasyExcel设计的目标是低内存消耗和高效处理，它通过流式读写方式避免了整个文件加载到内存中，降低了对系统资源的需求。 - ...
springboot整合easyexcel实现excel文件上传解析，下载导出简单实例.zip
11-10
springboot整合easyexcel，上传解析Excel，下载导出Excel 运行环境 jdk8+tomcat9+IntelliJ IDEA+maven 项目技术(必填) springboot+easyexcel+html 数据库文件(可选) 无 依赖包文件(可选) maven管理jar包依赖...
EasyExcel JAVA解析Excel工具 v3.3.4
04-07
easyexcel重写了poi对07版Excel的解析，一个3M的excel用POI sax解析依然需要100M左右内存，改用easyexcel可以降低到几M，并且再大的excel也不会出现内存溢出;03版依赖POI的sax模式，在上层做了模型转换的封装，让...
EasyExcel JAVA解析Excel工具.rar
07-04
Java解析、生成Excel比较有名的框架有Apache poi、jxl，但他们都存在一个严重的问题就是非常的耗内存。 EasyExcel 重写了poi，使一个3M的excel只需要几M内存，并且再大的excel不会出现内存溢出。 64M内存1分钟内...
免费Excel工作表同类数据合并工具
weixin_53505226的博客
08-14 435
下载地址：https://pan.quark.cn/s/81b1aeb45e4c 　　在Excel表格中，把多行同类数据合并为一行是件令人无比头痛的事情：首先，你得确定哪几条记录是可合并的同类数据，人工对比多个字段难免顾此失彼挂一漏万；其次，待合并的行可能分属多个分组，需要各自合并，但是同组的多行数据往往会分布在天遥地远的距离上，频繁地在表格的上下左右之间往返，势必令人心力憔悴；一旦确定了哪些行可以分别合并之后，还得分成数值和字符串两部分分别执行数值运算或拼接操作；最后，若要把计算结果填入对应的
EasyExcel-高性能的 Java Excel 处理库
weixin_51506966的博客
08-13 359
EasyExcel是一个高效且易于使用的 Excel 处理库，特别适用于大数据量的场景。它通过流式处理和高效的 API 简化了 Excel 文件的读取和写入操作，提高了性能，适合用于企业级应用和大数据处理任务。
Excel求和方法之
最新发布
m0_69575968的博客
08-16 223
SUM（），选择要相加的数即可。
Excel工作表同类数据合并工具
weixin_53505226的博客
08-12 559
下载地址：https://pan.quark.cn/s/81b1aeb45e4c 　　在Excel表格中，把多行同类数据合并为一行是件令人无比头痛的事情：首先，你得确定哪几条记录是可合并的同类数据，人工对比多个字段难免顾此失彼挂一漏万；其次，待合并的行可能分属多个分组，需要各自合并，但是同组的多行数据往往会分布在天遥地远的距离上，频繁地在表格的上下左右之间往返，势必令人心力憔悴；一旦确定了哪些行可以分别合并之后，还得分成数值和字符串两部分分别执行数值运算或拼接操作；最后，若要把计算结果填入对应的单
（第二十六天）
2301_78422961的博客
08-13 823
比如说，在对从库进行一些重大的配置更改或数据修复之前，可能会先使用此参数来防止从库自动启动复制，以免造成不可预期的结果。比如，如果有一个主库，多个从库，其中一个从库又作为另一个从库的主库时，就需要开启这个参数，以便将更新传递下去。例如，在进行数据恢复时，可以通过读取二进制日志中的操作来还原到特定的时间点。、如果数据⽐较少，可以通过跳过当前语句的⽅式解决，但是如果 从服务器写⼊的数据⽐较多，架。的唯一性或连续性等规则，系统会进行阻止或报错，以维护数据库的一致性和可靠性。从服务器中写⼊数据，主从结 构会失败。
快速把文件名统计到excel表的方法
方可软件的博客
08-13 389
快速把文件名统计到EXCEL表的方法，它只能通过专门的软件工具实现，操作系统自带的功能暂时没有这个功能，所以我们要实现这个功能，只能找相关的软件来做，上面介绍的这款批量提取器就是一个专门的软件。
制作好的excel报表设置打开密码或忘记密码怎么办？
pf_data的博客
08-12 245
excel工作表经常用来做数据统计、工资、报表等的文件格式，这些类型的文件都是很重要的数据资料，为此做这些数据的朋友们都会给他设置一个打开密码，不让其他人随便打开。但随着时间的流逝，我们做的数据报表越来越多了，做好后还不经常使用，所以就把密码忘记了，遇到这种情况时，我们该这么做呢？总的来说，虽然通过使用excel密码找回工具有可能找回密码，但忘记密码还是会带来诸多不便。因此，在设置密码时，大家可以设置易于记忆但又足够复杂的密码，并妥善保管。几分钟后，正确的密码将显示在弹出窗口中。
springmvc来实现Excel文件导入easyexcel
zhishidi的博客
08-13 396
实际生产中导入数据的功能经常遇到,今天我们来学习使用easyExcel实现导入。
Python办公自动化：使用`xlutils` 修改Excel文档
一名全栈开发工程师
08-12 332
除了读取Excel文件，我们还经常需要对文件进行修改或更新。在Python中，除了xlrd，还可以使用xlutils库来实现对Excel文件的修改操作。本文将继续以“巴黎奥运会奖牌榜.xlsx”文件为例，讲解如何使用xlrd和xlutils进行Excel文件的修改操作。
培训第二十六天（slave写入数据解决与GTIDS主从复制搭建）
weixin_70693880的博客
08-12 1049
1、Global transaction identifiers 全局事务标识符，是mysql5.6 新加⼊的技术2、使⽤GTIDs时，每⼀个事务都可以被识别和跟踪3、添加的新的slave或者发⽣故障时，需要将master身份或者⻆⾊迁移到slave上时，都需要考虑哪⼀个⼆进制⽇志以及哪个position值，极⼤简化了相关操作。
excel 2019版本的index match搜索功能
VB973490770的专栏
08-15 158
按Ctrl+Shift+Enter会出现{},代表数组公式，可以查找一组数据，并返回一组数据，然后根据情况处理即可，可以用JOIN将一组数据合并到一个单元格，用+分割或者其他符号分割即可。A:A="文字")*(sheet2!A:A="文字")*(sheet2!
xla 文件是 Excel 的加载项文件
nbspzs的专栏
08-13 350
1. **函数复杂性**：如果 `.xla` 文件中的函数逻辑复杂，计算过程耗时，或者涉及大量的数据处理，那么频繁调用这些函数会显著影响性能。是的，`.xla` 文件中的函数如果被大量调用，可能会影响 Excel 的性能。- 在 `加载项` 对话框中，点击 `浏览` 以找到您的 `.xla` 文件，然后勾选它以启用。2. **使用缓存**：如果函数需要多次使用相同的数据，考虑将数据缓存到内存中，避免重复计算。4. **简化计算**：分解复杂的计算任务，将其简化为多个小任务，这样更容易优化和管理。
excel计算时间差-显示每堂课时间
东方
08-16 91
【代码】excel计算时间差-显示每堂课时间。
Excel工具 -- vlookup函数使用
sz66cm 学习随笔
08-14 362
要快速寻找、定位和指向VLOOKUP。
easyexcel解析excel并添加解析结果
05-31
好的，根据您的问题，我假设您要使用EasyExcel解析Excel表格，并将解析结果添加到每一行的最后一列。可以按照以下步骤操作： 1. 定义要添加的解析结果 假设您要将解析结果添加到每一行的最后一列之后，可以定义一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值