POI跨行导出excell表格实现

最新推荐文章于 2023-02-17 15:29:37 发布
最新推荐文章于 2023-02-17 15:29:37 发布
阅读量134 收藏
点赞数 1
分类专栏： 文件处理 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33355858/article/details/86619329
版权

一：分析解决思想

1.需求：有一张含有父子级关系的跨行表格，需要将该表格的数据导入到数据库中存储，修改操作。（多行10列，每两列为同一级别的数据，共有5个不同级数据在表格中）

2.会出现的问题：由于多级跨行，跨行的数据只有第一行是有值的，第二行就是空值。也有可能由于某一级真的没有子级，造成真实的空值数据。

3.解决思想： 用一个变量来接受表格中的真实数据，跨行的时候不重新赋值，沿用本行的上一行数据，充当本行的数据。真实的空值数据，子级也会是空值，判断子级和本级是否同时为空值，同时为空值就是真实的空值数据。该数据不进入数据库。

4.实现原理：由于是多级存储，子级需要存入父级的id，id是自己生成的，所以先要存入最高级别的数据再存入，第二高级别的数据，由于跨行多子级数据就会出现很多重复数据，这样就考虑用map存取数据。一共有5级，那么需要5个map进行存储数据。

二：实现代码

1.编写controller

/**
	 *    表单导入方法
	 * @param request
	 * @param response
	 * @throws Exception
	 */
	@RequestMapping(value = "export")
    public void exportEvaluationTemplate(ultipartFile file) throws Exception {
		 
		ocScopeService.uploadScopeExcel(file);
		
	}

2.编写存储方法的service

