• Java 读取excel文件

    导入：

    先导入依赖：

    1. <!-- 文件上传 -->
    2. <dependency>
    3.     <groupId>org.apache.httpcomponents</groupId>
    4.     <artifactId>httpmime</artifactId>
    5. 	<version>4.5.7</version>
    6. </dependency>
    7. <!-- JSON -->
    8. <dependency>
    9.     <groupId>com.alibaba</groupId>
    10.     <artifactId>fastjson</artifactId>
    11.     <version>1.2.41</version>
    12. </dependency>
    13. <!-- POI -->
    14. <dependency>
    15.     <groupId>org.apache.poi</groupId>
    16.     <artifactId>poi-ooxml</artifactId>
    17.     <version>3.16</version>
    18. </dependency>

    1、获取想要上传excel文件的路径

    2、获得路径后，通过路径定位生成数据流，使用FileInputStream方法读取路径对应文件的原始字节流。

    1. //根据路径生成 FileInputStream字节流
    2. FileInputStream inputStream = new FileInputStream(new File(fileName));

    3、使用ExcelUtils工具类读取 字节流 + 路径。

    1. //通过ExcelUtils工具将Excel数据存入到list中，工具代码下面细讲,这一步读取Excel已经完成了，如果不想进行插入数据库操作，可以直接拿着list用啦。
    2. List<List<Object>> list = ExcelUtils.getListByExcel(inputStream,fileName);

    4、ExcelUtils工具类对数据进行处理，因为表格有行和列，所以处理完数据使用二维集合List对数据进行存储。

    ExcelUtils类讲解：

    1. public class ExcelUtils {
    2.     private final static String excel2003L =".xls";    //2003- 版本的excel
    3.     private final static String excel2007U =".xlsx";  //2007版本
    4.  
    5.     /**
    6.      * @Description：获取IO流中的数据，组装成List>对象
    7.      * @param in,fileName
    8.      * @return
    9.      * @throws
    10.      */
    11.     public static List<List<Object>> getListByExcel(InputStream in, String fileName) throws Exception{
    12.         List<List<Object>> list = null;
    13.         //创建Excel工作薄
    14.         Workbook work = getWorkbook(in,fileName);
    15.         if(null == work){
    16.             throw new Exception("创建Excel工作薄为空！");
    17.         }
    18.         Sheet sheet = null;  //页数
    19.         Row row = null;  //行数
    20.         Cell cell = null;  //列数
    21.  
    22.         list = new ArrayList<List<Object>>();
    23.         //遍历Excel中所有的sheet
    24.         for (int i = 0; i < work.getNumberOfSheets(); i++) {
    25.             sheet = work.getSheetAt(i);
    26.             if(sheet==null){continue;}
    27.  
    28.             //遍历当前sheet中的所有行
    29.             for (int j = sheet.getFirstRowNum(); j <= sheet.getLastRowNum(); j++) {
    30.                 row = sheet.getRow(j);
    31.                 if(row==null){continue;}
    32.  
    33.                 //遍历所有的列
    34.                 List<Object> li = new ArrayList<Object>();
    35.                 for (int y = row.getFirstCellNum(); y < row.getLastCellNum(); y++) {
    36.                     cell = row.getCell(y);
    37.                     li.add(getValue(cell));
    38.                 }
    39.                 list.add(li);
    40.             }
    41.         }
    42.  
    43.         return list;
    44.  
    45.     }
    46.  
    47.     /**
    48.      * @Description：根据文件后缀，自适应上传文件的版本
    49.      * @param inStr,fileName
    50.      * @return
    51.      * @throws Exception
    52.      */
    53.     public static  Workbook getWorkbook(InputStream inStr,String fileName) throws Exception{
    54.         Workbook wb = null;
    55.         String fileType = fileName.substring(fileName.lastIndexOf("."));
    56.         if(excel2003L.equals(fileType)){
    57.             wb = new HSSFWorkbook(inStr);  //2003-
    58.         }else if(excel2007U.equals(fileType)){
    59.             wb = new XSSFWorkbook(inStr);  //2007+
    60.         }else{
    61.             throw new Exception("解析的文件格式有误！");
    62.         }
    63.         return wb;
    64.     }
    65.  
    66.     /**
    67.      * @Description：对表格中数值进行格式化
    68.      * @param cell
    69.      * @return
    70.      */
    71.     //解决excel类型问题，获得数值
    72.     public static String getValue(Cell cell) {
    73.         String value = "";
    74.         if(null==cell){
    75.             return value;
    76.         }
    77.         switch (cell.getCellType()) {
    78.             //数值型
    79.             case NUMERIC:
    80.                 if (DateUtil.isCellDateFormatted(cell)) {
    81.                     //如果是date类型则 ，获取该cell的date值
    82.                     Date date = DateUtil.getJavaDate(cell.getNumericCellValue());
    83.                     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    84.                     value = format.format(date);;
    85.                 }else {// 纯数字
    86.                     BigDecimal big=new BigDecimal(cell.getNumericCellValue());
    87.                     value = big.toString();
    88.                     //解决1234.0  去掉后面的.0
    89.                     if(null!=value&&!"".equals(value.trim())){
    90.                         String[] item = value.split("[.]");
    91.                         if(1<item.length&&"0".equals(item[1])){
    92.                             value=item[0];
    93.                         }
    94.                     }
    95.                 }
    96.                 break;
    97.             //字符串类型
    98.             case STRING:
    99.                 value = cell.getStringCellValue();
    100.                 break;
    101.             // 公式类型
    102.             case FORMULA:
    103.                 //读公式计算值
    104.                 value = String.valueOf(cell.getNumericCellValue());
    105.                 if (value.equals("NaN")) {// 如果获取的数据值为非法值,则转换为获取字符串
    106.                     value = cell.getStringCellValue();
    107.                 }
    108.                 break;
    109.             // 布尔类型
    110.             case BOOLEAN:
    111.                 value = " "+ cell.getBooleanCellValue();
    112.                 break;
    113.             default:
    114.                 value = cell.getStringCellValue();
    115.         }
    116.         if("null".endsWith(value.trim())){
    117.             value="";
    118.         }
    119.         return value;
    120.     }
    121. }

    5、已经获取到了Excel表格中所有的数据，包含所有的行和列，都在List中，这一步所有的数据获取完了

    6、有了数据，要将数据存储到数据库。

    7、需要创建数据库字段的实体类，使用@Excel注解将表格和数据库字段名一一对应

    1. @Data
    2. @TableName("t_student")//数据库名字
    3. public class Student{
    4.  
    5.         @TableId(type = IdType.AUTO)
    6.         @Excel(name = "序号", cellType = Excel.ColumnType.NUMERIC)
    7.         private Long id;
    8.  
    9.         @Excel(name = "学生ID")
    10.         private Long id;
    11.  
    12.         @Excel(name = "名称")
    13.         private String name;
    14.  
    15.         @Excel(name = "性别")
    16.         private String sex;
    17.  
    18.         @Excel(name = "年龄")
    19.         private String age;
    20.  
    21.       
    22.         
    23. }

    8、通过双重 for循环遍历List,内层List为列，外层List为行，如下图将第一行数据单独拿出来，作为判断字段，如果实体类等@Excel注解属性和Excel表格第一行名字相同，对实体类进行set赋值

    1. //定义Excel第一行的属性
    2. List<Object> firstRows = null;
    3. //获取第一行属性 放入firstRows中。
    4. if(list != null && list.size() > 0){
    5. 	firstRows = list.get(0);
    6. }
    7. //遍历除第一行以外的Excel表格中的值
    8. for (int i = 1; i < list.size(); i++) {
    9.     //rows是某一行，i = 1 为第二行，	i = 2 为第三行
    10.     List<Object> rows = list.get(i);
    11.     //数据库数据的实体类
    12.     Student student =new student();
    13.     //遍历这一行所有的值
    14.     for (int j = 0; j < rows.size(); j++){
    15.     //某一行的某一列 j为列的坐标    
    16.     String cellVal = (String) rows.get(j);
    17.      //对实体类进行赋值,使用setFieldValueByFieldName方法，下面详细讲代码
    18.     TestExcel.setFieldValueByFieldName(questionBank, firstRows.get(j).toString().trim(), 	 cellVal);
    19.                     }
    20.  
    21.                 }
    22.      // 使用spring插入到数据库
    23.      questionBankService.save(questionBank);
    24.             }

    9、从第二行开始，每遍历完一行，将获得一个实体类对象，因为是结合数据库写的实体类，通过springboot可以直接插入数据库。

    1. public class TestExcel {
    2.  
    3.     /**
    4.      * 用反射方法，获取列名，比较，为属性赋值
    5.      * @param object
    6.      * @param fieldName
    7.      * @param val
    8.      */
    9.     public static void setFieldValueByFieldName(Object object, String fieldName, Object val) {
    10.         try {
    11.             //通过反射获取所有实体类所有定义的方法,object为数据库实体类
    12.             Field[] fields = object.getClass().getDeclaredFields();
    13.             //遍历fields
    14.             for (int i = 0; i < fields.length; i++) {
    15.                 Field field = fields[i];
    16.                 //读取注释，如@Excel(name = "科目")
    17.                 Excel annotation = field.getAnnotation(Excel.class);
    18.                 //因为private类型，所有要设置允许
    19.                 field.setAccessible(true);
    20.                 //annotation.name() 注解里的属性,如果annotation没写注解，读取原始名字如subject
    21.                 if(annotation == null){
    22.                     if(fieldName.equals(field.getName())){
    23.                         if(field.getType() == Integer.class){
    24.                             field.set(object, Integer.valueOf(val.toString()));
    25.                         }else if(field.getType() == Long.class){
    26.                             field.set(object, Long.valueOf(val.toString()));
    27.                         }else {
    28.                             field.set(object, val);
    29.                         }
    30.                         return;
    31.                     }  
    32.                 }else {//设置了注解，并且表格里的Excel字段值和注解的name值相同，则为相应字段赋值
    33.                     if(fieldName.equals(annotation.name())){
    34.                         //进行类型判断，因为实体类中变量类型不同。
    35.                         if(field.getType() == Integer.class){
    36.                             field.set(object, Integer.valueOf(val.toString()));
    37.                         }else if(field.getType() == Long.class){
    38.                             field.set(object, Long.valueOf(val.toString()));
    39.                         }else {
    40.                             field.set(object, val);
    41.                         }
    42.                         return;
    43.                     }
    44.                 }
    45.  
    46.             }
    47.         }catch (Exception e){
    48.             e.printStackTrace();
    49.         }
    50.     }
    51.  
    52. }

    六、通用读取excel工具类 

    1. package com.ssm;
    2.  
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.InputStream;
    6. import java.util.ArrayList;
    7. import java.util.HashMap;
    8. import java.util.List;
    9. import java.util.Map;
    10.  
    11. import org.apache.poi.hssf.usermodel.HSSFCell;
    12. import org.apache.poi.hssf.usermodel.HSSFRow;
    13. import org.apache.poi.hssf.usermodel.HSSFSheet;
    14. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
    15. import org.apache.poi.ss.usermodel.CellType;
    16. import org.apache.poi.xssf.usermodel.XSSFCell;
    17. import org.apache.poi.xssf.usermodel.XSSFRow;
    18. import org.apache.poi.xssf.usermodel.XSSFSheet;
    19. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    20.  
    21. public class ReadExcel {
    22. 	
    23. 	public List<Map<String,String>> readExcel(String filepath, String filename, int startrow, int startcol, int sheetnum) {
    24. 		List<Map<String, String>> varList = new ArrayList>();
    25. 		String suffix = filename.substring(filename.lastIndexOf(".") + 1);
    26. 		if ("xls".equals(suffix)) {
    27. 			varList = readExcel2003(filepath, filename, startrow, startcol, sheetnum);
    28. 		} else if ("xlsx".equals(suffix)) {
    29. 			varList = readExcel2007(filepath, filename, startrow, startcol, sheetnum);
    30. 		} else {
    31. 			System.out.println("Only excel files with XLS or XLSX suffixes are allowed to be read!");
    32. 			return null;
    33. 		}
    34. 		return varList;
    35. 	}
    36.     
    37.  
    38.    
    39.     /**
    40. 	 * 读取2003Excel
    41. 	 * 
    42. 	 * @param filepath 文件路径
    43. 	 * @param filename 文件名，包括扩展名
    44. 	 * @param startrow 开始行号，索引从0开始
    45. 	 * @param startcol 开始列号，索引从0开始
    46. 	 * @param sheetnum 工作簿，索引从0开始
    47. 	 * @return
    48. 	 */
    49. 	public static List<Map<String,String>> readExcel2003(String filepath, String filename, int startrow, int startcol, int sheetnum) {
    50. 		List<Map<String, String>> varList = new ArrayList>();
    51. 		try {
    52. 			File target = new File(filepath, filename);
    53. 			FileInputStream fis = new FileInputStream(target);
    54. 			HSSFWorkbook wb = new HSSFWorkbook(fis);
    55. 			fis.close();
    56. 			// sheet 从0开始
    57. 			HSSFSheet sheet = wb.getSheetAt(sheetnum);
    58. 			// 取得最后一行的行号
    59. 			int rowNum = sheet.getLastRowNum() + 1;
    60.  
    61. 			HSSFRow rowTitle = sheet.getRow(0);
    62. 			// 标题行的最后一个单元格位置
    63. 			int cellTitleNum = rowTitle.getLastCellNum();
    64. 			String[] title = new String[cellTitleNum];
    65. 			for (int i = startcol; i < cellTitleNum; i++) {
    66. 				HSSFCell cell = rowTitle.getCell(Short.parseShort(i + ""));
    67. 				if (cell != null) {
    68. 					cell.setCellType(CellType.STRING);
    69. 					title[i] = cell.getStringCellValue();
    70. 				} else {
    71. 					title[i] = "";
    72. 				}
    73. 			}
    74.  
    75. 			// 行循环开始
    76. 			for (int i = startrow + 1; i < rowNum; i++) {
    77. 				Map<String, String> varpd = new HashMap<String, String>();
    78. 				// 行
    79. 				HSSFRow row = sheet.getRow(i);
    80. 				// 列循环开始
    81. 				for (int j = startcol; j < cellTitleNum; j++) {
    82.  
    83. 					HSSFCell cell = row.getCell(Short.parseShort(j + ""));
    84. 					String cellValue = "";
    85. 					if (cell != null) {
    86. 						// 把类型先设置为字符串类型
    87. 						cell.setCellType(CellType.STRING);
    88. 						cellValue = cell.getStringCellValue();
    89. 					}
    90. 					varpd.put(title[j], cellValue);
    91. 				}
    92. 				varList.add(varpd);
    93. 			}
    94. 			wb.close();
    95. 		} catch (Exception e) {
    96. 			System.out.println(e);
    97. 		}
    98. 		return varList;
    99. 	}
    100. 	
    101. 	/**
    102. 	 * 读取2007Excel
    103. 	 * 
    104. 	 * @param filepath 文件路径
    105. 	 * @param filename 文件名，包括扩展名
    106. 	 * @param startrow 开始行号，索引从0开始
    107. 	 * @param startcol 开始列号，索引从0开始
    108. 	 * @param sheetnum 工作簿，索引从0开始
    109. 	 * @return
    110. 	 */
    111. 	public List<Map<String,String>> readExcel2007(String filepath, String filename, int startrow, int startcol, int sheetnum) {
    112. 		List<Map<String, String>> varList = new ArrayList>();
    113. 		try {
    114. 			File target = new File(filepath, filename);
    115. 			InputStream ins = new FileInputStream(target);
    116. 			XSSFWorkbook wb = new XSSFWorkbook(ins);
    117. 			ins.close();
    118. 			// 得到Excel工作表对象
    119. 			XSSFSheet sheet = wb.getSheetAt(sheetnum);
    120. 			// 取得最后一行的行号
    121. 			int rowNum = sheet.getLastRowNum() + 1;
    122.  
    123. 			XSSFRow rowTitle = sheet.getRow(0);
    124. 			int cellTitleNum = rowTitle.getLastCellNum();
    125. 			String[] title = new String[cellTitleNum];
    126. 			for (int i = startcol; i < cellTitleNum; i++) {
    127. 				XSSFCell cell = rowTitle.getCell(Short.parseShort(i + ""));
    128. 				if (cell != null) {
    129. 					// 把类型先设置为字符串类型
    130. 					cell.setCellType(CellType.STRING);
    131. 					title[i] = cell.getStringCellValue();
    132. 				} else {
    133. 					title[i] = "";
    134. 				}
    135. 			}
    136.  
    137. 			// 行循环开始
    138. 			for (int i = startrow + 1; i < rowNum; i++) {
    139. 				Map<String, String> varpd = new HashMap<String, String>();
    140. 				// 得到Excel工作表的行
    141. 				XSSFRow row = sheet.getRow(i);
    142. 				// 列循环开始
    143. 				for (int j = startcol; j < cellTitleNum; j++) {
    144. 					// 得到Excel工作表指定行的单元格
    145. 					XSSFCell cell = row.getCell(j);
    146. 					String cellValue = "";
    147. 					if (cell != null) {
    148. 						// 把类型先设置为字符串类型
    149. 						cell.setCellType(CellType.STRING);
    150. 						cellValue = cell.getStringCellValue();
    151. 					}
    152. 					varpd.put(title[j], cellValue);
    153. 				}
    154. 				varList.add(varpd);
    155. 			}
    156. 			wb.close();
    157. 		} catch (Exception e) {
    158. 			System.out.println(e);
    159. 		}
    160. 		return varList;
    161. 	}
    162.     
    163.     
    164.     
    165.     
    166.     
    167.     
    168.     
    169.     
    170.     
    171. }

  • 相关阅读:
    洛谷_P1305 新二叉树、UVA536 二叉树重建 Tree Recovery
    python运行带参数的python文件
    @Reference 、@Resource和@Autowired的简单区分
    Windows10专业版系统安装Hyper-V虚拟机软件
    CPP emplace_bake 和 push_back 的相同和区别
    系统架构师备考倒计时13天(每日知识点)
    SpringMVC 始+五种数据提交的方法
    为什么我学了几天 STM32 感觉一脸茫然？
    LET‘S BUILD A NEW ENTRY GATE FOR THE PALACE
    IDEA 在远程 Tomcat 上运行项目（亲身避坑版）
  • 原文地址：https://blog.csdn.net/m0_37346206/article/details/133631355