Example usage for org.apache.poi.hssf.usermodel HSSFCell getNumericCellValue

List of usage examples for org.apache.poi.hssf.usermodel HSSFCell getNumericCellValue

  1. HOME
  2. Java
  3. org.apache.poi
  4. org.apache.poi.hssf.usermodel.*
  5. HSSFCell
  6. getNumericCellValue

Introduction

In this page you can find the example usage for org.apache.poi.hssf.usermodel HSSFCell getNumericCellValue.

Prototype

public double getNumericCellValue()

Source Link

Document

Get the value of the cell as a number.

Usage

From source file:edu.fcps.hutchison.LabelBuilder.java

License:Open Source License

protected String getCellValStr(HSSFCell cell) {
    if (cell == null) {
        return "";
    } else if (cell.getCellType() == HSSFCell.CELL_TYPE_BOOLEAN) {
        return Boolean.toString(cell.getBooleanCellValue());
    } else if (cell.getCellType() == HSSFCell.CELL_TYPE_NUMERIC) {
        return Double.toString(cell.getNumericCellValue());
    } else if (cell.getCellType() == HSSFCell.CELL_TYPE_STRING) {
        return cell.getRichStringCellValue().toString();
    } else if (cell.getCellType() == HSSFCell.CELL_TYPE_BLANK) {
        return "";
    } else if (cell.getCellType() == HSSFCell.CELL_TYPE_FORMULA) {
        return cell.getCellFormula();
    } else if (cell.getCellType() == HSSFCell.CELL_TYPE_ERROR) {
        return String.valueOf(cell.getErrorCellValue());
    } else {//from   ww  w .ja v  a 2  s  .  co m
        return "";
    }
}

From source file:edu.fcps.hutchison.LabelBuilder.java

License:Open Source License

/**
 * Derive the schema from the contents of an Excel workbook
 *//*from   w  w w  . j  av a  2s.  c om*/
protected void generate() throws Exception {
    //start at the second row of the first sheet  -the first row has the column names
    HSSFSheet sheet = _excelWorkbook.getSheetAt(0);
    HSSFSheet outSheet = newWorkbook.createSheet();
    int rowct = 1;
    int newRows = 1;
    while (true) {
        HSSFRow row = sheet.getRow(rowct);
        if (row == null) {
            break;
        }
        HSSFCell cell = row.getCell(COPIES_COLUMN);
        if (cell == null) {
            break;
        }
        String copies = getCellValStr(cell);
        if (copies.equals("") || copies == null) {
            //last row is blank...return
            break;
        }
        int numCopies;
        try {
            numCopies = (int) cell.getNumericCellValue(); //gives 0 for empty cells
        } catch (java.lang.IllegalStateException e) {
            continue;
        }
        for (int j = 0; j < numCopies; j++) {
            HSSFRow outRow = outSheet.createRow(newRows);
            for (int i = 0; i < COLUMNS; i++) {
                System.out.println(row.getCell(i));
                //TODO write to the new workbook
                outRow.createCell(i).setCellValue(getCellValStr(row.getCell(i)));
            }
            newRows++;
        }
        rowct++;
    }
    OutputStream os = new FileOutputStream("test.xls");
    newWorkbook.write(os);
    os.close();
}

From source file:edu.ku.brc.specify.tasks.subpane.wb.ConfigureXLS.java

License:Open Source License