@Transactional(readOnly = false)
	public void uploadScopeExcel(MultipartFile file) throws IOException, Exception {


		Map<String, OcScope> ocScopeMapDictOne = Maps.newHashMap();
		List<OcScope > listOcScope = new ArrayList<>();
		Map<String, OcScope> ocScopeMap = Maps.newHashMap();
		Map<String, OcScope> ocScopeMapOne = Maps.newHashMap();  //用于存储第1级数据:最高级别数据
		Map<String, OcScope>  ocScopeMapTwo = Maps.newHashMap();//用于存储第2级数据
		Map<String, OcScope>  ocScopeMapThree = Maps.newHashMap();//用于存储第3级数据
		Map<String, OcScope>  ocScopeMapFour = Maps.newHashMap();//用于存储第4级数据
		Map<String, OcScope>  ocScopeMapFive = Maps.newHashMap();//用于存储第5级数据
		
		String originalFileName = file.getOriginalFilename();
		InputStream is = file.getInputStream();
		int version = 0;
    //判断版本号
		if (originalFileName.endsWith(".xls")) {
			version = 2003;
		}else if (originalFileName.endsWith(".xlsx")) {
			version = 2007;
		}else {
			throw new Exception("Incorrect file format,Only allowed '.xls,.xlsx' extension");
		}
		Workbook workbook = null;
		switch (version) {
			case 2003:
				POIFSFileSystem fs = new POIFSFileSystem(new BufferedInputStream(is));
				workbook = new HSSFWorkbook(fs);
				break;
	
			case 2007:
				workbook = new XSSFWorkbook(new BufferedInputStream(is));
				break;
		}
		
		int sheetIndex = workbook.getSheetIndex("评估模板");
		Sheet sheet = workbook.getSheetAt(sheetIndex);
		//由于表格是一张多级跨行的数据，所以不能简单的读取每一行的数据。需要引入几个变量进行数据存储赋值操作，
		String p4 = ""; String p3 = ""; String p2 = ""; String p1 = ""; double w1 = 0D;double w2 = 0D;double w3 = 0D;double w4 = 0D;
	     int code1=0; int code2=0; int code3=0; int code4=0;    int wCode1=0; int wCode2=0; int wCode3=0; int wCode4=0;  
		for (Row row : sheet) {
			OcScope ocScope = new OcScope();
			int rowNum = row.getRowNum();
//			if(e==1){break;}
			if(rowNum == 0){//跳出第一行   一般第一行都是表头没有数据意义
				continue;
			}
			int startCell = 0; //
			if(row.getCell(startCell)!=null ){//第1列数据
				 code4=0;
		          row.getCell(startCell).setCellType(Cell.CELL_TYPE_STRING);
		          if(!row.getCell(startCell).getStringCellValue().equals("")){
		        	 p4 = row.getCell(startCell).getStringCellValue();
		        	 code4=1;  //用于判断 p4的值是虚值还是真实的值，便于真实空格的数据导入不出错  
		          }
			}
			startCell++;
			if(row.getCell(startCell)!=null){//第2列
				wCode4=0;
		    	row.getCell(startCell).setCellType(Cell.CELL_TYPE_NUMERIC);
		    	if(row.getCell(startCell).getNumericCellValue()!=0.0){
		    		w4 = row.getCell(startCell).getNumericCellValue();
		    		wCode4=1;
		    	}
			}
		    	startCell++;
		    	if(row.getCell(startCell)!=null ){//第3列数据
		    		 code3=0;
			          row.getCell(startCell).setCellType(Cell.CELL_TYPE_STRING);
			          if(!row.getCell(startCell).getStringCellValue().equals("")){
			        	 p3 = row.getCell(startCell).getStringCellValue();
			        	 code3=1;
			          }
				}
		    	
		    	startCell++;
				if(row.getCell(startCell)!=null){//第4列
					wCode3=0;
			    	row.getCell(startCell).setCellType(Cell.CELL_TYPE_NUMERIC);
			    	if(row.getCell(startCell).getNumericCellValue()!=0.0){
			    		w3 = row.getCell(startCell).getNumericCellValue();
			    		wCode3=1;
			    	}
				}
			    	startCell++;
			    	if(row.getCell(startCell)!=null ){//第5列数据
			    		 code2=0;
				          row.getCell(startCell).setCellType(Cell.CELL_TYPE_STRING);
				          if(!row.getCell(startCell).getStringCellValue().equals("")){
				        	 p2 = row.getCell(startCell).getStringCellValue();
				        	 code2=1;
				          }
					}
			    	startCell++;
					if(row.getCell(startCell)!=null){//第6列
						wCode2=0;
				    	row.getCell(startCell).setCellType(Cell.CELL_TYPE_NUMERIC);
				    	if(row.getCell(startCell).getNumericCellValue()!=0.0){
				    		w2 = row.getCell(startCell).getNumericCellValue();
				    		wCode2=1;
				    	}
					}
				    	startCell++;
				    	if(row.getCell(startCell)!=null ){//第7列数据
				    		  code1=0;
					          row.getCell(startCell).setCellType(Cell.CELL_TYPE_STRING);
					          if(!row.getCell(startCell).getStringCellValue().equals("")){
					        	 p1 = row.getCell(startCell).getStringCellValue();
					        	 code1=1;
					          }
						}
				    	startCell++;
						if(row.getCell(startCell)!=null){//第8列
							wCode1=0;
					    	row.getCell(startCell).setCellType(Cell.CELL_TYPE_NUMERIC);
					    	if(row.getCell(startCell).getNumericCellValue()!=0.0){
					    		w1 = row.getCell(startCell).getNumericCellValue();
					    		wCode1=1;
					    	}
						}
            //最后两行是第五级数据，由于该级不存在跨行，所以直接赋值
					    	startCell++;
					    	if(row.getCell(startCell)!=null ){//第9列数据
						          row.getCell(startCell).setCellType(Cell.CELL_TYPE_STRING);
						          if(!row.getCell(startCell).getStringCellValue().equals("")){
						        	  ocScope.setScopeName(row.getCell(startCell).getStringCellValue());
						          }
							}
					    	startCell++;
							if(row.getCell(startCell)!=null){//第10列
						    	row.getCell(startCell).setCellType(Cell.CELL_TYPE_NUMERIC);
						    	if(row.getCell(startCell).getNumericCellValue()!=0.0){
						    		ocScope.setWeights(row.getCell(startCell).getNumericCellValue());
						    	}
							}
						    	ocScope.setP4ScopeName(p4);  //此种赋值好处，是解决跨行数据内部第二行读到空值数据，直接将上一行的数据赋值给自身用
						    	ocScope.setP4Weights(w4);
						    	ocScope.setP3ScopeName(p3);
						    	ocScope.setP3Weights(w3);
						    	ocScope.setP2ScopeName(p2);
						    	ocScope.setP2Weights(w2);
						    	ocScope.setP1ScopeName(p1);
						    	ocScope.setP1Weights(w1);
                  
						    	if(StringUtils.isEmpty(ocScope.getScopeName()) && code1==0){
						    		ocScope.setP1ScopeName("");  //当子级为空，P1父级为虚值时，说明该行是个真实的空行
						    	}
						    	//由于Double类型的值在读表的时候会将空值读成0,所以需要判断其是真实的0值还是，跨行度的上一级的值
						    	if(StringUtils.isEmpty(ocScope.getScopeName()) && code1==1 && wCode1==0){
						    		ocScope.setP1Weights(0.00);   //当子级为空，P1级的值是真实的时,w1读的值却是上一级的虚值，说明该行是个真实的0值，需要将真实的0值赋值给该行数据。
						    	}
						    	if(StringUtils.isEmpty(ocScope.getScopeName()) && code1==0 && code2==0){
						    		ocScope.setP2ScopeName("");
						    	}
						    	
						    	if(StringUtils.isEmpty(ocScope.getScopeName()) && code1==0 && code2==1 && wCode2==0){
						    		ocScope.setP2Weights(0.00);
						    	}
						    	if(StringUtils.isEmpty(ocScope.getScopeName()) && code1==0 && code2==0 && code3==0){
						    		ocScope.setP3ScopeName("");
						    	}
						    	if(StringUtils.isEmpty(ocScope.getScopeName()) && code1==0 && code2==0 && code1==0 && wCode3==0){
						    		ocScope.setP3Weights(0.00);
						    	}
						    	//实体可以用list接收，也可以用map，本列用map接收。
						    //istOcScope.add(ocScope);
						    	ocScopeMap.put(p4+p3+p2+p1+ocScope.getScopeName(), ocScope);//key值是关键，将其四个直系父级和本身同时放入key值中。避免去重出错。
		}
		
		//遍历主map，取出1，2，3，4，5，级的数据。并包装到相应的map中去。
		for (String key : ocScopeMap.keySet()) { 
				 
				 //获取第1级数据
				   OcScope ocScope1 = new OcScope();
				   ocScope1.setScopeName(ocScopeMap.get(key).getP4ScopeName());
				   ocScope1.setParentName(null);
				   ocScope1.setLevel("1");
				    ocScope1.setWeights(ocScopeMap.get(key).getP4Weights());
					ocScopeMapDictOne.put(ocScopeMap.get(key).getP4ScopeName(), ocScope1) ;
					//将数据封装到1级的map中在去
					ocScopeMapOne.put(ocScopeMap.get(key).getP4ScopeName(), ocScope1);
					
					//获取第2级数据
					OcScope ocScope2 = new OcScope();
					ocScope2.setParentName(ocScopeMap.get(key).getP4ScopeName());
					ocScope2.setScopeName(ocScopeMap.get(key).getP3ScopeName());
					ocScope2.setLevel("2");
					ocScope2.setWeights(ocScopeMap.get(key).getP3Weights());
					//将数据封装到2级的map中去
				    ocScopeMapTwo.put(ocScopeMap.get(key).getP4ScopeName()+ocScopeMap.get(key).getP3ScopeName(), ocScope2);
				    
				         //获取第3级数据
				    OcScope ocScope3 = new OcScope();
				    //该级需要装GrandFatherName属性进去，避免错误的将数据存储在相同的父级名称，不同爷爷级别的数据中去
				    ocScope3.setGrandFatherName(ocScopeMap.get(key).getP4ScopeName());
				    ocScope3.setParentName(ocScopeMap.get(key).getP3ScopeName());
				    ocScope3.setScopeName(ocScopeMap.get(key).getP2ScopeName());
				    ocScope3.setLevel("3");
				    ocScope3.setWeights(ocScopeMap.get(key).getP2Weights());
				    //将数据封装到3级的map中去 
				    ocScopeMapThree.put(ocScopeMap.get(key).getP3ScopeName()+ocScopeMap.get(key).getP2ScopeName(), ocScope3);
				    
				     //获取第4级数据
				    OcScope ocScope4 = new OcScope();
				  //该级需要装GrandFatherName属性进去，避免错误的将数据存储在相同的父级名称，不同爷爷级别的数据中去
				    ocScope4.setGrandFatherName(ocScopeMap.get(key).getP3ScopeName());
				    ocScope4.setParentName(ocScopeMap.get(key).getP2ScopeName());
				    ocScope4.setScopeName(ocScopeMap.get(key).getP1ScopeName());
				    ocScope4.setLevel("4");
				    ocScope4.setWeights(ocScopeMap.get(key).getP1Weights());
				  //将数据封装到4级的map中去
				    ocScopeMapFour.put(ocScopeMap.get(key).getP2ScopeName()+ocScopeMap.get(key).getP1ScopeName(), ocScope4);
				    
				    //获取第4级数据
				    OcScope ocScope5 = new OcScope();
				  //该级需要装GrandFatherName属性进去，避免错误的将数据存储在相同的父级名称，不同爷爷级别的数据中去
				    ocScope5.setGrandFatherName(ocScopeMap.get(key).getP2ScopeName());
				    ocScope5.setParentName(ocScopeMap.get(key).getP1ScopeName());
				    ocScope5.setScopeName(ocScopeMap.get(key).getScopeName());
				    ocScope5.setLevel("5");
				    ocScope5.setWeights(ocScopeMap.get(key).getWeights());
				    ocScopeMapFive.put(ocScopeMap.get(key).getP1ScopeName()+ocScopeMap.get(key).getScopeName(), ocScope5);
				           
			  
		}
		 //从数据库查询出所有的数据
		List<OcScope> ocScopelist=	dao.findList(new OcScope()); 
		List<OcScope> ocScopelistOne=  new ArrayList<>();
		List<OcScope> ocScopelistTwo= new ArrayList<>();
		List<OcScope> ocScopelistThree=	new ArrayList<>();
		List<OcScope> ocScopelistFour= new ArrayList<>();
		List<OcScope> ocScopelistFive= new ArrayList<>();
//		遍历封装1.2.3.4.5级的数据到list中去 (避免查询太多的数据库查询次数，导致性能不足)
	 for (OcScope ocScope : ocScopelist) {
		if(ocScope.getLevel().equals("1")){
			ocScopelistOne.add(ocScope);
		}
		if(ocScope.getLevel().equals("2")){
			ocScopelistTwo.add(ocScope);
		}
		if(ocScope.getLevel().equals("3")){
			ocScopelistThree.add(ocScope);
		}
		if(ocScope.getLevel().equals("4")){
			ocScopelistFour.add(ocScope);
		}
		if(ocScope.getLevel().equals("5")){
			ocScopelistFive.add(ocScope);
		}
		
	}
	
    	OcDict ocDict =new  OcDict();
    	ocDict.setType("evaluation_dimension");
    List<OcDict> 	ocDictLiset= ocDictService.findList(ocDict);
    List<Integer> OcDictListValue= new ArrayList<>();
    for (OcDict ocDict2 : ocDictLiset) {
    	OcDictListValue.add(Integer.valueOf(ocDict2.getValue()));
	}
	List<String> mapCode=new ArrayList<>();
     Integer max = Collections.max(OcDictListValue);
    	for (String key : ocScopeMapDictOne.keySet()) { 
			for (OcDict ocDict1  :  ocDictLiset) {
				if(ocScopeMapDictOne.get(key).getScopeName().equals(ocDict1.getLabel())){
					mapCode.add(key);
    			}
			}
		}
    	for (String str : mapCode) {
    		ocScopeMapDictOne.remove(str);
		}
    	
    	for (String key : ocScopeMapDictOne.keySet()) { 
    		OcDict ocDict3 =new  OcDict();
			ocDict3.setLabel(ocScopeMapDictOne.get(key).getScopeName());
			ocDict3.setType("evaluation_dimension");
			max++;
		    String v=max.toString();
			ocDict3.setValue(v);
			ocDictService.save(ocDict3);
    	}
    	 List<OcDict> 	ocDictLiset2= ocDictService.findList(ocDict);
    	 for (String key : ocScopeMapOne.keySet()) {   //遍历level=1的数据
    		 for (OcDict ocDict1  :  ocDictLiset2) {
    			 if(ocScopeMapOne.get(key).getScopeName().equals(ocDict1.getLabel())){
    				 ocScopeMapOne.get(key).setType(ocDict1.getValue());
    				 OcScope OcScope = new OcScope();
						OcScope.setId("0");  //由于其是第一级，故将其父级id设为0
						ocScopeMapOne.get(key).setParent(OcScope);       //将数据加入
    		 }
    		 }
    	 }
    	List<String> map1CodeList= new  ArrayList<>(); //用于记录map中的数据，和数据库中的数据是否有重复。
		for (String key : ocScopeMapOne.keySet()) { 
			for (OcScope ocScope1 : ocScopelistOne) {
				if(ocScopeMapOne.get(key).getScopeName().equals(ocScope1.getScopeName())){
					map1CodeList.add(key); //记录key值
					if(ocScopeMapOne.get(key).getWeights()!=ocScope1.getWeights()){
						ocScope1.setWeights(ocScopeMapOne.get(key).getWeights());
						OcScope OcScope = new OcScope();
						OcScope.setId("0");  //由于其是第一级，故将其父级id设为0
						ocScope1.setParent(OcScope);
						save(ocScope1);
			} 
				}
			}
		}
		
		for (String str : map1CodeList) {
			ocScopeMapOne.remove(str);  //将map中包含的数据中的数据清除掉
		}
		for (String key : ocScopeMapOne.keySet()) {
			 if(ocScopeMapOne.get(key).getScopeName()!=null && !ocScopeMapOne.get(key).getScopeName().equals("")){
					save(ocScopeMapOne.get(key));//将剩余的数据且不为空的存入到数据库中
				}
		}
		
		
		OcScope ocScopeOne = new OcScope();
		ocScopeOne.setLevel("1");
    	List<OcScope> ocScopelistOnes=	dao.findList(ocScopeOne);   //取出最新的level=2的数据
    
	
		for (String key : ocScopeMapTwo.keySet()) { 
			for (OcScope ocScope1 :  ocScopelistOnes) {
				if(ocScopeMapTwo.get(key).getParentName().equals(ocScope1.getScopeName())){  //判断父级的名称是否等于一级的名称
					ocScopeMapTwo.get(key).setParent(ocScope1);       //将数据加入
					ocScopeMapTwo.get(key).setType(ocScope1.getType());  
    			}
			}
		}
		
		
		List<String> map2CodeList= new  ArrayList<>(); 
		for (String key : ocScopeMapTwo.keySet()) {   //遍历ocScopeMapTwo
			for (OcScope ocScope2 : ocScopelistTwo) { //遍历ocScopelistTwo   level=2的数据
				if(ocScopeMapTwo.get(key).getScopeName().equals(ocScope2.getScopeName())){   //判断名称是否相等
					map2CodeList.add(key);         //相等加入map2CodeList 后面会将其处理掉，不新增该list中的数据  (易错点：对于批量增加数据而言需要判断相等记录下来，而不是判断不等就新增)
					if(ocScopeMapTwo.get(key).getWeights()!=ocScope2.getWeights()){   //判断名称相等的情况下，权重是否改变，权重改变了要更新到数据库中
						ocScope2.setWeights(ocScopeMapTwo.get(key).getWeights());
						ocScope2.setType(ocScopeMapTwo.get(key).getType());
						for (OcScope ocScope1 : ocScopelistOnes) {
							if(ocScope2.getParentId().equals(ocScope1.getId())){
								ocScope2.setParent(ocScope1);
								 save(ocScope2);
							}
						}
						
					}
			} 
			}
		}
		
		for (String str : map2CodeList) {   
			ocScopeMapTwo.remove(str);  //在ocScopeMapTwo中移除数据库已近存在的数据
		}
		
		for (String key : ocScopeMapTwo.keySet()) {
			 if(ocScopeMapTwo.get(key).getScopeName()!=null && !ocScopeMapTwo.get(key).getScopeName().equals("")){
					save(ocScopeMapTwo.get(key));//将剩余的数据且不为空的存入到数据库中
				}
		}
		
		OcScope ocScopeTwo = new OcScope();
		 ocScopeTwo.setLevel("2");
	List<OcScope> ocScopelistTwos=	dao.findList(ocScopeTwo);  //取出最新的level=2的数据
		for (String key : ocScopeMapThree.keySet()) { 
			for (OcScope ocScope2 :  ocScopelistTwos) {
				//由于数据多存在不同父级，相同子级的数据，所以需判读其GrandFather级别的数据是否相等
				if(ocScopeMapThree.get(key).getParentName().equals(ocScope2.getScopeName()) && ocScopeMapThree.get(key).getGrandFatherName().equals(ocScope2.getParentName())){
					ocScopeMapThree.get(key).setParent(ocScope2);
					ocScopeMapThree.get(key).setType(ocScope2.getType());
    			}
			}
		}
		List<String> map3CodeList= new  ArrayList<>();
		for (String key : ocScopeMapThree.keySet()) { 
			for (OcScope ocScope3 : ocScopelistThree) {
				if(ocScopeMapThree.get(key).getScopeName().equals(ocScope3.getScopeName())){
					map3CodeList.add(key);
					if(ocScopeMapThree.get(key).getWeights()!=ocScope3.getWeights()){
						ocScope3.setWeights(ocScopeMapThree.get(key).getWeights());
						ocScope3.setType(ocScopeMapThree.get(key).getType());
						for (OcScope ocScope2 : ocScopelistTwos) {
							if(ocScope3.getParentId().equals(ocScope2.getId())){
								ocScope3.setParent(ocScope2);
								 save(ocScope3);
							}
						}
					}
			} 
			}
		}
		for (String str : map3CodeList) {
			ocScopeMapThree.remove(str);
		}
		for (String key : ocScopeMapThree.keySet()) {
			 if(ocScopeMapThree.get(key).getScopeName()!=null && !ocScopeMapThree.get(key).getScopeName().equals("")){
					save(ocScopeMapThree.get(key));
				}
		}
		
		
		OcScope ocScopeThree = new OcScope();
		 ocScopeThree.setLevel("3");
   	List<OcScope> ocScopelistThrees=	dao.findList(ocScopeThree);  //取出最新的level=3的数据
   	//遍历 level=4的数据
		for (String key : ocScopeMapFour.keySet()) { 
			for (OcScope ocScope3 :  ocScopelistThrees) {
				if(ocScopeMapFour.get(key).getParentName().equals(ocScope3.getScopeName()) && ocScopeMapFour.get(key).getGrandFatherName().equals(ocScope3.getParentName()) ){
					ocScopeMapFour.get(key).setParent(ocScope3);
					ocScopeMapFour.get(key).setType(ocScope3.getType());
    			}
			}
		}
		
		List<String> map4CodeList= new  ArrayList<>();
		for (String key : ocScopeMapFour.keySet()) { 
			for (OcScope ocScope4 : ocScopelistFour) {
				if(ocScopeMapFour.get(key).getScopeName().equals(ocScope4.getScopeName())){
					map4CodeList.add(key);
					if(ocScopeMapFour.get(key).getWeights()!=ocScope4.getWeights()){
						ocScope4.setWeights(ocScopeMapFour.get(key).getWeights());
						ocScope4.setType(ocScopeMapFour.get(key).getType());
						for (OcScope ocScope3 : ocScopelistThrees) {
							if(ocScope4.getParentId().equals(ocScope3.getId())){
								ocScope4.setParent(ocScope3);
								 save(ocScope4);
							}
						}
					}
			} 
			}
		}
		
		for (String str : map4CodeList) {
			ocScopeMapFour.remove(str);
		}
		for (String key : ocScopeMapFour.keySet()) {
				if(ocScopeMapFour.get(key).getScopeName()!=null && !ocScopeMapFour.get(key).getScopeName().equals("")){
					save(ocScopeMapFour.get(key));
				}
			 
		}
		
		OcScope ocScopeFour = new OcScope();
		ocScopeFour.setLevel("4");
		List<OcScope> ocScopelistFours=	dao.findList(ocScopeFour);  //取出最新的level=4的数据
		
		//遍历 level=5的数据
		for (String key : ocScopeMapFive.keySet()) { 
			for (OcScope ocScope4 :  ocScopelistFours) {
				if(ocScopeMapFive.get(key).getParentName().equals(ocScope4.getScopeName()) && ocScopeMapFive.get(key).getGrandFatherName().equals(ocScope4.getParentName())  ){
					ocScopeMapFive.get(key).setParent(ocScope4);
					ocScopeMapFive.get(key).setType(ocScope4.getType());
    			}
			}
		}
		
		List<String> map5CodeList= new  ArrayList<>();
		for (String key : ocScopeMapFive.keySet()) { 
			for (OcScope ocScope5 : ocScopelistFive) {
				if(ocScopeMapFive.get(key).getScopeName().equals(ocScope5.getScopeName())){
					map5CodeList.add(key);
					if(ocScopeMapFive.get(key).getWeights()!=ocScope5.getWeights()){
						ocScope5.setWeights(ocScopeMapFive.get(key).getWeights());
						ocScope5.setType(ocScopeMapFive.get(key).getType());
						for (OcScope ocScope4 : ocScopelistFours) {
							if(ocScope5.getParentId().equals(ocScope4.getId())){
								ocScope5.setParent(ocScope4);
								 save(ocScope5);
							}
						}
					}
			} 
			}
		}
		
		for (String str : map5CodeList) {
			ocScopeMapFive.remove(str);
		}
		for (String key : ocScopeMapFive.keySet()) {
			if(ocScopeMapFive.get(key).getScopeName()!=null && !ocScopeMapFive.get(key).getScopeName().equals("")){
				save(ocScopeMapFive.get(key));
			}
			 
		}
		
		
	}
