poi解析excel

package org.test.create;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFCell;
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.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;

public class WorkBookCreate {

	public static void main(String[] args) throws IOException{
		//测试创建Workbook
		/**
		new WorkBookCreate().createWorkBook();
		**/

		
		
       //测试获取指定列中的所有的单元格，包括非合并单元格
	   /**
		* 
		HSSFWorkbook wb=null;
		InputStream in =null;
		in = new FileInputStream("c:/test1.xls");
		wb = new HSSFWorkbook(in);
		HSSFSheet sheet = wb.getSheet("sheet1");
		List<String> columnNameList = new WorkBookCreate().getColumnCell(sheet, 0);
		Iterator<String> iterator = columnNameList.iterator();
		System.out.println("start..."+columnNameList.size());
		while(iterator.hasNext())
		 {
		  System.out.println(iterator.next());
		 }
        */
		
		
		
		//直接去文本，优点是不需要遍历，有时可能会用到。
		/**
		ExcelExtractor excelExtractor = new ExcelExtractor(workBook);
		excelExtractor.setIncludeSheetNames(false);//不需要Sheet页的名字
		System.out.println(excelExtractor.getText());
		**/
		
		
		
		//测试合并单元格中的值是否是getVal(minRow,minColumn)中的值
		/**
		HSSFWorkbook wb=null;
		InputStream in =null;
		in = new FileInputStream("c:/test1.xls");
		wb = new HSSFWorkbook(in);
		new WorkBookCreate().getCellVal(wb.getSheet("sheet1"));
		**/
	}
	
	

	/**
	 * 创建工作薄
	 * @author Administrator
	 * @return 创建的工作薄
	 * @since 2014-11-20
	 */
	public Workbook createWorkBook()
	{
		//创建一个新的工作簿
		HSSFWorkbook workBook = new HSSFWorkbook();
		
		//如果不创建Sheet页，当打开创建好后的工作薄，可能会报"文件错误，数据可能丢失"
		//创建Sheet
		List<String> sheetsName = new ArrayList<String>();
		sheetsName.add("Sheet页1");
		sheetsName.add("Sheet页2");
		sheetsName.add("Sheet页3");
		createSheet(workBook, sheetsName);
		
		
		HSSFSheet sheet = workBook.getSheetAt(0); //获取工作薄中的第一个Sheet页做测试
		
		//创建行
		HSSFRow row = createRow(sheet, 0); //创建第一个Sheet页中的第一行
		HSSFRow row2=createRow(sheet , 1); //创建第一个Sheet页中的第二行
		
		//格式化日期，创建单元格样式
		CreationHelper helper = workBook.getCreationHelper();
		CellStyle style = workBook.createCellStyle();
		style.setDataFormat(helper.createDataFormat().getFormat("yyyy-MM-dd HH:mm:ss"));
		
		//创建第一行中的单元格
		Cell c1 = createCell(row , 0 , workBook); //创建第一行的第一个单元格,并设置值为字符串
		c1.setCellValue("第一个单元格");
		
		Cell c2 = createCell(row , 1 , workBook); //创建第一行的第二个单元格，并设置值为日期
		c2.setCellValue(new Date());
		c2.setCellStyle(style);//设置单元格样式
		
		Cell c3= createCell(row , 2 , workBook); //创建第一行的第三个单元格，并设置值为浮点数
		c3.setCellValue(223.3);
		
		//创建第二行中的单元格
		Cell c4 = createCell(row2, 0 , workBook);
		c4.setCellValue("第二个单元格第一列");
		
		Cell c5 = createCell(row2, 1 , workBook);
		c5.setCellValue("第二个单元格第二列");
		
		Cell c6 = createCell(row2, 2 , workBook);
		c6.setCellValue(Calendar.getInstance());
		c6.setCellStyle(style); //设置单元格样式
		
		//将工作簿存到指定的本地磁盘上，并关闭输出流
		try {
			OutputStream out = new FileOutputStream("c:\\students.xls");
			workBook.write(out);
		    out.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e)
		{
			e.printStackTrace();
		}
		return workBook;
	}
	
	
	
	/**
	 * 创建Sheet页
	 * @author Administrator
	 * @param wb 工作薄
	 * @param sheetsName  工作薄中各个sheet页的sheet名字
	 * @return 创建的各个Sheet页
	 * @since 2014-11-20
	 */
	public List<Sheet> createSheet(HSSFWorkbook wb , List<String> sheetsName)
	{
		List<Sheet> sheetList = new ArrayList<Sheet>();
		if(wb == null || sheetsName.size()<=0)
		{
			return null;
		}
		
		for(String str : sheetsName)
		{
			Sheet sheet = wb.createSheet(str);
			sheetList.add(sheet);
		}
		
		return sheetList;
	}
	
	
	
	/**
	 * 创建Sheet页中的行
	 * @author Administrator
	 * @param sheet sheet页
	 * @param lineNum 行号
	 * @return 创建的行
	 * @since 2014-11-20
	 */
	public HSSFRow  createRow(HSSFSheet sheet , int lineNum)
	{    HSSFRow  row = null;
		if(sheet != null)
		{
		   row = sheet.createRow(lineNum);
		}
		return row;
	}
	
	
	