@Override
protected void nonInteractiveConfig() {
    try {/*from   w  w  w.  j a  va  2 s  .c o  m*/
        InputStream input = new FileInputStream(externalFile);
        POIFSFileSystem fs = new POIFSFileSystem(input);
        HSSFWorkbook workBook = new HSSFWorkbook(fs);
        HSSFSheet sheet = workBook.getSheetAt(0);

        // Calculate the number of rows and columns
        colInfo = new Vector<ImportColumnInfo>(16);

        Hashtable<Integer, Boolean> colTracker = new Hashtable<Integer, Boolean>();

        boolean firstRow = true;
        int col = 0;
        colTracker.clear();

        Vector<Integer> badHeads = new Vector<Integer>();
        Vector<Integer> emptyCols = new Vector<Integer>();
        checkHeadsAndCols(sheet, badHeads, emptyCols);

        if (firstRowHasHeaders && badHeads.size() > 0) {
            status = ConfigureExternalDataIFace.Status.Error;
            showBadHeadingsMsg(badHeads, null, getResourceString("Error"));
            return;
        }

        // Iterate over each row in the sheet
        @SuppressWarnings("unchecked")
        Iterator<HSSFRow> rows = sheet.rowIterator();
        while (rows.hasNext()) {
            HSSFRow row = rows.next();
            if (firstRow || numRows == 1) {
                // Iterate over each cell in the row and print out the cell's content
                int colNum = 0;
                int maxSize = Math.max(row.getPhysicalNumberOfCells(), row.getLastCellNum());
                while (colNum < maxSize) {
                    if (emptyCols.indexOf(new Integer(colNum)) == -1) {
                        ImportColumnInfo.ColumnType disciplinee = ImportColumnInfo.ColumnType.Integer;
                        String value = null;
                        boolean skip = false;
                        HSSFCell cell = row.getCell(colNum);
                        if (cell == null) {
                            //assuming numRows == 1 or not firstRowHasHeaders.
                            //the call to checkHeadsAndCols would have already blank headers.
                            value = "";
                            disciplinee = ImportColumnInfo.ColumnType.String;
                        } else
                            switch (cell.getCellType()) {
                            case HSSFCell.CELL_TYPE_NUMERIC:
                                double numeric = cell.getNumericCellValue();
                                value = Double.toString(numeric);
                                disciplinee = ImportColumnInfo.ColumnType.Double;
                                break;
                            case HSSFCell.CELL_TYPE_STRING:
                                HSSFRichTextString richVal = cell.getRichStringCellValue();
                                value = richVal.getString().trim();
                                disciplinee = ImportColumnInfo.ColumnType.String;
                                break;
                            case HSSFCell.CELL_TYPE_BLANK:
                                value = "";
                                disciplinee = ImportColumnInfo.ColumnType.String;
                                break;
                            case HSSFCell.CELL_TYPE_BOOLEAN:
                                boolean bool = cell.getBooleanCellValue();
                                value = Boolean.toString(bool);
                                disciplinee = ImportColumnInfo.ColumnType.Boolean;
                                break;
                            default:
                                skip = true;
                                break;
                            }

                        if (numRows == 1 && !skip) {
                            colInfo.get(col).setData(value);
                            col++;
                        } else if (!skip) {
                            if (firstRowHasHeaders) {
                                colInfo.add(new ImportColumnInfo(colNum, disciplinee, value, value, null, null,
                                        null));
                                colTracker.put(col, true);
                            } else {
                                String colName = getResourceString("DEFAULT_COLUMN_NAME") + " " + (colNum + 1);
                                colInfo.add(new ImportColumnInfo(colNum, disciplinee, colName, colName, null,
                                        null, null));
                                colTracker.put(colNum, true);
                            }
                            numCols++;
                        }
                    }
                    colNum++;
                }
                firstRow = false;
            }
            numRows++;
        }
        Collections.sort(colInfo);
        readMappings(fs);
        status = Status.Valid;
    } catch (IOException ex) {
        edu.ku.brc.af.core.UsageTracker.incrHandledUsageCount();
        edu.ku.brc.exceptions.ExceptionTracker.getInstance().capture(ConfigureXLS.class, ex);
        status = Status.Error;
    }
}

From source file:edu.ku.brc.specify.tasks.subpane.wb.DataImportDialog.java

License:Open Source License

/**
 * Parses the given import xls file according to the users selection and creates/updates the
 * Preview table, showing the user how the import options effect the way the data will be
 * imported into the spreadsheet./* w  ww  .j a  va  2s  .  c  o  m*/
 * 
 * @param table - the table to display the data
 * @return JTable - the table to display the data
 */