佳佳乐2503
关注
专栏目录
使用POI导出跨行跨列
ajax_yan的博客
04-08 595
https://q.cnblogs.com/q/52096/ @RequestMapping("/export3") public void export3(HttpServletResponse response) throws Exception { String fileName ="学生"; Pattern pattern = Pattern.compile...
html页面表格导出为excel表格实现 excel POI
可爱的程序yuan
07-25 1950
/** * 下载文件，通过html页面直接将表导出 * * @param response * @param request * @param fileName * @param html * @throws Exception */ @RequestMapping(params = "downloadFile") public void downloadFile(HttpSe...
java跨行_java实现导出Excel(跨行，跨列)
weixin_27283495的博客
02-12 692
先来个最终结果样式：第一步： 传参，后期可根据自己需要进行调整。我这里需要的是quarter 代表季度dptid 部门编号根据接受过来的参数进行文档命名。UserInfo userInfo=(UserInfo)request.getSession().getAttribute("userInfo");String userid=userInfo.getUserID();String quarter...
poi导出excel跨行跨列
kaicen的博客
01-13 1239
poi导出excel跨行跨列 1、实体类 package cn.com.ws.utils; public class PoiModel { private String content; private String oldContent; private int rowIndex; private int cellIndex; public String getOldContent() { ...
java中Excel导出模板（跨行跨列导出）
麦 -_- 的博客
11-04 1109
跳转地址：点我 java中Excel导出模板（跨行跨列导出） 在这里插入图片描述 这个地方看似不难，实际后台很复杂，数据的来源也复杂，并不好处理。但是这不是让我纠结的地方。 我纠结的地方是，表头的跨行跨列，而且有的列还是动态的。 有了技术问题的时候，捋捋思路后，如果还解决不了，那可能是要去百度了，因为毕竟是在工作，不要耽误时间，赶紧解决问题。 七拼八凑整理了一套方法（后边附上代码），实现的小时如下： 在这里插入图片描述 就这样，表头的问题就解决了。 代码： package com.incon.project
Java POI创建excel 的跨行跨列
zane的博客
09-14 9774
  在开发中难免会遇到需要提交excel文件进行报表数据批量更新等需求，本次记录的契机是有报表需要用到excel进行批量更新数据，同时需要提供excel模板文件的下载，而这个模板就存在很多跨行跨列的需求，之前也在网上找过不少博文，但是不少的都是较为老的版本呢了，poi已经对某些方法进行过时处理了。   废话不多说  进入正文   首先是创建sheet页 wb = new HSSFWorkb...
java实现合并单元格的同时并导出excel示例
08-31
Java实现合并单元格的同时并导出Excel示例 Java实现合并单元格的同时并导出Excel是软件开发中常见的一种需求，特别是在报表系统和数据处理中。本文将详细介绍Java实现合并单元格的同时并导出Excel的相关知识点，并...
java POI 写Excel ，替换EXCEL模板内容。跨多行跨多列操作数据
霍城延的随笔
08-05 1106
首先那：先看下成果： 替换成功。 下面贴下源码： 首先在pom.xml 中引入： <!-- poi 相关 --> <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi</artifactId> <version>4.0.1</version.
POI使用word模板文件循环输出行并导出word
08-12
在这个例子中，我们将探讨如何使用POI库来处理Word文档，特别是利用模板文件循环输出表格行并导出新的Word文档。这个过程在数据分析、报告生成或自动化文档制作等场景中非常有用。 首先，我们需要理解Word文档的...
poi复制一行数据到另外一行_POI 复制excel一行到另外一个sheet页(修改) | 学步园...
weixin_35039377的博客
12-23 816
package cosmic.leon;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import org.apache.poi.hssf.usermodel.HSSFCell;import ...
java实现导出Excel多行表头复杂模板
12-20
java实现导出Excel多行表头复杂模板 一般我们都会选择poi来导出，选择一个比较好的ExcelUtils 但是对于初学者而言不了解poi的，还需从poi API文档去学习，如果是自学的话更好，如果是公司安排的任务，没有接触过有期限的，就大大的浪费时间了，所以我在这里给一些职场人士第一次接触导出Excel总结的一个简单好用的方法 原创文章 1获赞 1访问量 23 关注
自定义导出word表格的格式和内容，跨行跨列等操作
03-04
自定义导出word表格的格式和内容，跨行跨列等操作，可供学习和参考。
POI复杂表头及跨行跨列文件生成
最新发布
vezine的博客
02-17 859
使用poi自定义生成excel并生成文件流传到前端进行下载
poi中word中表格跨列合并以及不兼容wps问题，java下 linux下word转pdf 问题解决
FlyDanke的博客
11-27 4503
最近需要在word中绘制表格，绘制完成后发现 wps不支持poi的跨列合并，百度没有找到好的解决办法。自己在office中把文档转换为doc格式之后发现wps可以正常显示word中的表格了，同时之前微信预览不到表格的问题也解决了。 poi版本为3.17 以下是跨列以及跨行合并代码 之前网上搜到的 忘记原作者是哪位大佬了 maven &lt;!--poi 用于操作wor...
POI框架导出EXCEL的简单列子（跨行跨列）合并单元格
燕窝
05-02 1万+
public static void main(String[] args) throws IOException { try{ HSSFWorkbook wb = new HSSFWorkbook(); HSSFSheet sheet = wb.createSheet("new sheet")
导出动态Excel表头、动态跨行、跨列
qq_24192465的博客
12-29 4965
package cn.doofen.service.impl; import java.io.OutputStream; import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.apache.poi.hs
java poi 合并单元格
热门推荐
我要飞翔
03-29 8万+
poi 合并 单元格 XSSFWorkbook wb = new XSSFWorkbook(); XSSFSheet sheet = wb.createSheet(); //这个就是合并单元格 //参数说明：1：开始行 2：结束行 3：开始列 4：结束列 //比如我要合并 第二行到第四行的 第六列到第八列 sheet.addMergedRegion(new CellRang
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值