	/**
	 * 创建Sheet页中的单元格
	 * @author Administrator
	 * @param row sheet页中的行
	 * @param x 行坐标
	 * @param y 纵坐标
	 * @return 单元格
	 * @since 2014-11-20
	 */
	public Cell createCell(Row row , int columnNum , Workbook wb)
	{
		Cell cell=null;
		if(row != null)
		{
		  cell = row.createCell(columnNum);
		}
		return cell;
	}
	
	
	
	/**
	 * 遍历工作薄
	 * 先遍历行，再遍历列
	 * @author Administrator
	 * @param wb 要遍历的工作薄
	 */
	public void searchWorkbook(Workbook wb)
	{
		if(wb != null)
		{
		int sheetNums=wb.getNumberOfSheets();
		for(int i=0; i<sheetNums; i++)
		{
			Sheet sheet = wb.getSheetAt(i);
		    if(sheet != null)
			{
			//变量每个Sheet页中行
			for(Row row : sheet)
			{
				if(row != null)
				{
					//遍历列
					for(Cell cell : row)
					{
						System.out.println(getValue(cell)); //获取单元格中的值
					}
				}
			}
			}
		}
	}
  }
	
	
	
	/**
	 * 遍历工作薄
	 * 先遍历列，在遍历行
	 * @author Administrator
	 * @param wb 要遍历的工作薄
	 * @since2014-11-23
	 */
    public void searchWrokbookColumn(Workbook wb)
    {
    	Cell cell=null;
    	String columnName="";
    	List<String> list = new ArrayList<String>();
        Sheet sheet = wb.getSheet("sheet1");
       //遍历行
       if(sheet != null)
       {
    	   for(Row row : sheet)
    	   {
    		   //遍历第一列的数据
    		   if(row != null)
    		   {
    			   cell = row.getCell(0);
    			   columnName = getValue(cell);
    			   if(!columnName.equals("") && columnName!=null)
    			   {
    				   list.add(columnName);
    			   }    		   
    		   }
    	   }
       }
       
       for(int i=0; i<list.size() ;i++)
       {
    	   System.out.println(list.get(i));
       }
       
    }
    
   
    
    /**
     * 获取指定某列的所有单元格（包括合并单元格）
     * @param sheet sheet页
     * @param firstCol 起始列
     * @param lastCol  终止列
     * @return 指定列中的所有的单元格，包括合并后的单元格。
     * @since 2014-11-23
     */
    public List<String> getColumnCell(HSSFSheet sheet , int columnIndex) 
    { 
    Cell cell=null;
    List<String> list = new ArrayList<String>();
    
    //遍历整个sheet页中所有合并的单元格
    if(sheet!=null)
    {
    	for(Row row : sheet)
    	{
    		if(row != null)
    		{
    			cell=row.getCell(columnIndex);
    			String cellVal=getValue(cell);
    			if(!cellVal.equals(""))
    			{
    				list.add(cellVal);
    			}
    		}
    	}
    }
        return list;
    }
    
    
    
    /**
     * 获取起始列为firstCol,终止列为lastCol的  “合并的单元格”
     * 注意1：只能获取起始列为firstCol,终止列为lastCol的“合并单元格”，对于他们之间是否有更小的合并单元格是无法获取的
     * 注意2：只能获取合并单元格
     * @param sheet sheet页
     * @param firstCol 起始列
     * @param lastCol  终止列
     * @return 指定列中的"合并后"的单元格。
     * @since 2014-11-23
     */
    public List<String> getColumnMergedRegionCell(HSSFSheet sheet , int firstCol , int lastCol) { 
    List<String> list = new ArrayList<String>();
    int sheetMergeCount = sheet.getNumMergedRegions(); 
    
    //遍历整个sheet页中所有合并的单元格
    for (int i = 0; i < sheetMergeCount; i++) 
    { 
        CellRangeAddress ca = sheet.getMergedRegion(i); 
        int firstRow=ca.getFirstRow();
        int firstColumn = ca.getFirstColumn(); 
        int lastColumn = ca.getLastColumn(); 
    
        HSSFCell cell = sheet.getRow(firstRow).getCell(firstColumn);
    
        //找出指定列之间的单元格
        if(firstColumn==firstCol && lastColumn==lastCol)
          {
    	     list.add(getValue(cell));
          }
    }
        return list;
    }
    
    
    
    /**
     * 测试合并单元格情况下，单元格中的值是取得哪行哪列的值
     * 总结：合并的单元格取得值是get(minRow,minColumn)的值，即单元格的值就是getVal(minRow , minColumn)的值
     *     而单元格!minRow,!minColumn中的值是”空“
     * @author Administrator
     * @param sheet
     * @since 2014-11-23
     */
	public void getCellVal(Sheet sheet)
	{
		if(sheet!=null)
		{
			for(Row row : sheet)
			{
				if(row != null)
			    {
					for(Cell cell : row)
					{
						System.out.println((row.getRowNum()+1)+"行"+(cell.getColumnIndex()+1)+"列:"+getValue(cell));
					}
				
			    }
			}
		}
	}
	
	
	
	/**
	 * 获取单元格的值
	 * @author Administrator
	 * @param cell 单元格
	 * @since 2014-11-20
	 */
	private String getValue(Cell cell) {
		
		if(cell.getCellType()==Cell.CELL_TYPE_BOOLEAN)
		{
			return cell.getBooleanCellValue()+"";
		}else  if(cell.getCellType()==Cell.CELL_TYPE_NUMERIC)
		{
			return cell.getNumericCellValue()+"";
		}else
		{
			return cell.getStringCellValue();
		}
		 
	}
}