`

java读取Excel版本兼容的解决方案

 
阅读更多

项目开发中遇到了解析Excel的问题，顺利完成了测试发现office2003跟office2007有报错，网上找了一些资料，

 

package com.gts.admin.upload.services;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class ExcelOperate
{

    public static void main(String[] args) throws Exception
    {

        File file = new File("C:\\wwww.xls");

//         File file = new File("C:\\test.xls");
        String[][] result = getData(file,1);

        int rowLength = result.length;

        for (int i = 0; i < rowLength; i++)
        {

            for (int j = 0; j < result[i].length; j++)
            {

                System.out.print(result[i][j] + "\t\t");

            }

            System.out.println();

        }

    }

    /**
     *
     * 读取Excel的内容，第一维数组存储的是一行中格列的值，二维数组存储的是多少个行
     *
     * @param file
     *            读取数据的源Excel
     *
     * @param ignoreRows
     *            读取数据忽略的行数，比喻行头不需要读入 忽略的行数为1
     *
     * @return 读出的Excel中数据的内容
     *
     * @throws FileNotFoundException
     *
     * @throws IOException
     *
     */
    public static String[][] getData(File file, int ignoreRows)

    throws FileNotFoundException, IOException
    {
        int rowSize = 0;
        // 打开HSSFWorkbook
        List<String[]> result = new ArrayList<String[]>();
//        String outputFile = output2File(in);
        Workbook wb = null;
        InputStream in = null;
        try
        {
            in = new FileInputStream(file);
            wb = new XSSFWorkbook(in);
            result = getXSSFResult(wb, ignoreRows);
        } catch (Exception ex)
        {
            in = new FileInputStream(file);
            wb = new HSSFWorkbook(in);
            result = getHSSFResult(wb, ignoreRows);
        }

 

//哈哈，原来已经提供了一个很优雅的方法

Workbook wb = WorkbookFactory.create(in);

try
        {
            System.out.println(wb instanceof XSSFWorkbook);
            if(wb instanceof XSSFWorkbook)
            {
//                wb = new XSSFWorkbook(in);
                result = getXSSFResult(wb, ignoreRows);
            }
            else if(wb instanceof HSSFWorkbook)
            {
               
//                wb = new HSSFWorkbook(in);
                result = getHSSFResult(wb, ignoreRows);
            }

        in.close();

        String[][] returnArray = new String[result.size()][rowSize];

        for (int i = 0; i < returnArray.length; i++)
        {

            returnArray[i] = (String[]) result.get(i);

        }

        return returnArray;

    }

    private static List<String[]> getXSSFResult(Workbook wb, int ignoreRows)
    {
        List<String[]> result = new ArrayList<String[]>();
        XSSFCell cell = null;
        int rowSize = 0;
        for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets(); sheetIndex++)
        {
            XSSFSheet st = (XSSFSheet) wb.getSheetAt(sheetIndex);
            // 第一行为标题，不取
            for (int rowIndex = ignoreRows; rowIndex <= st.getLastRowNum(); rowIndex++)
            {
                XSSFRow row = st.getRow(rowIndex);
                if (row == null)
                {
                    continue;
                }
                int tempRowSize = row.getLastCellNum() + 1;
                if (tempRowSize > rowSize)
                {
                    rowSize = tempRowSize;
                }
                String[] values = new String[rowSize];
                Arrays.fill(values, "");
                boolean hasValue = false;
                for (short columnIndex = 0; columnIndex <= row.getLastCellNum(); columnIndex++)
                {
                    String value = "";
                    cell = row.getCell(columnIndex);
                    if (cell != null)
                    {

                        // 注意：一定要设成这个，否则可能会出现乱码

                        // cell.setEncoding(HSSFCell.ENCODING_UTF_16);
                        switch (cell.getCellType())
                        {
                        case XSSFCell.CELL_TYPE_STRING:
                            value = cell.getStringCellValue();
                            break;
                       
                        case XSSFCell.CELL_TYPE_FORMULA:
                            // 导入时如果为公式生成的数据则无值
                            if (!cell.getStringCellValue().equals(""))
                            {
                                value = cell.getStringCellValue();
                            } else
                            {
                                value = cell.getNumericCellValue() + "";
                            }
                            break;
                        case XSSFCell.CELL_TYPE_NUMERIC:
                            if (DateUtil.isCellDateFormatted(cell))
                            {
                                Date date = cell.getDateCellValue();
                                if (date != null)
                                {
                                    value = new SimpleDateFormat("yyyy/MM/dd")
                                            .format(date);
                                } else
                                {
                                    value = "";
                                }
                            } else
                            {
                                value = new DecimalFormat("0").format(cell
                                        .getNumericCellValue());
                            }
                            break;
                        case XSSFCell.CELL_TYPE_BLANK:
                            break;
                        case XSSFCell.CELL_TYPE_ERROR:
                            value = "";
                            break;
                        case XSSFCell.CELL_TYPE_BOOLEAN:
                            value = (cell.getBooleanCellValue() == true ? "Y"
                                    : "N");
                            break;
                        default:
                            value = "";
                        }
                    }
                    if (columnIndex == 0 && value.trim().equals(""))
                    {
                        break;
                    }
                    values[columnIndex] = rightTrim(value);
                    hasValue = true;
                }
                if (hasValue)
                {
                    result.add(values);
                }
            }
        }
        return result;
    }

    private static List<String[]> getHSSFResult(Workbook wb, int ignoreRows)
    {
        List<String[]> result = new ArrayList<String[]>();
        HSSFCell cell = null;
        int rowSize = 0;
        for (int sheetIndex = 0; sheetIndex < wb.getNumberOfSheets(); sheetIndex++)
        {
            HSSFSheet st = (HSSFSheet) wb.getSheetAt(sheetIndex);
            // 第一行为标题，不取
            for (int rowIndex = ignoreRows; rowIndex <= st.getLastRowNum(); rowIndex++)
            {
                HSSFRow row = st.getRow(rowIndex);
                if (row == null)
                {
                    continue;
                }
                int tempRowSize = row.getLastCellNum() + 1;
                if (tempRowSize > rowSize)
                {
                    rowSize = tempRowSize;
                }
                String[] values = new String[rowSize];
                Arrays.fill(values, "");
                boolean hasValue = false;
                for (short columnIndex = 0; columnIndex <= row.getLastCellNum(); columnIndex++)
                {
                    String value = "";
                    cell = row.getCell(columnIndex);
                    if (cell != null)
                    {

                        // 注意：一定要设成这个，否则可能会出现乱码

                        // cell.setEncoding(HSSFCell.ENCODING_UTF_16);
                        switch (cell.getCellType())
                        {
                        case HSSFCell.CELL_TYPE_STRING:
                            value = cell.getStringCellValue();
                            break;
                        case HSSFCell.CELL_TYPE_NUMERIC:
                            if (HSSFDateUtil.isCellDateFormatted(cell))
                            {
                                Date date = cell.getDateCellValue();
                                if (date != null)
                                {
                                    value = new SimpleDateFormat("yyyy-MM-dd")
                                            .format(date);
                                } else
                                {
                                    value = "";
                                }
                            } else
                            {
                                value = new DecimalFormat("0").format(cell
                                        .getNumericCellValue());
                            }
                            break;
                        case HSSFCell.CELL_TYPE_FORMULA:
                            // 导入时如果为公式生成的数据则无值
                            if (!cell.getStringCellValue().equals(""))
                            {
                                value = cell.getStringCellValue();
                            } else
                            {
                                value = cell.getNumericCellValue() + "";
                            }
                            break;
                        case HSSFCell.CELL_TYPE_BLANK:
                            break;
                        case HSSFCell.CELL_TYPE_ERROR:
                            value = "";
                            break;
                        case HSSFCell.CELL_TYPE_BOOLEAN:
                            value = (cell.getBooleanCellValue() == true ? "Y"
                                    : "N");
                            break;
                        default:
                            value = "";
                        }
                    }
                    if (columnIndex == 0 && value.trim().equals(""))
                    {
                        break;
                    }
                    values[columnIndex] = rightTrim(value);
                    hasValue = true;
                }
                if (hasValue)
                {
                    result.add(values);
                }
            }
        }
        return result;
    }
    private static final String TEMP_FILE_NAME = "temp";
//    private String output2File(InputStream streamIn) throws IOException
//    {
//        String dir = getServletPath()+TEMP_FILE_NAME;
//        // 上传的路径+文件名
//        File uploadFile = new File(dir);
//        if (!uploadFile.exists() || uploadFile == null)
//        { // 判断指定路径dir是否存在，不存在则创建路径
//            uploadFile.mkdirs();
//        }
//        // OutputStream用于向某个目标写入字节的抽象类，这个地方写入目标是path，通过输出流FileOutputStream去写
//        String path = dir+"\\temp.xls";
//        OutputStream streamOut = new FileOutputStream(path);
//        int bytesRead = 0;
//        byte[] buffer = new byte[8192];
//        // 将数据读入byte数组的一部分，其中读入字节数的最大值是8192，读入的字节将存储到，buffer[0]到buffer[0+8190-1]的部分中
//        // streamIn.read方法返回的是实际读取字节数目.如果读到末尾则返回-1.如果bytesRead返回为0则表示没有读取任何字节。
//        while ((bytesRead = streamIn.read(buffer, 0, 8192)) != -1)
//        {
//            // 写入buffer数组的一部分，从buf[0]开始写入并写入bytesRead个字节，这个write方法将发生阻塞直至字节写入完成。
//            streamOut.write(buffer, 0, bytesRead);
//        }
//        // 关闭输出输入流,销毁File流。
//        streamOut.close();
//        streamIn.close();
//        return path;
//    }
//    private String getServletPath()
//     {
//        String url =  this.getClass().getResource("/").getPath();
//         return url;
//     }
   

    /**
     *
     * 去掉字符串右边的空格
     *
     * @param str
     *            要处理的字符串
     *
     * @return 处理后的字符串
     *
     */

    public static String rightTrim(String str)
    {

        if (str == null)
        {

            return "";

        }

        int length = str.length();

        for (int i = length - 1; i >= 0; i--)
        {

            if (str.charAt(i) != 0x20)
            {

                break;

            }

            length--;

        }

        return str.substring(0, length);

    }

}

分享到：
| JDBC常用连接写法（包括MySQL、Oracle、Sy ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java中Excel转图片工具包（纯java）

    "Java中Excel转图片工具包（纯java）"就是这样一个解决方案，它实现了将Excel文件通过PDF中间格式转化为图片的功能。 首先，让我们了解一下这个工具包的工作原理。Excel文件本身并不直接支持转换为图片格式，但可以...

    JdbcExcel纯Java连接Excel

    2. `faq.html`：常见问题解答，可能会涵盖在Java中操作Excel时遇到的问题和解决方案，比如内存管理、性能优化、数据类型转换等。 3. `sqlsyntax.html`：可能涉及如何使用Java和Apache POI来执行类似SQL的操作，如...

    Java实现Excel导入导出操作详解.pptx.pptx

    通过Apache POI的API，开发者可以轻松读取Excel文件，将数据转化为Java对象，同时也可以添加、修改和删除单元格数据，实现对Excel文件的完全控制。JXL库则是一个较简单的选项，适合小型项目和简单的Excel操作。另外...

    java读取Excel数据.pdf

    Java Excel API提供了一个方便的解决方案。 在提供的部分代码中，可以看到一个名为`ExcelImportOracle`的类，这个类用于从Excel文件读取数据并将其导入到Oracle数据库。下面我们将深入探讨如何使用Java Excel API来...

    ExcelUtil借助反射和POI对Excel读取,省略了以往读取Excel的繁琐步骤

    兼容03/07版Excel的功能意味着ExcelUtil支持两种主要的Excel文件格式：.xls（97-2003版本）和.xlsx（2007及以上版本）。这得益于Apache POI库的广泛支持。 总的来说，ExcelUtil通过结合反射和Apache POI库，极大地...

    poi读取excel2007和2003兼容工具例子

    Apache POI是一个流行的Java库，用于处理Microsoft Office格式的文件，包括Excel。在这个"poi读取excel2007和2003...在实际开发中，这样的工具能够帮助我们构建跨版本兼容的解决方案，提升代码的可复用性和可维护性。

    java操作excel，读取数据

    然而，JXL存在一定的局限性和限制，如不支持`.xlsx`格式的文件，且对某些版本的Excel文件可能存在兼容性问题。例如，文中提到的对Excel XP文件中的“数据有效性”格式的支持不足。尽管如此，在处理简单的`.xls`文件...

    POI导入excel大数据处理，支持excel2003,2007

    在Java开发中，当需要处理大量的Excel数据时，POI库提供了高效且灵活的解决方案。标题提到的“POI导入excel大数据处理”是指利用Apache POI进行大量Excel数据的导入操作，同时它兼容Excel 2003（.xls格式）和2007...

    Excel2html－纯java实现excel转html

    "Excel2html"项目就是专为此目的设计的，它提供了一个纯Java实现的解决方案，使得开发者能够方便地将Excel文件转换成HTML文件，保留原有的格式和样式。 首先，我们要理解Excel文件和HTML文件的本质区别。Excel是...

    poi读取excel文件实例（兼容excel2007）

    由于JXL库不支持XLSX格式，所以Apache POI成为了首选解决方案。 在“poi读取excel文件实例”中，我们将讨论如何使用Apache POI API来读取和操作Excel 2007文件。以下是一些关键知识点： 1. **创建工作簿对象**：...

    java导入Excel

    总之，Java结合Apache POI库提供了一套强大的解决方案，用于在后台处理Excel数据的导入和导出。通过熟练掌握这些技术，开发者可以轻松地在Java应用中实现与Excel文件的交互，满足各种数据处理需求。

    java文档excel、word、pdf、ppt转图片

    在Java编程环境中，将文档（如Excel、Word、PDF、PPT）转换为图片是一种常见的需求，这在处理大量文档预览、数据可视化或者移动设备兼容性问题时尤其有用。以下是一些关于如何使用Java实现这种转换的关键知识点： 1...

    java 导入导出excel

    ### Java导入导出Excel知识点详解 #### 一、Jxl库概述 Jxl是一个用于Java应用程序处理Microsoft Excel文件的强大库...然而，在处理复杂或大规模数据时，可能需要评估其性能表现，并考虑是否有其他更适合的解决方案。

    jcom 实现 java 写 Excel实例（包含jar包_dll文件_api）资料全

    这时，`jcom`库提供了一个解决方案，允许Java程序与Microsoft Office应用程序交互，包括创建、读取和修改Excel工作簿。本教程将详细介绍如何使用`jcom`来实现Java写Excel的实例，并涵盖关键知识点。 首先，`jcom`库...

    java excel转pdf

    Aspose.Cells 8.5.2版本提供了一种高效且无需额外插件的解决方案，可以帮助开发者轻松实现高质量的Excel文件转换，以满足各种业务需求。在实际开发中，确保遵循开源软件的使用条款，以避免潜在的法律问题。

    安卓读写Excel（基于xxl-excel）

    在这个场景中，我们关注的是一个名为"xxl-excel"的库，它是一个专门用于Java和Android平台读写Excel的库。通过这个库，我们可以轻松地在Android应用中创建、读取和修改Excel文件，无需依赖Microsoft Office或Apache ...

    读写Excel所用到的jar包

    5. JODA：JODA（Java Object Data Access）是一个用于读写Excel文件的库，它提供了一个直观的API来操作Excel数据，支持老版本的Excel格式和新版本的OOXML格式。 6. EPPlus：EPPlus是一个.NET框架的库，但它有一个...

    sql导出不了EXCEL不了解决方案

    ### SQL导出Excel问题解决方案 #### 一、问题概述 在使用SQL进行数据处理时，经常需要将查询结果导出到Excel文件中以便进一步分析或分享。然而，在实际操作过程中，有时会遇到无法将SQL查询结果导出为Excel的情况...

    java读写csv文件，中文乱码问题

    2. **Java读取CSV文件**： - 使用`BufferedReader`和`InputStreamReader`组合，可以指定字符编码读取文件。例如： ```java FileInputStream fis = new FileInputStream("path_to_file.csv"); InputStreamReader ...

    java导入导出excel操作

    Java作为一种广泛使用的编程语言，在进行Excel文件的读写操作时，提供了多种解决方案。本文将详细介绍如何使用`jxl`库来实现Java中的Excel导入导出功能。 #### 二、`jxl`库简介 `jxl`是Java Excel API的简称，它是...

Magicbox
Global site tag (gtag.js) - Google Analytics