private JTable setXLSTableData(final JTable table) {
    int numRows = 0;
    int numCols = 0;
    String[] headers = {};
    Vector<Vector<String>> tableDataVector = new Vector<Vector<String>>();
    Vector<String> rowData = new Vector<String>();
    Vector<String> headerVector = new Vector<String>();
    DateWrapper scrDateFormat = AppPrefsCache.getDateWrapper("ui", "formatting", "scrdateformat");
    try {
        log.debug("setXLSTableData - file - " + configXLS.getFile().toString());

        InputStream input = new FileInputStream(configXLS.getFile());
        POIFSFileSystem fs = new POIFSFileSystem(input);
        HSSFWorkbook workBook = new HSSFWorkbook(fs);
        HSSFSheet sheet = workBook.getSheetAt(0);

        Vector<Integer> badHeads = new Vector<Integer>();
        Vector<Integer> emptyCols = new Vector<Integer>();
        ((ConfigureXLS) config).checkHeadsAndCols(sheet, badHeads, emptyCols);
        if (badHeads.size() > 0 && doesFirstRowHaveHeaders) {
            if (table != null) {
                ((ConfigureXLS) config).showBadHeadingsMsg(badHeads, emptyCols, getTitle());
            }
            this.doesFirstRowHaveHeaders = false;
            try {
                ignoreActions = true;
                this.containsHeaders.setSelected(false);
            } finally {
                ignoreActions = false;
            }
            if (table != null) {
                return table;
            }
        }
        boolean firstRow = true;

        //quick fix to prevent ".0" at end of catalog numbers etc
        NumberFormat nf = NumberFormat.getInstance();
        nf.setMinimumFractionDigits(0);
        nf.setMaximumFractionDigits(20);
        nf.setGroupingUsed(false); //gets rid of commas

        int maxCols = 0;

        // Iterate over each row in the sheet
        Iterator<?> rows = sheet.rowIterator();
        while (rows.hasNext()) {
            numCols = 0;
            rowData = new Vector<String>();
            HSSFRow row = (HSSFRow) rows.next();
            //log.debug(row.getLastCellNum()+"  "+row.getPhysicalNumberOfCells());
            int maxSize = Math.max(row.getPhysicalNumberOfCells(), row.getLastCellNum());
            if (maxSize > maxCols) {
                maxCols = maxSize;
            }
            while (numCols < maxSize) {
                if (emptyCols.indexOf(new Integer(numCols)) == -1) {
                    HSSFCell cell = row.getCell(numCols);
                    String value = null;
                    // if cell is blank, set value to ""
                    if (cell == null) {
                        value = "";
                    } else {
                        int type = cell.getCellType();

                        switch (type) {
                        case HSSFCell.CELL_TYPE_NUMERIC:
                            // The best I can do at this point in the app is to guess if a
                            // cell is a date.
                            // Handle dates carefully while using HSSF. Excel stores all
                            // dates as numbers, internally.
                            // The only way to distinguish a date is by the formatting of
                            // the cell. (If you
                            // have ever formatted a cell containing a date in Excel, you
                            // will know what I mean.)
                            // Therefore, for a cell containing a date, cell.getCellType()
                            // will return
                            // HSSFCell.CELL_TYPE_NUMERIC. However, you can use a utility
                            // function,
                            // HSSFDateUtil.isCellDateFormatted(cell), to check if the cell
                            // can be a date.
                            // This function checks the format against a few internal
                            // formats to decide the issue,
                            // but by its very nature it is prone to false negatives.
                            if (HSSFDateUtil.isCellDateFormatted(cell)) {
                                value = scrDateFormat.getSimpleDateFormat().format(cell.getDateCellValue());
                                //value = scrDateFormat.getSimpleDateFormat().format(cell.getDateCellValue());
                            } else {
                                double numeric = cell.getNumericCellValue();
                                value = nf.format(numeric);
                            }
                            break;

                        case HSSFCell.CELL_TYPE_STRING:
                            value = cell.getRichStringCellValue().getString();
                            break;

                        case HSSFCell.CELL_TYPE_BLANK:
                            value = "";
                            break;

                        case HSSFCell.CELL_TYPE_BOOLEAN:
                            value = Boolean.toString(cell.getBooleanCellValue());
                            break;

                        case HSSFCell.CELL_TYPE_FORMULA:
                            value = UIRegistry.getResourceString("WB_FORMULA_IMPORT_NO_PREVIEW");
                            break;

                        default:
                            value = "";
                            log.error("unsuported cell type");
                            break;
                        }
                    }
                    if (firstRow && doesFirstRowHaveHeaders) {
                        checkUserColInfo(value, numCols);
                    }
                    if (isUserCol(numCols)) {
                        rowData.add(value.toString());
                    }
                }
                numCols++;
            }
            if (doesFirstRowHaveHeaders && firstRow) {
                headerVector = rowData;
                headers = new String[rowData.size()];
            } else if (!doesFirstRowHaveHeaders && firstRow) {
                //headers = createDummyHeaders(rowData.size());
                tableDataVector.add(rowData);
            } else {
                tableDataVector.add(rowData);
            }
            firstRow = false;
            numRows++;
        }
        maxCols -= emptyCols.size();
        if (!doesFirstRowHaveHeaders) {
            headerVector = createDummyHeadersAsVector(maxCols);
            headers = new String[maxCols];
        }
        for (int i = 0; i < headerVector.size(); i++) {
            headers[i] = headerVector.elementAt(i);
        }
        printArray(headers);

        String[][] tableData = new String[tableDataVector.size()][maxCols];
        for (int i = 0; i < tableDataVector.size(); i++) {
            Vector<String> v = tableDataVector.get(i);
            for (int j = 0; j < v.size(); j++) {
                tableData[i][j] = v.get(j).toString();
            }

        }
        if (checkForErrors(headers, tableData)) {
            errorPanel.showDataImportStatusPanel(true);
        } else {
            errorPanel.showDataImportStatusPanel(false);
        }

        if ((doesFirstRowHaveHeaders ? numRows - 1 : numRows) > WorkbenchTask.MAX_ROWS) {
            hasTooManyRows = true;
            showTooManyRowsErrorDialog();
        } else {
            hasTooManyRows = false;
        }
        log.debug(headers);
        log.debug(tableData);
        model = new PreviewTableModel(headers, tableData);
        JTable result = null;
        if (table == null) {
            result = new JTable();
            result.setColumnSelectionAllowed(false);
            result.setRowSelectionAllowed(false);
            result.setCellSelectionEnabled(false);
            result.getTableHeader().setReorderingAllowed(false);
            result.setPreferredScrollableViewportSize(new Dimension(500, 100));
            result.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        } else {
            result = table;
        }
        result.setModel(model);
        result.setDefaultRenderer(String.class, new BiColorTableCellRenderer(false));
        model.fireTableDataChanged();
        model.fireTableStructureChanged();
        return result;
    } catch (Exception ex) {
        UIRegistry.displayErrorDlgLocalized(UIRegistry.getResourceString("WB_ERROR_READING_IMPORT_FILE"));
        if (table != null) {
            String[] columnNames = {};
            String[][] blankData = { {} };
            model = new PreviewTableModel(columnNames, blankData);
            table.setModel(model);
            table.setColumnSelectionAllowed(false);
            table.setRowSelectionAllowed(false);
            table.setCellSelectionEnabled(false);
            table.getTableHeader().setReorderingAllowed(false);
            table.setPreferredScrollableViewportSize(new Dimension(500, 100));
            table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
            table.setDefaultRenderer(String.class, new BiColorTableCellRenderer(false));
            model.fireTableDataChanged();
            model.fireTableStructureChanged();
            return table;
        }
        //log.error("Error attempting to parse input xls file:" + ex);
        //ex.printStackTrace();
    }

    return null;
}

