`

jxl poi 对xls 的读写,实例较量

 
阅读更多

          最近公司要扫描全部xls 文件，xls 是一个单，并且将xls的单数据 全部写入一个xls 中! 心里一热，采用jxl 和poi 两种方式进行读取，其实就是解决xls 2003 和xls 2007 版本问题，再次晒出代码，希望与更多人交流，QQ:962589149

 


public class XlsManger {
  /**
   * @author 樱花无罪
   * @version 2012-09-18
   * @see xls 操作类
   */
 public XlsManger(){
  this.allData=new ArrayList();
 }
 private static List allData=new ArrayList();//全家记录条数
 private static boolean  isin=true;//数量是否in
 private static boolean  isin2=true;
 public static void main(String args[]) throws Exception
 {
   
  allData=new ArrayList();
  XlsManger xls=new XlsManger();
  //xls.read2007XSSF(new File("C:\\test"),"16888.xlsx");
  //xls.read2007XSSF(new File("C:\\test"),"16888.xlsx");
     //xls.read2007HSSF(new File("C:\\test"),"Book1.xls");
  //System.out.println(xls.getTitle(new File("C:\\test\\configtxt.txt")));
  
  //xls.readXlsJXL(File dir,String filename) throws Exception
  
  String title=xls.getTitle(new File("C:\\test\\configtxt.txt"));//所有列标题
  System.out.println(title);
  String[] titledata=title.split("#");
  String outpath="C:\\test\\workbook.xls";
  List alldata=xls.readXls(new File("C:\\test"),0,titledata[2].split(","));//所有数据
  System.out.println(alldata.size()+"==========所有记录条数===========");
  if(xls.readIntoXls(titledata[1].split(","), alldata, outpath))
  {
   System.out.println("合并成功");
  }else
  {
   System.out.println("合并失败");
  }
  
 }
 public boolean beginXls()
 {
  try
  {
   XlsManger xls=new XlsManger();
   String title=xls.getTitle(new File("C:\\test\\configtxt.txt"));//所有列标题
   System.out.println(title);
   String[] titledata=title.split("#");
   String outpath="C:\\test\\workbook.xls";
   List alldata=xls.readXls(new File("C:\\test"),0,titledata[2].split(","));//所有数据
   System.out.println(alldata.size()+"======所有记录条数===========");
   if(xls.readIntoXls(titledata[1].split(","), alldata, outpath))
   {
    return true;
   }else
   {
    return false;
   }
   
  }catch(Exception ex)
  {
   ex.printStackTrace();
  }
  return false;
 }
 //初始化表头
 public String getTitle(File file)
 {
  String title="111";
  BufferedReader reader = null;
  if(file.exists())
  {
   try {
             System.out.println("以行为单位读取文件内容，一次读一整行：");
             reader = new BufferedReader(new FileReader(file));
             String tempString = null;
             int line = 1;
             // 一次读入一行，直到读入null为文件结束
             while ((tempString = reader.readLine()) != null) {
              title=title+"#"+tempString;
                 line++;
             }
             reader.close();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (reader != null) {
                 try {
                     reader.close();
                 } catch (IOException e1) {
                 }
             }
         }
  }else
  {
   title="表头配置无法获取";
  }
  return title;
 }
 //初始2007阅读器
 public static List read2007XSSF(File dir,String filename) throws Exception
 {
  List datalist=new ArrayList();
  if(dir.exists())//文件存在
  {
   XSSFWorkbook xwb = null; 
   try { 
                xwb = new XSSFWorkbook(dir.getPath() +"\\" + filename);
                XSSFFormulaEvaluator evaluator  = new XSSFFormulaEvaluator(xwb);
                //获取xwb 文件工作表个数
                int sheetcount=xwb.getNumberOfSheets();
                //System.out.println("一共有"+sheetcount+"表");
                // 读取第一章表格内容   
                StringBuffer rowStr=null;
                for(int s=0;s<sheetcount;s++)
                {
                 XSSFSheet sheet = xwb.getSheetAt(s);
                 //获取行数
                 XSSFRow row=null;
                 XSSFCell cell=null;
                 rowStr=new StringBuffer();//行容器
              rowStr.append("文件名,");
              rowStr.append(dir.getPath() +"\\" + filename+",");
                  for (int i = sheet.getFirstRowNum()+1; i < sheet.getPhysicalNumberOfRows(); i++) {    
                      row = sheet.getRow(i);
                     
                      if(row!=null){//行不为空
                      for (int j = row.getFirstCellNum(); j < row.getPhysicalNumberOfCells(); j++) {
                        cell=row.getCell(j);
                        CellValue cellValue = evaluator.evaluate(cell);
                        String restr=formart(cell,cellValue);
                     if(restr!=null)
                     {
                      if(restr.equals("排版尺寸")&&rowStr.indexOf("排版尺寸")!=-1)
                      {
                      
                      }else if(restr.equals("数量"))
                      {
                       if(isin)
                       {
                        rowStr.append(restr+",");
                        isin=false;
                       }
                      } else if(restr.equals("裁"))
                      {
                       if(isin2)
                       {
                        rowStr.append(restr+",");
                        isin2=false;
                       }
                      }else
                     
                      {
                        //System.out.println(formartHSSF(cell,cellValue)+":"+cellValue.getNumberValue());
                                    rowStr.append(restr+",");
                      }
                     } 
                       }
                      }
                  }
                  // 每个表为单位
                  //System.out.println("第"+s+"表"+rowStr);
                  if(rowStr!=null&&rowStr.toString().trim().length()!=0)
                  {
                   if(rowStr.toString().toLowerCase().indexOf("ltd")!=-1)
                   {
                   
                   }else
                   {
                   // System.out.println(rowStr+"888888888888888888888888");
                    datalist.add(rowStr);//将文件的所有记录保存到list
                   }
                  }
                 
                 
                 
                }
            } catch (IOException e) {
                e.printStackTrace(); 
            }     
  }
  //System.out.println("文件"+dir+"获取的记录条数"+datalist.size());
  return datalist;
 }
 //初始2007列格式问题
 public  static String formart(XSSFCell cell,CellValue cellValue)
 {
  switch (cell.getCellType()) {  
        case XSSFCell.CELL_TYPE_NUMERIC: // 数字  
            return String.valueOf(cell.getNumericCellValue()); 
        case XSSFCell.CELL_TYPE_STRING: // 字符串  
            return cell.getStringCellValue() ;
        case XSSFCell.CELL_TYPE_BOOLEAN: // Boolean  
            return String.valueOf(cell.getBooleanCellValue());
        case XSSFCell.CELL_TYPE_FORMULA: // 公式   
           return String.valueOf(cellValue.getNumberValue());
  case XSSFCell.CELL_TYPE_BLANK: // 空值   
            break;  
        case XSSFCell.CELL_TYPE_ERROR: // 故障   
            break;  
        default: 
            return cell.getStringCellValue();  
        }  
  return null;
 }
 //初始2007列格式问题
 public  static String formartHSSF(HSSFCell cell,CellValue cellValue)
 {
  switch (cell.getCellType()) {  
        case HSSFCell.CELL_TYPE_NUMERIC: // 数字  
            return String.valueOf(cell.getNumericCellValue()); 
        case HSSFCell.CELL_TYPE_STRING: // 字符串  
            return cell.getStringCellValue() ;
        case HSSFCell.CELL_TYPE_BOOLEAN: // Boolean  
            return String.valueOf(cell.getBooleanCellValue());
        case HSSFCell.CELL_TYPE_FORMULA: // 公式   
            return String.valueOf(cellValue.getNumberValue());
  case HSSFCell.CELL_TYPE_BLANK: // 空值   
            break;  
        case HSSFCell.CELL_TYPE_ERROR: // 故障   
            break;  
        default: 
            return cell.getStringCellValue();  
        }  
  return null;
 }
 //初始化2007 读写方式二
 public static List read2007HSSF(File dir,String filename) throws Exception
 {
  List<StringBuffer> datalist=new ArrayList();
  if(dir.exists())//文件存在
  {
   HSSFWorkbook xwb = null; 
   try { 
    
                xwb = new HSSFWorkbook(new FileInputStream(new File(dir.getPath() +"\\" + filename)));
                HSSFFormulaEvaluator evaluator  = new HSSFFormulaEvaluator(xwb);
                //获取xwb 文件工作表个数
                int sheetcount=xwb.getNumberOfSheets();
                //System.out.println("一共有"+sheetcount+"表");
                // 读取第一章表格内容   
                StringBuffer rowStr=null;
                for(int s=0;s<sheetcount;s++)
                {
                  rowStr=new StringBuffer();//行容器
                  rowStr.append("文件名,");
               rowStr.append(dir.getPath() +"\\" + filename+",");
                 HSSFSheet sheet = xwb.getSheetAt(s);
                 //获取行数
                 HSSFRow row=null;
                 HSSFCell cell=null;
                  isin=true;
                  isin2=true;
                  for (int i = sheet.getFirstRowNum()+1; i < sheet.getPhysicalNumberOfRows(); i++) {    
                      row = sheet.getRow(i);
                      if(row!=null){//行不为空
                      for (int j = row.getFirstCellNum(); j < row.getPhysicalNumberOfCells(); j++) {
                        cell=row.getCell(j);
                        if(cell!=null)
                        {
                         CellValue cellValue = evaluator.evaluate(cell);
                         String restr=formartHSSF(cell,cellValue);
                         if(restr!=null)
                         {
                          if(restr.equals("排版尺寸")&&rowStr.indexOf("排版尺寸")!=-1)
                          {
                          
                          }else if(restr.equals("数量"))
                          {
                           if(isin)
                           {
                            rowStr.append(restr+",");
                            isin=false;
                           }
                          } else if(restr.equals("裁"))
                          {
                           if(isin2)
                           {
                            rowStr.append(restr+",");
                            isin2=false;
                           }
                          }else
                         
                          {
                            //System.out.println(formartHSSF(cell,cellValue)+":"+cellValue.getNumberValue());
                                        rowStr.append(restr+",");
                          }
                         } 
                        }
                       }
                      }
                  }
                  // 每个表为单位
                  //System.out.println("第"+s+"表"+rowStr);
                  if(rowStr!=null&&rowStr.toString().trim().length()!=0)
                  {
                   if(rowStr.toString().toLowerCase().indexOf("ltd")!=-1)
                   {
                   
                   }else
                   {
                   
                    //System.out.println(rowStr);
                    datalist.add(rowStr);//将文件的所有记录保存到list
                   }
                  }
                }
            } catch (IOException e) {
                e.printStackTrace(); 
            }     
  }
  return datalist;
 }
 /**
  * 开始读取
  * @param di 文件目录
  * @param level 文件记录数
  * @return list
  * @throws Exception
  */
 public static boolean isExists(String filename,String[] exifile)
 {
  for(int i=0;i<exifile.length;i++)
  {
   if(filename.toLowerCase().indexOf(exifile[i])!=-1)
   {
    return true;
   }
  }
  return false;
 }
 public List readXls(File dir,int level,String[] exifile) throws Exception
 {
  
  File [] f = dir.listFiles();//获取目录下文件
  List DATxls=new ArrayList();
  for (int x = 0; x < f.length; x++)
     {
   System.out.println("扫描文件...."+dir.getPath()+"\\"+f[x].getName());
   try{
       if (f[x].isDirectory()){//如果是目录
        readXls(f[x], level,exifile);
       }else if(isExists(f[x].getName(),exifile))//含税G类文件
       {
       
       }
       else if(f[x].getName().toLowerCase().endsWith(".xlsx")){//2007 读取方式一
        DATxls=new ArrayList();
        DATxls=this.read2007XSSF(dir, f[x].getName());
        System.out.println("方式一记录数"+DATxls.size());
        for(int r=0;r<DATxls.size();r++)
        {
         allData.add(DATxls.get(r).toString());
        }
          }
       else if(f[x].getName().toLowerCase().endsWith(".xls")){//2007 读取方式二
        DATxls=new ArrayList();
        DATxls=this.read2007HSSF(dir, f[x].getName());
        System.out.println("方式二记录数"+DATxls.size());
        for(int r=0;r<DATxls.size();r++)
        {
         allData.add(DATxls.get(r).toString());
        }
          }
   }catch(Exception ex)
   {
   //如果出错,尝试jxl 读取方式
   // this.readXlsJXL(dir, f[x].getName());
   }
     
     
      level++;
     }
  //System.out.println("共读取"+level+"个文件"+"共"+allData.size()+"记录");
  return allData;
 }
 //初始jxl 方式读取
 public static List readXlsJXL(File dir,String filename) throws Exception
 {
  System.out.println("读取方式三"+dir.getPath()+"\\"+filename);
   File file=new File(dir.getPath()+"\\"+filename);
   List excelValueList = new ArrayList();  
   if (file.exists() && file.canRead() && (file.getName().toLowerCase().lastIndexOf(".xls") >= 1)) {
    Workbook workbook = null; 
    StringBuffer rowValue=null;
             try {  
                 workbook = Workbook.getWorkbook(file);  
                 Sheet sheet=null;
                 for(int s=0;s<workbook.getSheets().length;s++)
                 {
                  rowValue=new StringBuffer();
                  sheet= workbook.getSheet(s);  //表
                   int row = sheet.getRows();  
                      int col = sheet.getColumns();  
                      for (int r = 0; r < row; r++) {    
                          for (int c = 0; c < col; c++) {  
                           rowValue.append(sheet.getCell(c, r).getContents() != null ? sheet.getCell(c, r).getContents(): ""+",");  
                          }  
                           
                      }
                   excelValueList.add(rowValue);
                 }
             }catch(Exception ex)
             {
              ex.printStackTrace();
             }
            
   
   }
  return null;
 }
 //初始写入xls
 public boolean readIntoXls(String[] title,List datalist,String outPath)throws Exception
 {
  try{
    HSSFWorkbook wb = new HSSFWorkbook();
       HSSFSheet sheet = wb.createSheet("发料合并表");
       HSSFRow row = sheet.createRow(0);
       for(int i=0;i<title.length;i++)
       {
        row.createCell(i).setCellValue(title[i]);
       }
       for(int j=1;j<datalist.size()+1;j++)
       {
        //System.out.println(String.valueOf(datalist.get(j-1))+"*************");
        
        String[] data=String.valueOf(datalist.get(j-1)).split(",");
        row = sheet.createRow(j);
        //System.out.println(datalist.get(j-1));
        for(int i=0;i<title.length;i++)
        {
         for(int k=0;k<data.length;k++)
         {
          //System.out.println(data[k]);
          if(data[k].trim().equals(title[i].trim()))
          { 
           if(title[i].trim().equals("排版数量"))
           {
            if(data[k].equals("排版数量")&data[k+1].trim().equals("（1）"))
            {
             row.createCell(i).setCellValue(data[k+2]);
            }
           }else
           {
            if(data[k].trim().length()!=0)
            {
             row.createCell(i).setCellValue(data[k+1]);
            }
           }
           
          }else if(title[i].trim().equals("客户订单号"))
          {
           if(data[k].indexOf("客户订单号")!=-1)
           {
            row.createCell(i).setCellValue(data[k]);
           }
          }else{
           if(title[i].trim().equals("发料日期"))
           {
            if(data[data.length-1].indexOf("CA-MP")!=-1)
            {
             row.createCell(i).setCellValue(data[data.length-2]);
            }else
            {
             row.createCell(i).setCellValue(data[data.length-1]);
            }
            
           }
          }
         }
        }
        
       }
       FileOutputStream fileOut = new FileOutputStream(outPath);
       wb.write(fileOut);
       fileOut.close();
  }catch(Exception ex)
  {
   return false;
  }
  return true;
 }
}

分享到：
| 字符串操作，sql 倒序，以及截取字符串
评论
发表评论

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

相关推荐

    java操作excel——jxl和poi比较

    首先，jxl是较早的Java Excel处理库，主要用于读写Excel 97-2003格式的.XLS文件。它的API简洁，易于上手，对于简单的读写操作十分方便。例如，如果你只需要进行基础的数据读取或写入，不涉及复杂的样式设置和公式...

    POI与JXL的实战性能对比

    以下是对JXL和POI在实际项目中性能表现的一些分析： ##### 数据量处理能力 - **JXL**：由于其支持的Excel版本限制，JXL更适合处理不超过65535行的小型文件。对于大规模数据处理，JXL可能会遇到行数限制或内存溢出...

    jxl poi技术对excel操作

    jxl jxl包 poi技术导出数据至excel中 poi-bin-2.5.1包 jxl对excel表格 代码操作 poi技术 java代码从数据库取数据导入至Excel表中 poi-bin-2.5.1-final-20040804.jar

    Excel生成导出JXL和POI两种方式小demo

    此时，开发者通常会借助编程语言来实现自动化操作，Java中就有两个常用的库，即JXL和Apache POI，用于读写Excel文件。下面我们将详细探讨这两个库以及如何使用它们生成Excel导出。 1. **JXL库**： JXL是Java Excel...

    jxl poi jar包

    Apache POI是另一个广泛使用的Java库，它提供了读写Microsoft Office格式文件的能力，包括Excel (.xls和.xlsx)。与jxl相比，POI提供更广泛的API和功能，尤其是在处理较新版本的Excel文件（.xlsx，基于Open XML格式...

    实用jxl.jar读写xls文件demo

    需要注意的是，jxl库对.xlsx（Excel 2007及以后版本）的支持有限，如果你需要处理这种格式，可能需要考虑使用Apache POI或其他现代库。此外，jxl库不支持公式、图表等复杂功能，如果项目中有这些需求，可能需要寻找...

    用JXL读写excel到数据库实例

    使用jxl，读写excel数据进数据库的例子。 需要jxl.jar、poi-2.0-final-20040126.jar、mysql-connector-java-3.0.8-stable-bin.jar、jakarta-poi-1.5.1-final-20020615.jar。

    jxl与poi jar

    jxl是一个流行的开源库，专门用于读写Microsoft Excel格式的文件，而Apache POI是另一个强大的开源库，同样支持创建、修改和读取Microsoft Office格式的文件，包括Excel。 在描述中提到的"jxl的jar包以及相应的使用...

    JXL 和 POI　操作Excel 表格

    JXL适合对Excel功能需求不高的简单应用，而Apache POI则更适合需要深度定制和广泛支持Excel特性的复杂场景。选择哪一个取决于具体项目的需求和性能要求。在实际开发中，开发者可以根据项目需求和性能评估来决定使用...

    jxl poi java操作excel

    "jxl"和"Apache POI"是两个主要的库，分别提供了对Excel文件操作的支持。以下是对这两个库及其相关知识点的详细说明： 1. **jxl库**： - **简介**：jxl是一个开源Java库，专门用于读写Microsoft Excel文件。它支持...

    ExcelDemo_Excel导出_下载_POI读excel_JXL读写excel_java读写excel_列宽_读取合并或拆分单元格内容

    尽管POI提供了更全面的功能，但JXL对于简单的读写操作来说足够便捷。以下是一个使用JXL读取Excel文件的示例： ```java import jxl.Sheet; import jxl.Workbook; import jxl.read.biff.BiffException; import jxl....

    java 操作Excel jxl poi 有例子

    在POI中，我们可以使用`XSSFWorkbook`（对于.xlsx文件）或`HSSFWorkbook`（对于.xls文件）来读写Excel： ```java FileInputStream fis = new FileInputStream(new File("yourfile.xlsx")); XSSFWorkbook workbook =...

    JXL、POI实现Excel导入导出

    JXL和Apache POI是两个流行的Java库，专门用于读取、写入和操作Excel文件。下面将详细介绍这两个库以及如何利用它们实现Excel的导入导出功能。 ### JXL JXL（Java Excel API）是一个轻量级的Java库，它提供了读取...

    jxl，POI jar包

    标题中的“jxl，POI jar包”提及的是两个在Java编程中用于处理电子表格的库，即JExcelAPI（jxl）和Apache POI。这两个库都是为了方便开发者读写Microsoft Office格式的文件，尤其是Excel工作簿。下面将详细阐述这两...

    poi 和 jxl

    与Apache POI相比，JXL的功能相对简单，但它对Excel的读写操作也相当全面。你可以通过JXL创建新的工作表，插入数据，设置单元格样式，以及读取和解析现有的Excel文件。JXL的API通常被认为更易于理解和使用，但对较新...

    poi jxl 生成EXCEL 报表

    JXL是另一个处理Excel文件的Java库，它提供了简单的API用于读写Excel文件。在描述中提到的"jxl-2.6.jar"是JXL的一个版本。虽然POI功能更强大，但JXL在某些场景下可能更易于使用，尤其是对于简单的Excel操作。 - ...

    jxl.jar 和 poi3.14.jar

    总结来说，`jxl.jar`和`poi3.14.jar`都是用于Java环境下处理Excel文件的库，其中`jxl.jar`适用于老版本的`.xls`格式，而`poi3.14.jar`则同时支持`.xls`和`.xlsx`格式。在选择使用哪个库时，应根据项目需求和文件类型...

    Excel导入导出 jxl及Poi 工具类

    jxl是一个开源的Java库，专门设计用于读写Excel文件。它支持多种操作，如创建新的工作簿、修改现有工作簿、读取单元格数据、设置格式等。以下是一些关键知识点： 1. **创建工作簿**：使用`Workbook.createWorkbook...

    Java通过POI和JXL给Excel动态添加水印

    - **JXL**: 是一个用于读写Excel文件的Java库，支持多种Excel版本，包括.xls格式。 - **Apache POI**: 同样是处理Excel文件的强大Java库，除了支持.xls外还支持.xlsx等新版本格式，并且提供了更多的功能，如图表、...

    poi和jxl jar包

    Apache POI和JXL是两个流行的库，它们允许开发者用Java语言读写Microsoft Excel格式的数据。在这篇文章中，我们将深入探讨这两个库，以及如何在实际项目中使用它们。 首先，Apache POI是一个开源的Java API，它允许...

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