JAVA操作Excel参考

Java Excel是一开放源码项目,通过它Java开发人员可以读取Excel文件的内容、创建新的Excel文件、更新已经存在的Excel文件。

 

   今天突然翻到了以前的一个测试,好像也是从哪里拷贝修改改过的,注释里有个IBM的链接 http://www.ibm.com/developerworks/cn/java/l-javaExcel/?ca=j-t10,贴上来当作一个入门参考资料吧。

 

Java代码 复制代码
  1. import java.io.File;   
  2. import java.io.IOException;   
  3.   
  4. import jxl.Cell;   
  5. import jxl.HeaderFooter;   
  6. import jxl.Sheet;   
  7. import jxl.Workbook;   
  8. import jxl.format.VerticalAlignment;   
  9. import jxl.read.biff.BiffException;   
  10. import jxl.write.Label;   
  11. import jxl.write.WritableCellFormat;   
  12. import jxl.write.WritableImage;   
  13. import jxl.write.WritableSheet;   
  14. import jxl.write.WritableWorkbook;   
  15. import jxl.write.WriteException;   
  16. import jxl.write.biff.RowsExceededException;   
  17.   
  18. /**  
  19.  * @author cjj 2008-12-22 参考:  
  20.  *         http://www.ibm.com/developerworks/cn/java/l-javaExcel/?ca=j-t10  
  21.  *   
  22.  *   
  23.  */  
  24. public class ExcelUtils   
  25. {   
  26.     /**  
  27.      * 读取Excel文件的内容  
  28.      *   
  29.      * @param file  
  30.      *            待读取的文件  
  31.      * @return  
  32.      */  
  33.     public static String readExcel(final File file)   
  34.     {   
  35.         final StringBuffer sb = new StringBuffer();   
  36.   
  37.         Workbook wb = null;   
  38.         try  
  39.         {   
  40.             //构造Workbook(工作薄)对象      
  41.             wb = Workbook.getWorkbook(file);   
  42.         }   
  43.         catch (final BiffException e)   
  44.         {   
  45.             e.printStackTrace();   
  46.         }   
  47.         catch (final IOException e)   
  48.         {   
  49.             e.printStackTrace();   
  50.         }   
  51.   
  52.         if (wb == nullreturn null;   
  53.   
  54.         //获得了Workbook对象之后,就可以通过它得到Sheet(工作表)对象了      
  55.         final Sheet[] sheet = wb.getSheets();   
  56.   
  57.         if (sheet != null && sheet.length > 0)   
  58.         {   
  59.             //对每个工作表进行循环      
  60.             for (int i = 0; i < sheet.length; i++)   
  61.             {   
  62.                 //得到当前工作表的行数      
  63.                 final int rowNum = sheet[i].getRows();   
  64.                 for (int j = 0; j < rowNum; j++)   
  65.                 {   
  66.                     //得到当前行的所有单元格      
  67.                     final Cell[] cells = sheet[i].getRow(j);   
  68.                     if (cells != null && cells.length > 0)   
  69.                     {   
  70.                         //对每个单元格进行循环      
  71.                         for (int k = 0; k < cells.length; k++)   
  72.                         {   
  73.                             //读取当前单元格的值      
  74.                             final String cellValue = cells[k].getContents();   
  75.                             sb.append(cellValue + "\t");   
  76.                         }   
  77.                     }   
  78.                     sb.append("\r\n");   
  79.                 }   
  80.                 sb.append("\r\n");   
  81.             }   
  82.         }   
  83.         //最后关闭资源,释放内存      
  84.         wb.close();   
  85.         return sb.toString();   
  86.     }   
  87.   
  88.     /**  
  89.      * 生成一个Excel文件  
  90.      *   
  91.      * @param fileName  
  92.      *            要生成的Excel文件名  
  93.      */  
  94.     public static void writeExcel(final String fileName)   
  95.     {   
  96.         WritableWorkbook wwb = null;   
  97.         //格式化   
  98.         final WritableCellFormat totalFormat = new WritableCellFormat();   
  99.         try  
  100.         {   
  101.             //首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象      
  102.             wwb = Workbook.createWorkbook(new File(fileName));   
  103.             //格式化剧中   
  104.             totalFormat.setVerticalAlignment(VerticalAlignment.CENTRE);   
  105.   
  106.         }   
  107.         catch (final IOException e)   
  108.         {   
  109.             e.printStackTrace();   
  110.         }   
  111.         catch (final WriteException e)   
  112.         {   
  113.             e.printStackTrace();   
  114.         }   
  115.         if (wwb != null)   
  116.         {   
  117.             //创建一个可写入的工作表      
  118.             //Workbook的createSheet方法有两个参数,第一个是工作表的名称,第二个是工作表在工作薄中的位置      
  119.             final WritableSheet ws = wwb.createSheet("sheet1"0);   
  120.   
  121.             //下面开始添加单元格      
  122.             for (int i = 0; i < 10; i++)   
  123.             {   
  124.                 for (int j = 0; j < 5; j++)   
  125.                 {   
  126.                     //这里需要注意的是,在Excel中,第一个参数表示列,第二个表示行      
  127.                     final Label labelC = new Label(j, i, "这是第" + (i + 1) + "行,第" + (j + 1) + "列", totalFormat);   
  128.                     try  
  129.                     {   
  130.                         //将生成的单元格添加到工作表中      
  131.                         ws.addCell(labelC);   
  132.                     }   
  133.                     catch (final RowsExceededException e)   
  134.                     {   
  135.                         e.printStackTrace();   
  136.                     }   
  137.                     catch (final WriteException e)   
  138.                     {   
  139.                         e.printStackTrace();   
  140.                     }   
  141.   
  142.                 }   
  143.             }   
  144.   
  145.             try  
  146.             {   
  147.                 //把 单元格(column, row)到单元格(column1, row1)进行合并。   
  148.                 ws.mergeCells(6063);   
  149.                 //从内存中写入文件中      
  150.                 wwb.write();   
  151.                 //关闭资源,释放内存      
  152.                 wwb.close();   
  153.             }   
  154.             catch (final IOException e)   
  155.             {   
  156.                 e.printStackTrace();   
  157.             }   
  158.             catch (final WriteException e)   
  159.             {   
  160.                 e.printStackTrace();   
  161.             }   
  162.         }   
  163.     }   
  164.   
  165.     /**  
  166.      * 搜索某一个文件中是否包含某个关键字  
  167.      *   
  168.      * @param file  
  169.      *            待搜索的文件  
  170.      * @param keyWord  
  171.      *            要搜索的关键字  
  172.      * @return  
  173.      */  
  174.     public static boolean searchKeyWord(final File file, final String keyWord)   
  175.     {   
  176.         boolean res = false;   
  177.   
  178.         Workbook wb = null;   
  179.         try  
  180.         {   
  181.             //构造Workbook(工作薄)对象      
  182.             wb = Workbook.getWorkbook(file);   
  183.         }   
  184.         catch (final BiffException e)   
  185.         {   
  186.             return res;   
  187.         }   
  188.         catch (final IOException e)   
  189.         {   
  190.             return res;   
  191.         }   
  192.   
  193.         if (wb == nullreturn res;   
  194.   
  195.         //获得了Workbook对象之后,就可以通过它得到Sheet(工作表)对象了      
  196.         final Sheet[] sheet = wb.getSheets();   
  197.   
  198.         boolean breakSheet = false;   
  199.   
  200.         if (sheet != null && sheet.length > 0)   
  201.         {   
  202.             //对每个工作表进行循环      
  203.             for (int i = 0; i < sheet.length; i++)   
  204.             {   
  205.                 if (breakSheet) break;   
  206.   
  207.                 //得到当前工作表的行数      
  208.                 final int rowNum = sheet[i].getRows();   
  209.   
  210.                 boolean breakRow = false;   
  211.   
  212.                 for (int j = 0; j < rowNum; j++)   
  213.                 {   
  214.                     if (breakRow) break;   
  215.                     //得到当前行的所有单元格      
  216.                     final Cell[] cells = sheet[i].getRow(j);   
  217.                     if (cells != null && cells.length > 0)   
  218.                     {   
  219.                         boolean breakCell = false;   
  220.                         //对每个单元格进行循环      
  221.                         for (int k = 0; k < cells.length; k++)   
  222.                         {   
  223.                             if (breakCell) break;   
  224.                             //读取当前单元格的值      
  225.                             final String cellValue = cells[k].getContents();   
  226.                             if (cellValue == nullcontinue;   
  227.                             if (cellValue.contains(keyWord))   
  228.                             {   
  229.                                 res = true;   
  230.                                 breakCell = true;   
  231.                                 breakRow = true;   
  232.                                 breakSheet = true;   
  233.                             }   
  234.                         }   
  235.                     }   
  236.                 }   
  237.             }   
  238.         }   
  239.         //最后关闭资源,释放内存      
  240.         wb.close();   
  241.   
  242.         return res;   
  243.     }   
  244.   
  245.     /**  
  246.      * 往Excel中插入图片  
  247.      *   
  248.      * @param dataSheet  
  249.      *            待插入的工作表  
  250.      * @param col  
  251.      *            图片从该列开始  
  252.      * @param row  
  253.      *            图片从该行开始  
  254.      * @param width  
  255.      *            图片所占的列数  
  256.      * @param height  
  257.      *            图片所占的行数  
  258.      * @param imgFile  
  259.      *            要插入的图片文件  
  260.      */  
  261.     public static void insertImg(   final WritableSheet dataSheet,   
  262.                                     final int col,   
  263.                                     final int row,   
  264.                                     final int width,   
  265.                                     final int height,   
  266.                                     final File imgFile)   
  267.     {   
  268.         final WritableImage img = new WritableImage(col, row, width, height, imgFile);   
  269.         dataSheet.addImage(img);   
  270.     }   
  271.   
  272.     /**  
  273.      * 向Excel中加入页眉页脚  
  274.      *   
  275.      * @param dataSheet  
  276.      *            待加入页眉的工作表  
  277.      * @param left  
  278.      * @param center  
  279.      * @param right  
  280.      */  
  281.     public static void setHeader(   final WritableSheet dataSheet,   
  282.                                     final String left,   
  283.                                     final String center,   
  284.                                     final String right)   
  285.     {   
  286.         final HeaderFooter hf = new HeaderFooter();   
  287.         hf.getLeft().append(left);   
  288.         hf.getCentre().append(center);   
  289.         hf.getRight().append(right);   
  290.         //加入页眉      
  291.         dataSheet.getSettings().setHeader(hf);   
  292.         //加入页脚      
  293.         //dataSheet.getSettings().setFooter(hf);      
  294.     }   
  295.   
  296.     //测试   
  297.     public static void main(final String[] arts)   
  298.     {   
  299.   
  300.         //测试写   
  301.         ExcelUtils.writeExcel("test.xls");   
  302.   
  303.         if (false)   
  304.         {   
  305.             //测试插入页眉页脚   
  306.             try  
  307.             {   
  308.                 //创建一个工作薄      
  309.                 final WritableWorkbook workbook = Workbook.createWorkbook(new File("test.xls"));   
  310.                 //待插入的工作表      
  311.                 final WritableSheet dataSheet = workbook.createSheet("加入页眉"0);   
  312.                 ExcelUtils.setHeader(dataSheet, "chb""2007-03-06""第1页,共3页");   
  313.                 workbook.write();   
  314.                 workbook.close();   
  315.             }   
  316.             catch (final IOException e)   
  317.             {   
  318.                 e.printStackTrace();   
  319.             }   
  320.             catch (final WriteException e)   
  321.             {   
  322.                 e.printStackTrace();   
  323.             }   
  324.         }   
  325.   
  326.         if (false)   
  327.         {   
  328.             //测试插入图片   
  329.             try  
  330.             {   
  331.                 //创建一个工作薄      
  332.                 final WritableWorkbook workbook = Workbook.createWorkbook(new File("D:/testxls"));   
  333.                 //待插入的工作表      
  334.                 final WritableSheet imgSheet = workbook.createSheet("Images"0);   
  335.                 //要插入的图片文件      
  336.                 final File imgFile = new File("D:/png");   
  337.                 //图片插入到第二行第一个单元格,长宽各占六个单元格      
  338.                 insertImg(imgSheet, 0166, imgFile);   
  339.                 workbook.write();   
  340.                 workbook.close();   
  341.             }   
  342.             catch (final IOException e)   
  343.             {   
  344.                 e.printStackTrace();   
  345.             }   
  346.             catch (final WriteException e)   
  347.             {   
  348.                 e.printStackTrace();   
  349.             }   
  350.         }   
  351.   
  352.     }   
  353. }  
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
目标检测(Object Detection)是计算机视觉领域的一个核心问题,其主要任务是找出图像中所有感兴趣的目标(物体),并确定它们的类别和位置。以下是对目标检测的详细阐述: 一、基本概念 目标检测的任务是解决“在哪里?是什么?”的问题,即定位出图像中目标的位置并识别出目标的类别。由于各类物体具有不同的外观、形状和姿态,加上成像时光照、遮挡等因素的干扰,目标检测一直是计算机视觉领域最具挑战性的任务之一。 二、核心问题 目标检测涉及以下几个核心问题: 分类问题:判断图像中的目标属于哪个类别。 定位问题:确定目标在图像中的具体位置。 大小问题:目标可能具有不同的大小。 形状问题:目标可能具有不同的形状。 三、算法分类 基于深度学习的目标检测算法主要分为两大类: Two-stage算法:先进行区域生成(Region Proposal),生成有可能包含待检物体的预选框(Region Proposal),再通过卷积神经网络进行样本分类。常见的Two-stage算法包括R-CNN、Fast R-CNN、Faster R-CNN等。 One-stage算法:不用生成区域提议,直接在网络中提取特征来预测物体分类和位置。常见的One-stage算法包括YOLO系列(YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5等)、SSD和RetinaNet等。 四、算法原理 以YOLO系列为例,YOLO将目标检测视为回归问题,将输入图像一次性划分为多个区域,直接在输出层预测边界框和类别概率。YOLO采用卷积网络来提取特征,使用全连接层来得到预测值。其网络结构通常包含多个卷积层和全连接层,通过卷积层提取图像特征,通过全连接层输出预测结果。 五、应用领域 目标检测技术已经广泛应用于各个领域,为人们的生活带来了极大的便利。以下是一些主要的应用领域: 安全监控:在商场、银行
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值