From source file:edu.ku.brc.specify.tasks.subpane.wb.XLSImport.java

License:Open Source License

public DataImportIFace.Status getData(final Workbench workbench) {
    if (config.getStatus() == ConfigureExternalDataIFace.Status.Valid) {
        DateWrapper scrDateFormat = AppPrefsCache.getDateWrapper("ui", "formatting", "scrdateformat");
        try {//from w w w.j av a 2  s.  co  m
            InputStream input = new FileInputStream(config.getFile());
            POIFSFileSystem fs = new POIFSFileSystem(input);
            HSSFWorkbook workBook = new HSSFWorkbook(fs);
            HSSFSheet sheet = workBook.getSheetAt(0);
            int numRows = 0;

            // Calculate the number of rows and columns

            Set<WorkbenchTemplateMappingItem> wbtmiSet = workbench.getWorkbenchTemplate()
                    .getWorkbenchTemplateMappingItems();
            Vector<WorkbenchTemplateMappingItem> wbtmiList = new Vector<WorkbenchTemplateMappingItem>();
            NumberFormat nf = NumberFormat.getInstance();
            nf.setMinimumFractionDigits(0);
            nf.setMaximumFractionDigits(20);
            nf.setGroupingUsed(false); //gets rid of commas
            NumberFormat nfGeoCoord = NumberFormat.getInstance();
            nfGeoCoord.setMinimumFractionDigits(0);
            nfGeoCoord.setMaximumFractionDigits(
                    LatLonConverter.DECIMAL_SIZES[LatLonConverter.FORMAT.DDDDDD.ordinal()]);
            nfGeoCoord.setGroupingUsed(false); //gets rid of commas
            char decSep = new DecimalFormatSymbols().getDecimalSeparator();
            wbtmiList.addAll(wbtmiSet);

            Collections.sort(wbtmiList);

            this.truncations.clear();
            Vector<HSSFHyperlink> activeHyperlinks = new Vector<HSSFHyperlink>();

            // Iterate over each row in the sheet
            Iterator<?> rows = sheet.rowIterator();
            while (rows.hasNext()) {
                HSSFRow row = (HSSFRow) rows.next();
                if (numRows == 0 && config.getFirstRowHasHeaders()) {
                    numRows++;
                    getSystemCols(row);
                    continue;
                }

                WorkbenchRow wbRow = workbench.addRow();

                for (WorkbenchTemplateMappingItem wbtmi : wbtmiList) {
                    int cellNum = wbtmi.getOrigImportColumnIndex().intValue();
                    if (cellNum == -1) {
                        if (wbtmi.getViewOrder() != null) {
                            cellNum = wbtmi.getViewOrder().intValue();
                            if (cellNum == -1) {
                                continue;
                            }
                        }
                    }
                    HSSFCell cell = row.getCell(cellNum);
                    if (cell == null) {
                        continue;
                    }
                    int type = cell.getCellType();
                    if (type == HSSFCell.CELL_TYPE_FORMULA) {
                        type = cell.getCachedFormulaResultType();
                    }
                    String value = "";
                    boolean skip = false;

                    switch (type) {
                    case HSSFCell.CELL_TYPE_NUMERIC: {
                        if (HSSFDateUtil.isCellDateFormatted(cell)) {
                            //even if WorkbenchTask.getDataType(wbtmi) is not Calendar or Date. Hmmmm.
                            value = scrDateFormat.getSimpleDateFormat().format(cell.getDateCellValue());
                        } else {
                            Class<?> classObj = WorkbenchTask.getDataType(wbtmi);
                            if (classObj.equals(Integer.class)) {
                                double numeric = cell.getNumericCellValue();
                                value = Integer.toString((int) numeric);

                            } else if (classObj.equals(Calendar.class) || classObj.equals(Date.class)) {
                                Date d = cell.getDateCellValue();
                                if (d != null) {
                                    value = scrDateFormat.getSimpleDateFormat().format(cell.getDateCellValue());
                                } else {
                                    value = null;
                                }
                            } else {
                                double numeric = cell.getNumericCellValue();
                                value = nf.format(numeric);
                                if (isGeoCoordinate(wbtmi)) {
                                    int sepInx = value.indexOf(decSep);
                                    if (sepInx > -1 && value.substring(sepInx).length() > nfGeoCoord
                                            .getMaximumFractionDigits()) {
                                        String value2 = nfGeoCoord.format(numeric);
                                        int maxlen = wbtmi.getFieldName().startsWith("latitude")
                                                ? nfGeoCoord.getMaximumFractionDigits() + 3
                                                : nfGeoCoord.getMaximumFractionDigits() + 4;
                                        if (numeric < 0) {
                                            maxlen++;
                                        }
                                        //System.out.println(value + " " + trackTrunc(value, numRows, wbtmi.getViewOrder(), wbtmi.getCaption(), 
                                        //      maxlen) + " " + value2);
                                        value = value2;
                                    }
                                }
                            }
                        }
                        break;
                    }

                    case HSSFCell.CELL_TYPE_STRING:
                        HSSFHyperlink hl = checkHyperlinks(cell, activeHyperlinks);
                        if (hl == null /*|| (hl != null && hl.getType() == HSSFHyperlink.LINK_EMAIL)*/) {
                            value = cell.getRichStringCellValue().getString();
                        } else {
                            //value = hl.getAddress();
                            value = hl.getLabel();
                        }
                        break;

                    case HSSFCell.CELL_TYPE_BLANK:
                        value = "";
                        type = HSSFCell.CELL_TYPE_STRING;
                        break;

                    case HSSFCell.CELL_TYPE_BOOLEAN:
                        boolean bool = cell.getBooleanCellValue();
                        value = Boolean.toString(bool);
                        break;

                    default:
                        skip = true;
                        break;
                    }

                    if (!skip && value != null && !value.trim().equals("")) {
                        wbRow.setData(truncateIfNecessary(value, numRows, wbtmi), wbtmi.getViewOrder(), true);
                    }
                }
                addImageInfo(row, wbRow);
                addGeoInfo(row, wbRow);
                numRows++;
            }
            if (activeHyperlinks.size() > 0) {
                log.warn("Hyperlinks vector not empty after import. Overlapping hyperlink ranges?");
            }
            return status = this.truncations.size() == 0 && this.messages.size() == 0
                    ? DataImportIFace.Status.Valid
                    : DataImportIFace.Status.Modified;
        } catch (Exception ex) {
            edu.ku.brc.af.core.UsageTracker.incrHandledUsageCount();
            edu.ku.brc.exceptions.ExceptionTracker.getInstance().capture(XLSImport.class, ex);
            log.error(ex);
        }
    }
    return status = DataImportIFace.Status.Error;
}

