Java Row.getLastCellNum方法代码示例

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
public static List<String[]> readExcel(InputStream is, int sheetIndex) throws Exception {
	Workbook workbook = WorkbookFactory.create(is);
	Sheet sheet = workbook.getSheetAt(sheetIndex);
	List<String[]> data = new ArrayList<>();
	for (int i = sheet.getFirstRowNum(); i <= sheet.getLastRowNum(); i++) {
		Row row = sheet.getRow(i);
		if (row == null) continue;
		int last = row.getLastCellNum();
		String[] rowData = new String[last];
		for (int j = 0; j < last; j++) {
			Cell cell = row.getCell(j);
			rowData[j] = cell == null ? null : getCellString(cell);
		}
		data.add(rowData);
	}
	return data;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
private List<String> getClasses(Row classRow) {
	//声明一个list，用来存放所有的字段类型
	List<String> classList = new ArrayList<String>();
	//判断这一行是否为空
	if (classRow != null) {
		//遍历这一行的所有单元格
		for (int i = 0; i < classRow.getLastCellNum(); i++) {
			//获取单元格
			Cell cell = classRow.getCell(i);
			//判断单元格是否为空
			if (cell != null) {
				//将单元格的内容存放到list中
				classList.add(cell.getStringCellValue());
			}
		}
	}
	//返回所有的字段类型
	return classList;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
private void setSheetData(SheetData data, String group) {
	data.setCurrentGroup(group);
	// start from 1
	data.setCurrentIndex(1);
	// get sheet
	Sheet vSheet = getWorkBook().getSheet(group);
	Assert.notNull(vSheet, "Can't get sheet with name: " + group);
	data.setSheet(vSheet);
	// get row number
	int vRowCount = vSheet.getLastRowNum() + 1;
	data.setRowCount(vRowCount);
	// get first row
	Row vRow = vSheet.getRow(0);
	Assert.notNull(vRow, "Invalid format: first row must be title");
	// get column number
	int vColumnCount = vRow.getLastCellNum();
	String[] vTitles = new String[vColumnCount];
	// read titles
	for (int i = 0; i < vColumnCount; ++i) {
		Cell vCell = vRow.getCell(i);
		vTitles[i] = vCell.getStringCellValue();
	}
	data.setTitles(vTitles);
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
/**
 * 解析行
 * @param row
 * @return
 */
protected List<Object> parseRow(Row row) {
	List<Object> rowData = new ArrayList<Object>();

	for (int i = 0; i < row.getLastCellNum(); i++) {
		Cell cell = row.getCell(i);
		Object cellObj=null;
		if(cell!=null){
			cellObj = parseCell(cell);
		}
		rowData.add(cellObj);
	}
	/*// 迭代 一行的各个单元格
	Iterator<Cell> cellIterator = row.iterator();
	// 遍历一行多列
	while (cellIterator.hasNext()) {
		Cell cell = cellIterator.next();
		Object cellObj = parseCell(cell);
		rowData.add(cellObj);
	}*/
	return rowData;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
private List<String> getAnnotations(Row annotationRow) {
	//声明一个list，用来存放所有的字段说明
	List<String> annotationList = new ArrayList<String>();
	//判断，字段说明那一行是否为空
	if (annotationRow != null) {
		//遍历字段说明这一行所有的单元格
		for (int i = 0; i < annotationRow.getLastCellNum(); i++) {
			//获取单元格
			Cell cell = annotationRow.getCell(i);
			//判断单元格是否为空
			if (cell != null) {
				//将单元格中的内容放入List中
				annotationList.add(cell.getStringCellValue());
			}
		}
	}
	//返回所有的字段说明
	return annotationList;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
private boolean isRowEmpty(Row row) {
    for (int c = row.getFirstCellNum(); c < row.getLastCellNum(); c++) {
        Cell cell = row.getCell(c, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
        if (cell != null && cell.getCellTypeEnum() != CellType.BLANK)
            return false;
    }
    return true;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
private Object[] getNames(Row namesRow) {
	//实例化一个List,该list中存放的是所有的字段名
	List<String> nameList = new ArrayList<String>();
	//实例化一个int值，该值表示key字段在excel中的位置
	int keyNum = 0;
	//实例化一个object类型的数组，该数组中存放的是所有的字段名和key字段的位置
	Object[] obj = new Object[2];
	//判断namesRow这个行是否为空
	if (namesRow != null) {
		//遍历namesRow这一行
		for (int i = 0; i < namesRow.getLastCellNum(); i++) {
			//获取单元格
			Cell cell = namesRow.getCell(i);
			//判断单元格是否为空
			if (cell != null) {
				//添加单元格的内容到nameList中
				nameList.add(cell.getStringCellValue());
				//判断这个单元格的内容是不是Key
				if (cell.getStringCellValue().equalsIgnoreCase("Key")) {
					//记录Key的位置
					keyNum = i;
				}
			}
		}
	}
	//将所有的字段名放入obj[0]
	obj[0] = nameList;
	//将key列的位置放入obj[1]
	obj[1] = keyNum;
	//返回obj
	return obj;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
private Map<Characteristic, CharacteristicValue> getCharacteristicsValues(Row row, List<Characteristic> characteristics) {
  Map<Characteristic, CharacteristicValue> characteristicsValues = new HashMap<>();

  for (int i = 1; i < row.getLastCellNum(); i++) {
    characteristicsValues.put(characteristics.get(i - 1), new CharacteristicValue(row.getCell(i).getStringCellValue()));
  }

  return characteristicsValues;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
/**
 * 行复制功能（空白行的复制，即只复制格式和固定文字，不填充数据）
 * 
 * @author      ZhengWei(HY)
 * @createDate  2017-07-03
 * @version     v1.0
 *
 * @param i_RTemplate      模板
 * @param i_TemplateRow    模板中的行对象
 * @param i_DataWorkbook   数据工作薄
 * @param io_RTotal        将数据写入Excel时的辅助统计信息。
 * @param io_RSystemValue  系统变量信息
 * @param i_DataRow        数据中的行对象
 * @param i_Datas          本行对应的数据
 * 
 * @return                 返回本方法内一共生成多少新行。
 */
public final static int copyRowByBlankSpace(RTemplate i_RTemplate ,Row i_TemplateRow ,RWorkbook i_DataWorkbook ,RTotal io_RTotal ,RSystemValue io_RSystemValue ,Row i_DataRow) 
{
    i_DataRow.setHeight(    i_TemplateRow.getHeight());
    i_DataRow.setZeroHeight(i_TemplateRow.getZeroHeight());
    
    int v_CellCount = i_TemplateRow.getLastCellNum();
    
    for (int v_CellIndex=0; v_CellIndex<v_CellCount; v_CellIndex++) 
    {
        Cell v_TemplateCell = i_TemplateRow.getCell(v_CellIndex);
        if ( v_TemplateCell == null )
        {
            continue;
        }
        
        Cell v_DataCell = i_DataRow.getCell(v_CellIndex);
        if ( v_DataCell == null ) 
        {
            v_DataCell = i_DataRow.createCell(v_CellIndex);
        }
        
        copyCellByBlankSpace(i_RTemplate ,v_TemplateCell ,i_DataWorkbook ,v_DataCell ,io_RSystemValue);
    }
    
    return 0;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
/**
 * Iterates through the sheet and determines the cells that are between START_TEST_CASE and END_TEST_CASE comments.
 * Also determines if the data table is to be returned as a Cartesian product of the rows.
 * @param sheet
 * @throws DataProviderException
 */
private void determineTestDataFrame(
                                     Sheet sheet ) throws DataProviderException {

    int rows = sheet.getLastRowNum() + 1;
    int columns = sheet.getRow(sheet.getLastRowNum()).getLastCellNum();
    // iterate throughout the spreadsheet's cells
    for (int x = 0; x < columns; x++) {
        for (int y = 0; y < rows; y++) {
            Row rowValue = sheet.getRow(y);
            if (rowValue != null) {

                if (rowValue.getLastCellNum() > columns) {
                    columns = rowValue.getLastCellNum();
                }

                Cell current = rowValue.getCell(x, Row.CREATE_NULL_AS_BLANK);
                if (hasComments(current)) {
                    if (isStartingCell(current)) {
                        this.startingCell = current;
                    }
                    if (isEndingCell(current)) {
                        this.endingCell = current;
                    }
                    if (isMultiplyCell(current)) {
                        this.isMultipliable = true;
                    }
                }
            }
        }
    }

    if (this.startingCell == null) {
        throw new DataProviderException(ERROR_LOCATING_STARTING_CELL);
    } else if (this.endingCell == null) {
        throw new DataProviderException(ERROR_LOCATING_ENDING_CELL);
    }

    if (this.startingCell.getRowIndex() <= this.endingCell.getRowIndex()) {
        if (this.startingCell.getColumnIndex() <= this.endingCell.getColumnIndex()) {
            return;
        }
    }

    throw new DataProviderException(WRONG_ORDER);
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
private Object[] getTypes(Row typeRow, int keyNum) {
	//声明一个List，用来存放所有要放入生成的client端的xml文件中的数据位置信息
	List<Integer> cnums = new ArrayList<Integer>();
	//声明一个List，用来存放所有要放入生成的server端的xml文件中的数据位置信息
	List<Integer> snums = new ArrayList<Integer>();
	//声明一个boolean值，用来判断是否要生成client端的xml文件
	boolean cfal = false;
	//声明一个boolean值，用来判断是否要生成server端的xml文件
	boolean sfal = false;
	//声明一个object数字，用来存放这一行所要返回的信息
	Object[] obj = new Object[4];
	//判断这一行是否为空
	if (typeRow != null) {
		//遍历这一行的所有单元格
		for (int i = 0; i < typeRow.getLastCellNum(); i++) {
			//获取单元格
			Cell cell = typeRow.getCell(i);
			//判断单元格是否为空
			if (cell != null) {
				//判断单元格的内容是否为C，为C表示这一列要放入到生成的client端要使用的xml文件中
				if (cell.getStringCellValue().equals("C")) {
					//添加单元格位置到cnums中
					cnums.add(i);
					//判断是否是key列，如果是，表示要生成client端使用的xml文件
					if (keyNum == i) {
						//将判断是否生成client端使用的xml文件的标志设为true
						cfal = true;
					}
				//判断单元格的内容是否为S，为S表示这一列要放入到生成的server端要使用的xml文件中
				} else if (cell.getStringCellValue().equals("S")) {
					//添加单元格位置到snums中
					snums.add(i);
					//判断是否是key列，如果是，表示要生成server端使用的xml文件
					if (keyNum == i) {
						//将判断是否生成server端使用的xml文件的标志设为true
						sfal = true;
					}
				//判断单元格的内容是否为A，为A表示这一列既要放入到生成的client端使用的xml文件中，又要放入到生成的server端要使用的xml文件中
				} else if (cell.getStringCellValue().equals("A")) {
					//添加单元格位置到cnums中
					cnums.add(i);
					//添加单元格位置到snums中
					snums.add(i);
					//判断是否是key列，如果是，表示要生成client端和server端使用的xml文件
					if (keyNum == i) {
						//将判断是否生成client端使用的xml文件的标志设为true
						cfal = true;
						//将判断是否生成server端使用的xml文件的标志设为true
						sfal = true;
					}
				}
			}
		}
	}
	//将要生成client端xml文件的位置信息放入到obj[0]
	obj[0] = cnums;
	//将要生成server端xml文件的位置信息放入到obj[1]
	obj[1] = snums;
	//将判断是否要生成client端xml文件的标志放入到obj[2]
	obj[2] = cfal;
	//将判断是否要生成server端xml文件的标志放入到obj[3]
	obj[3] = sfal;
	//返回这一行所有的信息
	return obj;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
public final static PartitionMap<String ,RCell> readDatas(Sheet i_Sheet ,Integer i_BeginRow ,Integer i_EndRow)
{
    PartitionMap<String ,RCell> v_Ret      = new TablePartition<String ,RCell>();
    Sheet                       v_Sheet    = i_Sheet;
    int                         v_BeginRow = 0;
    int                         v_EndRow   = 0;
    
    if ( i_BeginRow != null )
    {
        v_BeginRow = i_BeginRow.intValue();
        
        if ( v_BeginRow < 0 )
        {
            v_BeginRow = 0;
        }
    }
    
    if ( i_EndRow != null )
    {
        v_EndRow = i_EndRow.intValue();
    }
    else
    {
        v_EndRow = v_Sheet.getPhysicalNumberOfRows();
    }
    
    for (int v_RowNo=v_BeginRow; v_RowNo<=v_EndRow; v_RowNo++)
    {
        Row v_Row = v_Sheet.getRow(v_RowNo);
        if ( v_Row == null )
        {
            continue;
        }
        
        short v_CellCount = v_Row.getLastCellNum();
        
        for (int v_ColumnNo=0; v_ColumnNo<v_CellCount; v_ColumnNo++)
        {
            Cell v_Cell = v_Row.getCell(v_ColumnNo);
            if ( v_Cell == null )
            {
                continue;
            }
            
            if ( v_Cell.getCellTypeEnum() == CellType.STRING )
            {
                String v_Value = v_Cell.getStringCellValue();
                
                if ( !Help.isNull(v_Value) )
                {
                    RCell        v_RCell    = new RCell(v_RowNo ,v_ColumnNo);
                    List<String> v_Decimals = StringHelp.getString(v_Cell.getCellStyle().getDataFormatString() ,$Decimal);
                    if ( !Help.isNull(v_Decimals) )
                    {
                        v_RCell.setDecimal(v_Decimals.get(0).split("\\.")[1].length());
                    }
                    
                    v_Ret.putRow(v_Value.trim() ,v_RCell);
                }
            }
            else if ( v_Cell.getCellTypeEnum() == CellType.NUMERIC )
            {
                if ( HSSFDateUtil.isCellDateFormatted(v_Cell) ) 
                {
                    if ( v_Cell.getDateCellValue() != null )
                    {
                        v_Ret.putRow((new Date(v_Cell.getDateCellValue())).getFull() ,new RCell(v_RowNo ,v_ColumnNo));
                    }
                } 
                else 
                {
                    v_Ret.putRow(String.valueOf(v_Cell.getNumericCellValue()) ,new RCell(v_RowNo ,v_ColumnNo));
                }
            }
        }
    }
    
    return v_Ret;
}
 

import org.apache.poi.ss.usermodel.Row; //导入方法依赖的package包/类
/**
 * 处理excel到List(用于简单导入，不返回具体实体的列表／简单导入使用)
 *
 * @param inputStream 文件流
 * @return 数据列表
 */
public static List<Map<String, String>> read(InputStream inputStream) throws IOException,
        InvalidFormatException {


    Sheet sheet = inputStream2Sheet(inputStream);
    if (sheet == null) {
        return Collections.emptyList();
    }

    Row row;
    Iterator<Row> rows = sheet.rowIterator();
    //表头
    List<String> titleList = new ArrayList<>();

    List<Map<String, String>> result = new ArrayList<>();
    //是否是第一行
    boolean firstRow = true;
    while (rows.hasNext()) {
        //每行数据的Map，key为表头，value为值
        Map<String, String> map = new HashMap<>();

        row = rows.next();
        if (isBlankRow(row)) {
            break;
        }

        for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {
            Cell cell = row.getCell(i);
            if (cell == null) {
                continue;
            }
            //取得cell值
            String cellValue = getCellFormatValue(cell);
            if (firstRow) {
                titleList.add(cellValue.trim());
            } else {
                if (i < titleList.size()) {
                    map.put(titleList.get(i), cellValue.trim());
                }
            }
        }
        //每行记录加入
        if (map.size() > 0) {
            result.add(map);
        }
        //第一行设置为否
        firstRow = false;
    }
    return result;
}