vue后端--导入--单元格类型判断和转换

 判断单元格类型转换成String

 private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    private static String getCellToStr (Cell cell){
        String cellStr = "";
        if (cell != null) {
            // 根据单元格类型处理
            switch (cell.getCellType()) {
                case STRING:
                    // 如果单元格是文本类型，直接获取
                    cellStr = cell.getStringCellValue();
                    break;
                case NUMERIC:
                    // 如果单元格是数字类型，转换为字符串获取
                    if (DateUtil.isCellDateFormatted(cell)) {
                        Date date = cell.getDateCellValue();
                        cellStr = dateFormat.format(date);
                    } else {
                        // 不是日期,直接返回其字符串表示
                        cellStr = String.valueOf(cell.getNumericCellValue());
                    }
                    break;
                case BOOLEAN:
                    // 如果单元格是布尔类型，转换为字符串
                    cellStr = Boolean.toString(cell.getBooleanCellValue());
                    break;
                case FORMULA:
                    // 如果单元格是公式类型，先评估公式再获取值（可能还是数字或字符串等）
                    // 简单处理为调用formatter转化成字符串
                    DataFormatter formatter = new DataFormatter();
                    cellStr = formatter.formatCellValue(cell);
                    break;
                case BLANK:
                    // 如果单元格为空，则返回空字符串或特殊标记
                    cellStr = ""; // 设置为 "NULL" 或其他标记
                    break;
                default:
                    // 处理未知或不支持的单元格类型
                    throw new IllegalStateException("不支持的单元格类型: " + cell.getCellType());
            }
        }
        return cellStr;
    }

 判断单元格类型转换成BigDecimal

    private static final SimpleDateFormat sdf = new SimpleDateFormat("###.###");
    // 解析可能包含数字的字符串，根据实际格式调整
    private static BigDecimal getCellToBigDecimal (Cell cell){
        BigDecimal cellBd = BigDecimal.valueOf(0);
        if (cell != null) {
            // 根据单元格类型处理
            switch (cell.getCellType()) {
                case NUMERIC:
                    // 如果单元格是数字类型
                    // 检查是否为日期格式（尽管通常不推荐将日期转换为BigDecimal）
                    if (!DateUtil.isCellDateFormatted(cell)) {
                        // 不为日期直接作为数字处理
                        cellBd = BigDecimal.valueOf(cell.getNumericCellValue());
                    }
                    else {
                        cellBd = null;
                    }
                    break;
                case STRING:
                    // 将字符串解析为BigDecimal
                    try {
                        //cellBd = new BigDecimal(cell.getStringCellValue());
                        cellBd = new BigDecimal(sdf.parse(cell.getStringCellValue()).toString());
                    } catch (ParseException e) {
                        cellBd = null;
                    }
                    break;
                case BOOLEAN:
                    // 将布尔值映射为BigDecimal（例如，true为1，false为0）
                    cellBd = BigDecimal.valueOf(cell.getBooleanCellValue() ? 1 : 0);
                    break;
                case FORMULA:
                    // 评估公式并获取结果类型
                    CellType formulaCellType = cell.getCachedFormulaResultType();
                    if (formulaCellType == CellType.NUMERIC) {
                        // 如果公式结果是数字，则按数字处理
                        cellBd = BigDecimal.valueOf(cell.getNumericCellValue());
                    } else if (formulaCellType == CellType.STRING) {
                        // 如果公式结果是字符串，则尝试按字符串处理
                        try {
                            cellBd = new BigDecimal(sdf.parse(cell.getStringCellValue()).toString());
                        } catch (ParseException e) {
                            cellBd = null; // 或抛出异常
                        }
                    } else if (formulaCellType == CellType.BOOLEAN) {
                        // 如果公式结果是布尔值，则按布尔值处理
                        cellBd = BigDecimal.valueOf(cell.getBooleanCellValue() ? 1 : 0);
                    } else {
                        // 处理其他类型的公式结果（可能是BLANK, ERROR等）
                        cellBd = null; // 或抛出异常
                    }
                    break;
                default:
                    // 处理未知或不支持的单元格类型
                    throw new IllegalStateException("不支持的单元格类型: " + cell.getCellType());
            }
        }
        return cellBd;
    }

应用

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String importDataList(MultipartFile file) {
        String result = "";
        List<EcComprehensive> list = new ArrayList<>();
        try {
            //获取ec_energy_dic
            EcEnergyDic ecDto = new EcEnergyDic();
            List<EcEnergyDic> ecEnergyDicList = ecEnergyDicService.selectEcEnergyDicList(ecDto);
            //
            Workbook workbook = null;
            String suffix = FilenameUtils.getExtension(file.getOriginalFilename()).toLowerCase();
            InputStream inputStream = file.getInputStream();
            if ("xlsx".equals(suffix) || "xls".equals(suffix)) {
                workbook = new HSSFWorkbook(inputStream);
            } else if ("xlsx".equals(suffix)) {
                workbook = new XSSFWorkbook(inputStream);
            } else {
                throw new IllegalArgumentException("不支持的文件类型: " + suffix);
            }
            //获取sheet的数量
            int sheetSize = workbook.getNumberOfSheets();
            //循环sheet数
            for (int k = 0; k < sheetSize; k++) {
                Sheet sheet = workbook.getSheetAt(k);
                String sheetName = sheet.getSheetName();
                if (sheetName == null || sheetName.trim().isEmpty() || sheetName.matches("^Sheet\\d+$")) {
                    // 如果名称不符合要求，则使用默认名称或生成新名称
                    sheetName = "2024" + (k + 1);
                }
                //循环行数
                String organization = "";
                for (int i = 2; i <= sheet.getLastRowNum(); i++) {
                    Row row = sheet.getRow(i);
                    if(i == 2){
                        organization = getCellToStr(row.getCell(0));
                    }
                    else {
                        String s = getCellToStr(row.getCell(0));
                        if (!s.isEmpty()) {
                            if (!s.equals(organization)) {
                                organization = s;
                            }
                        }
                    }
                    for (int j = 4; j < 16; j++){
                        EcComprehensive dto = new EcComprehensive();
                        dto.setId(BaseInfo.getNewId());
                        dto.setCreateUser("admin");
                        dto.setCreateTime(new Date());
                        dto.setOrganization(organization);
                        dto.setYear(Integer.valueOf(sheetName));///未命名报错
                        dto.setMonth(j-3);
                        String energyName = getCellToStr(row.getCell(1));
                        String energy = "" ;
                        for (EcEnergyDic ec :ecEnergyDicList){
                            if (energyName.equals(ec.getEnergy())){
                                energy = ec.getId();
                                break;
                            }
                        }
                        dto.setEnergy(energy);
                        BigDecimal value = getCellToBigDecimal(row.getCell(j));
                        dto.setValue(value);
                        list.add(dto);
                    }
                }
            }
            if(list.size()>0){
                for (EcComprehensive ecComprehensive : list){
                    comprehensiveMapper.insert(ecComprehensive);
                }
            }
        } catch (Exception e) {
            result = e.getMessage();
            e.printStackTrace();
            throw new RuntimeException();
        }
        return  result;
    }