From source file:edu.ku.brc.specify.utilapps.BuildSampleDatabase.java

License:Open Source License

/**
 * @param cell//from   ww w  . ja  v a2s.  c om
 * @return
 */
public String getXLSCellValueAsStr(final HSSFCell cell) {
    String value = null;
    // if cell is blank, set value to ""
    if (cell == null) {
        value = "";
    } else {
        switch (cell.getCellType()) {
        case HSSFCell.CELL_TYPE_NUMERIC:
            // The best I can do at this point in the app is to guess if a
            // cell is a date.
            // Handle dates carefully while using HSSF. Excel stores all
            // dates as numbers, internally.
            // The only way to distinguish a date is by the formatting of
            // the cell. (If you
            // have ever formatted a cell containing a date in Excel, you
            // will know what I mean.)
            // Therefore, for a cell containing a date, cell.getCellType()
            // will return
            // HSSFCell.CELL_TYPE_NUMERIC. However, you can use a utility
            // function,
            // HSSFDateUtil.isCellDateFormatted(cell), to check if the cell
            // can be a date.
            // This function checks the format against a few internal
            // formats to decide the issue,
            // but by its very nature it is prone to false negatives.
            if (HSSFDateUtil.isCellDateFormatted(cell)) {
                DateWrapper scrDateFormat = AppPrefsCache.getDateWrapper("ui", "formatting", "scrdateformat");
                SimpleDateFormat simpDateFmt = scrDateFormat != null
                        && scrDateFormat.getSimpleDateFormat() != null ? scrDateFormat.getSimpleDateFormat()
                                : sdf;
                value = simpDateFmt.format(cell.getDateCellValue());
            } else {
                double numeric = cell.getNumericCellValue();
                value = numFmt.format(numeric);
            }
            break;

        case HSSFCell.CELL_TYPE_STRING:
            value = cell.getRichStringCellValue().getString();
            break;

        case HSSFCell.CELL_TYPE_BLANK:
            value = "";
            break;

        case HSSFCell.CELL_TYPE_BOOLEAN:
            value = Boolean.toString(cell.getBooleanCellValue());
            break;

        default:
            value = "";
            log.error("unsuported cell type[" + cell.getCellType() + "]");
            break;
        }
    }
    return value;
}

From source file:edu.wustl.catissuecore.webservice.util.ExcelFileReader.java

License:BSD License

/**
 * Method to read content of one row of Excel sheet
 * @param row HSSFRow row whose content to be read
 * @return/*from   w ww  .j  ava  2s  .  com*/
 */
private String[] getRowContent(HSSFRow row) {
    HSSFCell cell = null;
    int noOfColumn = row.getPhysicalNumberOfCells();
    String[] rowContent = new String[noOfColumn];
    for (short i = 0; i < noOfColumn; i++) {
        try {
            cell = row.getCell(i);
            if (cell == null)
                rowContent[i] = "";
            else {
                if (columnDataType.length > i && columnDataType[i] != null) {
                    switch (columnDataType[i]) {
                    case 0: {
                        HSSFRichTextString strCell = cell.getRichStringCellValue();
                        rowContent[i] = strCell.toString();
                        break;
                    }
                    case 1: {
                        rowContent[i] = String.valueOf(cell.getNumericCellValue());
                        break;
                    }
                    case 2: {
                        Date date = cell.getDateCellValue();
                        rowContent[i] = parseDateToString(date, DATE_PATTERN_MM_DD_YYYY);
                        break;
                    }
                    }
                } else {
                    HSSFRichTextString strCell = cell.getRichStringCellValue();
                    rowContent[i] = strCell.toString();
                }
            }
        } catch (Exception e) {
            System.out.println("columnDataType[" + i + "]" + columnDataType[i]);
        }
    }
    return rowContent;
}

From source file:endrov.customData.ImportTable.java

License:BSD License

/**
 * Import Excel file/*from   w  w w.ja v a  2 s  .  c  om*/
 */
public void importExcel(String filename) throws Exception {
    rows.clear();
    POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(filename));
    HSSFWorkbook wb = new HSSFWorkbook(fs);
    //Take first sheet
    HSSFSheet sheet = wb.getSheetAt(0);

    for (int rowi = 0; sheet.getRow(rowi) != null; rowi++) {
        HSSFRow row = sheet.getRow(rowi);
        List<String> a = new LinkedList<String>();

        for (int coli = 0; row.getCell((short) coli) != null; coli++) {
            HSSFCell c = row.getCell((short) coli);
            if (c.getCellType() == HSSFCell.CELL_TYPE_STRING)
                a.add(c.getRichStringCellValue().getString());
            else if (c.getCellType() == HSSFCell.CELL_TYPE_NUMERIC)
                a.add("" + c.getNumericCellValue());
        }
        rows.add(a);
    }
}

From source file:endrov.util.io.EvSpreadsheetImporter.java

License:BSD License

/**
 * Import Excel file//from  w  w w  .j ava2s.  c om
 */
public void importExcel(String filename) throws Exception {
    rows.clear();
    POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(filename));
    HSSFWorkbook wb = new HSSFWorkbook(fs);
    //Take first sheet
    HSSFSheet sheet = wb.getSheetAt(0);

    int lastCapacity = 0;
    for (int rowi = 0; sheet.getRow(rowi) != null; rowi++) {
        HSSFRow row = sheet.getRow(rowi);
        ArrayList<String> a = new ArrayList<String>(lastCapacity);

        for (int coli = 0; row.getCell((short) coli) != null; coli++) {
            HSSFCell c = row.getCell((short) coli);
            if (c.getCellType() == HSSFCell.CELL_TYPE_STRING)
                a.add(c.getRichStringCellValue().getString());
            else if (c.getCellType() == HSSFCell.CELL_TYPE_NUMERIC)
                a.add("" + c.getNumericCellValue());
        }
        rows.add(a);
        lastCapacity = a.size();
    }
}

From source file:es.tena.foundation.util.POIUtil.java

public static String getCelda(HSSFCell cellSugg) {
    String suggestion = "";
    if (cellSugg != null) {
        if (cellSugg.getCellType() == HSSFCell.CELL_TYPE_STRING) {
            suggestion = StringUtil.trim(StringEscapeUtils.escapeSql(cellSugg.getStringCellValue()));
        } else if (cellSugg.getCellType() == HSSFCell.CELL_TYPE_NUMERIC) {
            BigDecimal big = new BigDecimal(cellSugg.getNumericCellValue());
            suggestion = big.toString();
        } // no hace falta else
        else {//from   w  w w .  j  a  va 2  s .  c o  m
            suggestion = StringUtil.trim(StringEscapeUtils.escapeSql(cellSugg.getStringCellValue()));
        }
        suggestion = SQLUtil.replace(suggestion);
    }
    return suggestion;
}