jacob操作word增加表格 行列

import  com.jacob.activeX.ActiveXComponent;
import  com.jacob.com.Dispatch;
import  com.jacob.com.Variant;
import  com.jacob.com.ComThread;

public   class  StudyJacob {

     // word文档
     private  Dispatch doc =  null ;
     // word运行程序对象
     private  ActiveXComponent word =  null ;

     // 所有word文档集合
     private  Dispatch documents =  null ;
     // 选定的范围或插入点
     private   static  Dispatch selection =  null ;
     // 设置是否保存后才退出的标志
     private   boolean  saveOnExit =  true ;
     /**
     * word中的当前文档
     */
     private   static  Dispatch document =  null ;
     // private static Dispatch textFrame = null;
     //
     /**
     * 所有表格
     */
     private  Dispatch tables;
     /**
     * 当前表格
     */
     private  Dispatch table;
     /**
     * 当前单元格
     */
     private  Dispatch cell;
     /**
     * 当前表格中的所有行
     */
     private  Dispatch rows;
     /**
     * 表格中的某一行
     */
     private  Dispatch row;
     /**
     * 表格中的所有列
     */
     private  Dispatch columns;
     /**
     * 表格中的某一列
     */
     private  Dispatch column;
     /**
     * 打开word时同时要打开的文档，不指定时将新建一个空白文档
     */
     // private File openDoc;
     private   static  Dispatch shapes;
     private   static  Dispatch shape;
     private   static  Dispatch textRange;
     private   static  Dispatch textframe;
     private  Dispatch range;
     private  Dispatch paragraphs;
     private  Dispatch paragraph;

     // constructor
     public  StudyJacob() {

         if  (word ==  null ) {
            word =  new  ActiveXComponent( "Word.Application" );
            word.setProperty( "Visible" ,  new  Variant( true ));
        }
         if  (documents ==  null ) {
            documents = word.getProperty( "Documents" ).toDispatch();
        }

    }

     /**
     * 创建一个新的word文档
     * 
     */

     public   void  createNewDocument() {
        doc = Dispatch.call(documents,  "Add" ).toDispatch();

        selection = Dispatch.get(word,  "Selection" ).toDispatch();

    }

     /**
     * 打开一个已存在的文档
     * 
     * @param docPath
     */

     public   void  openDocument(String docPath) {
         if  ( this .doc !=  null ) {
             this .closeDocument();
        }
        doc = Dispatch.call(documents,  "Open" , docPath).toDispatch();
        selection = Dispatch.get(word,  "Selection" ).toDispatch();
    }

     /**
     * 关闭当前word文档
     * 
     */
     public   void  closeDocument() {
         if  (doc !=  null ) {
            Dispatch.call(doc,  "Save" );
            Dispatch.call(doc,  "Close" ,  new  Variant(saveOnExit));
            doc =  null ;
        }
    }

     /**
     * 关闭全部应用
     * 
     */
     public   void  close() {
        closeDocument();
         if  (word !=  null ) {
            Dispatch.call(word,  "Quit" );
            word =  null ;
        }
        selection =  null ;
        documents =  null ;

    }

     /**
     * 把插入点移动到文件首位置
     * 
     */
     public   void  moveStart() {
         if  (selection ==  null )
            selection = Dispatch.get(word,  "Selection" ).toDispatch();
        Dispatch.call(selection,  "HomeKey" ,  new  Variant( 6 ));

    }

     /**
     * 在当前插入点插入字符串
     * 
     * @param newText
     *            要插入的新字符串
     */
     public   void  insertText(String newText) {
        Dispatch.put(selection,  "Text" , newText);
    }

     /**
     * 在当前插入点插入图片
     * 
     * @param imagePath
     *            图片路径
     */
     public   void  insertImage(String imagePath) {
        Dispatch.call(Dispatch.get(selection,  "InLineShapes" ).toDispatch(),
                 "AddPicture" , imagePath);
    }

     /**
     * 把选定的内容或者插入点向下移动
     * 
     * @param pos
     *            移动的距离
     */
     public   void  moveDown( int  pos) {
         if  (selection ==  null )
            selection = Dispatch.get(word,  "Selection" ).toDispatch();
         for  ( int  i =  0 ; i < pos; i++)
            Dispatch.call(selection,  "MoveDown" );
    }

     /**
     * 把选定的内容或插入点向上移动
     * 
     * @param pos
     *            移动的距离
     */
     public   void  moveUp( int  pos) {
         if  (selection ==  null )
            selection = Dispatch.get(word,  "Selection" ).toDispatch();
         for  ( int  i =  0 ; i < pos; i++)
            Dispatch.call(selection,  "MoveUp" );
    }

     /**
     * 把选定的内容或者插入点向左移动
     * 
     * @param pos
     *            移动的距离
     */
     public   void  moveLeft( int  pos) {
         if  (selection ==  null )
            selection = Dispatch.get(word,  "Selection" ).toDispatch();
         for  ( int  i =  0 ; i < pos; i++) {
            Dispatch.call(selection,  "MoveLeft" );
        }
    }

     /**
     * 把选定的内容或者插入点向右移动
     * 
     * @param pos
     *            移动的距离
     */
     public   void  moveRight( int  pos) {
         if  (selection ==  null )
            selection = Dispatch.get(word,  "Selection" ).toDispatch();
         for  ( int  i =  0 ; i < pos; i++)
            Dispatch.call(selection,  "MoveRight" );
    }

     /**
     * 文件保存或另存为
     * 
     * @param savePath
     *            一定要记得加上扩展名 .doc 保存或另存为路径
     */
     public   void  save(String savePath) {
        Dispatch.call(
                (Dispatch) Dispatch.call(word,  "WordBasic" ).getDispatch(),
                 "FileSaveAs" , savePath);

    }

     /**
     * 从第tIndex个Table中取出值第row行，第col列的值
     * 
     * @param tableIndex
     *            文档中的第tIndex个Table，即tIndex为索引取
     * @param cellRowIdx
     *            cell在Table第row行
     * @param cellColIdx
     *            cell在Talbe第col列
     * @return cell单元值
     * @throws Exception
     */
     public  String getCellString( int  tableIndex,  int  cellRowIdx,  int  cellColIdx)
             throws  Exception {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要取数据的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
        Dispatch cell = Dispatch.call(table,  "Cell" ,  new  Variant(cellRowIdx),
                 new  Variant(cellColIdx)).toDispatch();
        Dispatch.call(cell,  "Select" );
         return  Dispatch.get(selection,  "Text" ).toString();
    }

     /**
     * 从第tableIndex个Table中取出值第cellRowIdx行，第cellColIdx列的值
     * 
     * @param tIndex
     *            文档中的第tIndex个Table，即tIndex为索引取
     * @param cellRowIdx
     *            cell在Table第row行
     * @param cellColIdx
     *            cell在Talbe第col列
     * @return cell单元值
     * @throws Exception
     */
     public   void  getCellValue( int  tableIndex,  int  cellRowIdx,  int  cellColIdx)
             throws  Exception {

         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要取数据的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
        Dispatch cell = Dispatch.call(table,  "Cell" ,  new  Variant(cellRowIdx),
                 new  Variant(cellColIdx)).toDispatch();
        Dispatch.call(cell,  "Select" );
        Dispatch.call(selection,  "Copy" );

    }

     /**
     * 在当前光标处做粘贴
     */
     public   void  paste() {
        Dispatch.call(selection,  "Paste" );
    }

     /**
     * 在当前光标处添加图片
     * 
     * @param imgPath
     *            图片的地址
     */
     public   void  addImage(String imgPath) {
         if  (imgPath !=  ""  && imgPath !=  null ) {
            Dispatch image = Dispatch.get(selection,  "InLineShapes" )
                    .toDispatch();
            Dispatch.call(image,  "AddPicture" , imgPath);
        }
    }

     /**
     * 在指定的单元格里填写数据
     * 
     * @param tableIndex
     *            文档中的第tIndex个Table，即tIndex为索引取
     * @param cellRowIdx
     *            cell在Table第row行
     * @param cellColIdx
     *            cell在Talbe第col列
     * @param txt
     *            填写的数据
     */
     public   void  putTxtToCell( int  tableIndex,  int  cellRowIdx,  int  cellColIdx,
            String txt) {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
        Dispatch cell = Dispatch.call(table,  "Cell" ,  new  Variant(cellRowIdx),
                 new  Variant(cellColIdx)).toDispatch();
        Dispatch.call(cell,  "Select" );
        Dispatch.put(selection,  "Text" , txt);
    }

     /**
     * 
     * 得到当前文档的tables集合
     */
     public  Dispatch getTables()  throws  Exception {
         if  ( this .doc ==  null ) {
             throw   new  Exception( "there is not a document can't be operate!!!" );
        }

         return  Dispatch.get(doc,  "Tables" ).toDispatch();
    }

     /**
     * 
     * 得到当前文档的表格数
     * 
     * @param Dispatch
     */
     public   int  getTablesCount(Dispatch tables)  throws  Exception {
         int  count =  0 ;
         try  {
             this .getTables();
        }  catch  (Exception e) {
             throw   new  Exception( "there is not any table!!" );
        }
        count = Dispatch.get(tables,  "Count" ).toInt();

         return  count;
    }

     /**
     * 在当前文档指定的位置拷贝表格
     * 
     * @param pos
     *            当前文档指定的位置
     * @param tableIndex
     *            被拷贝的表格在word文档中所处的位置
     */
     public   void  copyTable(String pos,  int  tableIndex) {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
        Dispatch range = Dispatch.get(table,  "Range" ).toDispatch();
        Dispatch.call(range,  "Copy" );
        Dispatch textRange = Dispatch.get(selection,  "Range" ).toDispatch();
        Dispatch.call(textRange,  "Paste" );

    }

     /**
     * 在当前文档指定的位置拷贝来自另一个文档中的表格
     * 
     * @param anotherDocPath
     *            另一个文档的磁盘路径
     * @param tableIndex
     *            被拷贝的表格在另一格文档中的位置
     * @param pos
     *            当前文档指定的位置
     */
     public   void  copyTableFromAnotherDoc(String anotherDocPath,  int  tableIndex,
            String pos) {
        Dispatch doc2 =  null ;
         try  {
            doc2 = Dispatch.call(documents,  "Open" , anotherDocPath)
                    .toDispatch();
             // 所有表格
            Dispatch tables = Dispatch.get(doc2,  "Tables" ).toDispatch();
             // 要填充的表格
            Dispatch table = Dispatch.call(tables,  "Item" ,
                     new  Variant(tableIndex)).toDispatch();
            Dispatch range = Dispatch.get(table,  "Range" ).toDispatch();
            Dispatch.call(range,  "Copy" );

            Dispatch textRange = Dispatch.get(selection,  "Range" ).toDispatch();
            moveDown( 1 );
            Dispatch.call(textRange,  "Paste" );

        }  catch  (Exception e) {
            e.printStackTrace();
        }  finally  {
             if  (doc2 !=  null ) {
                Dispatch.call(doc2,  "Close" ,  new  Variant(saveOnExit));
                doc2 =  null ;
            }
        }
    }

     /**
     * 在当前文档拷贝剪贴板数据
     * 
     * @param pos
     */
     public   void  pasteExcelSheet(String pos) {
        moveStart();

        Dispatch textRange = Dispatch.get(selection,  "Range" ).toDispatch();
        Dispatch.call(textRange,  "Paste" );

    }

     /**
     * 选中dispatch对象
     * 
     * @param dispatch（分配，派遣）
     */
     private   void  select(Dispatch dispatch) {
        Dispatch.call(dispatch,  "Select" );
    }

     /**
     * 在当前文档指定的位置拷贝来自另一个文档中的图片
     * 
     * @param anotherDocPath
     *            另一个文档的磁盘路径
     * @param shapeIndex
     *            被拷贝的图片在另一格文档中的位置
     * @param pos
     *            当前文档指定的位置
     * @throws com.jacob.com.ComFailException
     *             Invoke of: Item Source: Microsoft Word 若shapeIndex不存在
     */
     public   void  copyImageFromAnotherDoc(String anotherDocPath,  int  shapeIndex,
            String pos) {
        Dispatch doc2 =  null ;
         try  {
            doc2 = Dispatch.call(documents,  "Open" , anotherDocPath)
                    .toDispatch();
            Dispatch shapes = Dispatch.get(doc2,  "InLineShapes" ).toDispatch();
            Dispatch shape = Dispatch.call(shapes,  "Item" ,
                     new  Variant(shapeIndex)).toDispatch();
            Dispatch imageRange = Dispatch.get(shape,  "Range" ).toDispatch();
            Dispatch.call(imageRange,  "Copy" );

            Dispatch textRange = Dispatch.get(selection,  "Range" ).toDispatch();
            moveDown( 4 );
            Dispatch.call(textRange,  "Paste" );

        }  catch  (Exception e) {
            e.printStackTrace();
        }  finally  {
             if  (doc2 !=  null ) {
                Dispatch.call(doc2,  "Close" ,  new  Variant(saveOnExit));
                doc2 =  null ;
            }
        }
    }

     /**
     * 打印当前word文档
     * 
     * @throws Exception
     *             com.jacob.com.ComFailException: Invoke of: PrintOut Source:
     *             Microsoft Word 若无打印机
     */
     public   void  printFile() {
         if  (doc !=  null ) {
            Dispatch.call(doc,  "PrintOut" );
        }
    }

     /**
     * 打印文本，反选，在文本后换行<br>
     * 警告：使用了Home, End来取消选中
     * 
     * @param s
     */
     public   void  println(String s) {
        write(s);
        goToEnd();
        cmd( "TypeParagraph" );
    }

     /**
     * 执行某条宏指令
     * 
     * @param cmd
     */
     private   void  cmd(String cmd) {
        Dispatch.call(selection, cmd);
    }

     /**
     * 按下Ctrl + End键
     */
     public   void  goToEnd() {
        Dispatch.call(selection,  "EndKey" ,  "6" );
    }

     /**
     * 反选，再打印文本<br>
     * 警告：使用了Home, End来取消选中
     */
     public   void  print(String s) {
        goToEnd();
        write(s);
    }

     /**
     * 不反选, 直接输出文本
     * 
     * @param s
     */
     public   void  write(String s) {
        Dispatch.put(selection,  "Text" , s);
    }

     /**
     * 反选，在文本后换行<br>
     * 警告：使用了Home, End来取消选中
     */
     public   void  println() {
        home();
        end();
        cmd( "TypeParagraph" );
    }

     /**
     * 按下Home键
     */
     public   void  home() {
        Dispatch.call(selection,  "HomeKey" ,  "5" );
    }

     /**
     * 按下End键
     */
     public   void  end() {
        Dispatch.call(selection,  "EndKey" ,  "5" );
    }

     /**
     * 按下Ctrl + Home键
     */
     public   void  goToBegin() {
        Dispatch.call(selection,  "HomeKey" ,  "6" );
    }

     /**
     * 设置指定表格指定列的列宽
     * 
     * @param tableIndex
     * @param columnWidth
     * @param columnIndex
     */
     public   void  setColumnWidth( int  tableIndex,  float  columnWidth,
             int  columnIndex) {
         this .getTable(tableIndex);

         this .setColumnWidth(columnWidth, columnIndex);
    }

     /**
     * 查找表
     * 
     * @param tableIndex
     * @return
     */
     public  Dispatch getTable( int  tableIndex) {
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();

         return  table;
    }

     public  Dispatch getShapes()  throws  Exception {
         return  Dispatch.get(doc,  "Shapes" ).toDispatch();
    }

     public   int  getShapesCount()  throws  Exception {
         int  count =  0 ;

        count = Dispatch.get(shapes,  "Count" ).toInt();

         return  count;
    }

     public  Dispatch getShape( int  tIndex)  throws  Exception {

         return  Dispatch.call(shapes,  "Item" ,  new  Variant(tIndex)).toDispatch();
         // return Dispatch.invoke(shapes,"item",Dispatch.Method,new Object[]{
         // new Integer(tIndex)},new int[1]).toDispatch();
    }

     public  Dispatch getTextFrame()  throws  Exception {
         return  Dispatch.get(shape,  "TextFrame" ).toDispatch();
    }

     public  Dispatch getTextRange()  throws  Exception {
         return  Dispatch.get(textframe,  "TextRange" ).toDispatch();
    }

     /**
     * 设置当前表格指定列的列宽
     * 
     * @param columnWidth
     * @param columnIndex
     * @throws 如果不是整齐的表格不能使用
     */
     public   void  setColumnWidth( float  columnWidth,  int  columnIndex) {
         if  (columnWidth <  11 ) {
            columnWidth =  120 ;
        }

         if  (columns ==  null  || column ==  null ) {
             this .getColumns();
             this .getColumn(columnIndex);
        }

        Dispatch.put(column,  "Width" ,  new  Variant(columnWidth));
    }

     /**
     * 设置指定表格指定列的背景色
     * 
     * @param tableIndex
     * @param columnIndex
     * @param color
     *            取值范围 0 < color < 17 默认：16 浅灰色 1：黑色 2：蓝色 3：浅蓝 ...............
     */
     public   void  setColumnBgColor( int  tableIndex,  int  columnIndex,  int  color) {
         this .getTable(tableIndex);
         this .setColumnBgColor(columnIndex, color);
    }

     /**
     * 设置当前表格指定列的背景色
     * 
     * @param columnIndex
     * @param color
     *            取值范围 0 < color < 17 默认：16 浅灰色 1：黑色 2：蓝色 3：浅蓝 ...............
     */
     public   void  setColumnBgColor( int  columnIndex,  int  color) {
         this .getColumn(columnIndex);

        Dispatch shading = Dispatch.get(column,  "Shading" ).toDispatch();

         if  (color >  16  || color <  1 )
            color =  16 ;
        Dispatch
                .put(shading,  "BackgroundPatternColorIndex" ,  new  Variant(color));
    }

     /**
     * 初始化 com 线程
     */
     public   void  initCom() {
        ComThread.InitSTA();
    }

     /**
     * 释放 com 线程资源 com 的线程回收不由 java 垃圾回收机制回收
     */
     public   void  releaseCom() {
        ComThread.Release();
    }

     /**
     * 设置当前表格指定行的背景色
     * 
     * @param rowIndex
     * @param color
     *            取值范围 0 < color < 17 默认：16 浅灰色 1：黑色 2：蓝色 3：浅蓝 ...............
     */
     public   void  setRowBgColor( int  rowIndex,  int  color) {
         this .getRow(rowIndex);

        Dispatch shading = Dispatch.get(row,  "Shading" ).toDispatch();

         if  (color >  16  || color <  1 )
            color =  16 ;
        Dispatch
                .put(shading,  "BackgroundPatternColorIndex" ,  new  Variant(color));
    }

     /**
     * 设置指定表格的指定行的背景色
     * 
     * @param tableIndex
     * @param rowIndex
     * @param color
     *            取值范围 0 < color < 17 默认：16 浅灰色 1：黑色 2：蓝色 3：浅蓝 ...............
     */
     public   void  setRowBgColor( int  tableIndex,  int  rowIndex,  int  color) {
         this .getTable(tableIndex);

         this .setRowBgColor(rowIndex, color);
    }

     /**
     * 设置当前选定内容的字体
     * 
     * @param isBold
     *            是否为粗体
     * @param isItalic
     *            是否为斜体
     * @param isUnderLine
     *            是否带下划线
     * @param color
     *            rgb 字体颜色 例如：红色 255,0,0
     * @param size
     *            字体大小 12:小四 16:三号
     * @param name
     *            字体名称 例如：宋体，新宋体，楷体，隶书
     */
     public   void  setFont( boolean  isBold,  boolean  isItalic,  boolean  isUnderLine,
            String color, String size, String name) {
        Dispatch font = Dispatch.get(selection,  "Font" ).toDispatch();
        Dispatch.put(font,  "Name" ,  new  Variant(name));
        Dispatch.put(font,  "Bold" ,  new  Variant(isBold));
        Dispatch.put(font,  "Italic" ,  new  Variant(isItalic));
        Dispatch.put(font,  "Underline" ,  new  Variant(isUnderLine));
        Dispatch.put(font,  "Color" , color);
        Dispatch.put(font,  "Size" , size);
    }

     /**
     * 恢复默认字体 不加粗，不倾斜，没下划线，黑色，小四号字，宋体
     */
     public   void  clearFont() {
         this .setFont( false ,  false ,  false ,  "0,0,0" ,  "12" ,  "宋体" );
    }

     /**
     * 对当前段落进行格式化
     * 
     * @param align
     *            设置排列方式 默认：居左 0:居左 1:居中 2:居右 3:两端对齐 4:分散对齐
     * @param lineSpace
     *            设置行间距 默认：1.0 0：1.0 1：1.5 2：2.0 3：最小值 4：固定值
     */
     public   void  setParaFormat( int  align,  int  lineSpace) {
         if  (align <  0  || align >  4 ) {
            align =  0 ;
        }
         if  (lineSpace <  0  || lineSpace >  4 ) {
            lineSpace =  0 ;
        }

        Dispatch alignment = Dispatch.get(selection,  "ParagraphFormat" )
                .toDispatch();
        Dispatch.put(alignment,  "Alignment" , align);

        Dispatch.put(alignment,  "LineSpacingRule" ,  new  Variant(lineSpace));
    }

     /**
     * 还原段落默认的格式 左对齐,行间距：1.0
     */
     public   void  clearParaFormat() {
         this .setParaFormat( 0 ,  0 );
    }

     /**
     * 创建表格
     * 
     * @param pos
     *            位置
     * @param cols
     *            列数
     * @param rows
     *            行数
     */
     public   void  createTable(String pos,  int  numCols,  int  numRows) {
         if  (find(pos)) {
            Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
            Dispatch range = Dispatch.get(selection,  "Range" ).toDispatch();
            Dispatch newTable = Dispatch.call(tables,  "Add" , range,
                     new  Variant(numRows),  new  Variant(numCols)).toDispatch();
            Dispatch.call(selection,  "MoveRight" );
        }
    }

     /**
     * 在指定行前面增加行
     * 
     * @param tableIndex
     *            word文件中的第N张表(从1开始)
     * @param rowIndex
     *            指定行的序号(从1开始)
     */
     public   void  addTableRow( int  tableIndex,  int  rowIndex) {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch();
        Dispatch row = Dispatch.call(rows,  "Item" ,  new  Variant(rowIndex))
                .toDispatch();
        Dispatch.call(rows,  "Add" ,  new  Variant(row));
    }

     /**
     * 在第1行前增加一行
     * 
     * @param tableIndex
     *            word文档中的第N张表(从1开始)
     */
     public   void  addFirstTableRow( int  tableIndex) {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch();
        Dispatch row = Dispatch.get(rows,  "First" ).toDispatch();
        Dispatch.call(rows,  "Add" ,  new  Variant(row));
    }

     /**
     * 在最后1行前增加一行
     * 
     * @param tableIndex
     *            word文档中的第N张表(从1开始)
     */
     public   void  addLastTableRow( int  tableIndex) {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch();
        Dispatch row = Dispatch.get(rows,  "Last" ).toDispatch();
        Dispatch.call(rows,  "Add" ,  new  Variant(row));
    }

     /**
     * 增加一行
     * 
     * @param tableIndex
     *            word文档中的第N张表(从1开始)
     */
     public   void  addRow( int  tableIndex) {
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch rows = Dispatch.get(table,  "Rows" ).toDispatch();
        Dispatch.call(rows,  "Add" );
    }

     /**
     * 增加一列
     * 
     * @param tableIndex
     *            word文档中的第N张表(从1开始)
     */
     public   void  addCol( int  tableIndex) {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch();
        Dispatch.call(cols,  "Add" ).toDispatch();
        Dispatch.call(cols,  "AutoFit" );
    }

     /**
     * 在指定列前面增加表格的列
     * 
     * @param tableIndex
     *            word文档中的第N张表(从1开始)
     * @param colIndex
     *            制定列的序号 (从1开始)
     */
     public   void  addTableCol( int  tableIndex,  int  colIndex) {
         // 所有表格
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch();
        System.out.println(Dispatch.get(cols,  "Count" ));
        Dispatch col = Dispatch.call(cols,  "Item" ,  new  Variant(colIndex))
                .toDispatch();
         // Dispatch col = Dispatch.get(cols, "First").toDispatch();
        Dispatch.call(cols,  "Add" , col).toDispatch();
        Dispatch.call(cols,  "AutoFit" );
    }

     /**
     * 在第1列前增加一列
     * 
     * @param tableIndex
     *            word文档中的第N张表(从1开始)
     */
     public   void  addFirstTableCol( int  tableIndex) {
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch();
        Dispatch col = Dispatch.get(cols,  "First" ).toDispatch();
        Dispatch.call(cols,  "Add" , col).toDispatch();
        Dispatch.call(cols,  "AutoFit" );
    }

     /**
     * 在最后一列前增加一列
     * 
     * @param tableIndex
     *            word文档中的第N张表(从1开始)
     */
     public   void  addLastTableCol( int  tableIndex) {
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
         // 要填充的表格
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant(tableIndex))
                .toDispatch();
         // 表格的所有行
        Dispatch cols = Dispatch.get(table,  "Columns" ).toDispatch();
        Dispatch col = Dispatch.get(cols,  "Last" ).toDispatch();
        Dispatch.call(cols,  "Add" , col).toDispatch();
        Dispatch.call(cols,  "AutoFit" );
    }

     /**
     * 从选定内容或插入点开始查找文本
     * 
     * @param toFindText
     *            要查找的文本
     * @return boolean true-查找到并选中该文本，false-未查找到文本
     */
     public   boolean  find(String toFindText) {
         if  (toFindText ==  null  || toFindText.equals( "" ))
             return   false ;
         // 从selection所在位置开始查询
        Dispatch find = word.call(selection,  "Find" ).toDispatch();
         // 设置要查找的内容
        Dispatch.put(find,  "Text" , toFindText);
         // 向前查找
        Dispatch.put(find,  "Forward" ,  "True" );
         // 设置格式
        Dispatch.put(find,  "Format" ,  "True" );
         // 大小写匹配
        Dispatch.put(find,  "MatchCase" ,  "True" );
         // 全字匹配
        Dispatch.put(find,  "MatchWholeWord" ,  "True" );
         // 查找并选中
         return  Dispatch.call(find,  "Execute" ).getBoolean();
    }

     /**
     * 把选定选定内容设定为替换文本
     * 
     * @param toFindText
     *            查找字符串
     * @param newText
     *            要替换的内容
     * @return
     */
     public   boolean  replaceText(String toFindText, String newText) {
         if  (!find(toFindText))
             return   false ;
        Dispatch.put(selection,  "Text" , newText);
         return   true ;
    }
%E
/**
     * 全局替换文本
     * 
     * @param toFindText
     *            查找字符串
     * @param newText
     *            要替换的内容
     */
     public   void  replaceAllText(String toFindText, String newText) {
         while  (find(toFindText)) {
            Dispatch.put(selection,  "Text" , newText);
            Dispatch.call(selection,  "MoveRight" );
        }
    }

     /**
     * 
     * @param toFindText
     *            要查找的字符串
     * @param imagePath
     *            图片路径
     * @return 此函数将字符串替换成图片
     */
     public   boolean  replaceImage(String toFindText, String imagePath) {
         if  (!find(toFindText))
             return   false ;
        Dispatch.call(Dispatch.get(selection,  "InLineShapes" ).toDispatch(),
                 "AddPicture" , imagePath);
         return   true ;
    }

     /**
     * 全局替换图片
     * 
     * @param toFindText
     *            查找字符串
     * @param imagePath
     *            图片路径
     */
     public   void  replaceAllImage(String toFindText, String imagePath) {
         while  (find(toFindText)) {
            Dispatch.call(Dispatch.get(selection,  "InLineShapes" ).toDispatch(),
                     "AddPicture" , imagePath);
            Dispatch.call(selection,  "MoveRight" );
        }
    }

     // ////////////////////////////////////////////////////////
     // //////////////////////////////////////////////////////////
     // /////////////////////////////////////////////////////
     // ///////////////////////////////////////////////////
     // //////////////////////////////////////////////////

     /**
     * 设置当前表格线的粗细 w范围：1<w<13 超过范围设为：w=6
     * 
     * @param w
     */
     /*
     * private void setTableBorderWidth(int w) { if (w > 13 || w < 2) { w = 6; }
     * Dispatch borders = Dispatch.get(table, "Borders").toDispatch(); Dispatch
     * border = null;
     * 
     * /** 设置表格线的粗细 1：代表最上边一条线 2：代表最左边一条线 3：最下边一条线 4：最右边一条线 5：除最上边最下边之外的所有横线
     * 6：除最左边最右边之外的所有竖线 7：从左上角到右下角的斜线 8：从左下角到右上角的斜线
     */
     /*
     * for (int i = 1; i < 7; i++) { border = Dispatch.call(borders, "Item", new
     * Variant(i)) .toDispatch(); Dispatch.put(border, "LineWidth", new
     * Variant(w)); Dispatch.put(border, "Visible", new Variant(true)); } }
     * 
     * 
     * 
     * /** 复制表的最后一行到剪切板
     * 
     * @param tableIndex
     */
     /*
     * public void copyLastRow(int tableIndex) {
     * getRow(getRowsCount(tableIndex)); Dispatch.call(row, "select");
     * Dispatch.call(selection, "Copy"); }
     * 
     * /** 复制表的最后一行并粘贴到下一行（包括行中的数据）
     * 
     * @param tableIndex 表的索引 @param times 粘贴的次数
     */
     /*
     * public void duplicateLastRow(int tableIndex, int times) {
     * this.copyLastRow(tableIndex); for (int i = 0; i < times; i++) {
     * Dispatch.call(selection, "Paste"); } }
     * 
     * /** 查找当前行表格所有行中的某一行
     * 
     * @param rowIndex @return
     */
     public  Dispatch getRow( int  rowIndex) {
         if  (rows ==  null )
             this .getRows();
        row = Dispatch.invoke(rows,  "item" , Dispatch.Method,
                 new  Object[] {  new  Integer(rowIndex) },  new   int [ 1 ])
                .toDispatch();
         return  row;
    }

     public   int  getRowsCount() {
         if  (rows ==  null )
             this .getRows();
         return  Dispatch.get(rows,  "Count" ).getInt();
    }

     /**
     * 得到当前表格的所有的列
     * 
     * @return
     */
     // 需要找到Dispatch对象,这里的Variant(1)不行一定要做成变量
     public  Dispatch getColumns() {
         // this.getTables();
        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant( 1 ))
                .toDispatch();
         return   this .columns = Dispatch.get(table,  "Columns" ).toDispatch();
    }

     /**
     * 得到当前表格的某一列
     * 
     * @param index
     *            列索引
     * @return
     */
     public  Dispatch getColumn( int  columnIndex) {
         if  (columns ==  null )
             this .getColumns();
         return   this .column = Dispatch.call(columns,  "Item" ,
                 new  Variant(columnIndex)).toDispatch();
    }

     /**
     * 得到当前表格的列数
     * 
     * @return
     */
     public   int  getColumnsCount() {
         this .getColumns();

         return  Dispatch.get(columns,  "Count" ).toInt();
    }

     /**
     * 得到指定表格的列数
     * 
     * @param tableIndex
     * @return
     */
     public   int  getColumnsCount( int  tableIndex) {
         this .getTable(tableIndex);

         return   this .getColumnsCount();
    }

     /**
     * 得到表的行数
     * 
     * @param tableIndex
     * @return
     */
     public   int  getRowsCount( int  tableIndex) {
         this .getTable(tableIndex);
         return   this .getRowsCount();
    }

     /**
     * 设置当前表格的所有行的行高
     * 
     * @param rowHeight
     */
     public   void  setRowHeight( float  rowHeight) {
         if  (rowHeight >  0 ) {
             if  (rows ==  null )
                 this .getRows();
            Dispatch.put(rows,  "Height" ,  new  Variant(rowHeight));
        }
    }

     /**
     * 设置指定表格的所有行的行高
     * 
     * @param tableIndex
     * @param rowHeight
     */
     public   void  setRowHeight( int  tableIndex,  float  rowHeight) {
         this .getRows(tableIndex);

         this .setRowHeight(rowHeight);
    }

     /**
     * 设置当前表格指定行的行高
     * 
     * @param rowHeight
     * @param rowIndex
     */
     public   void  setRowHeight( float  rowHeight,  int  rowIndex) {
         if  (rowHeight >  0 ) {
             if  (rows ==  null  || row ==  null ) {
                 this .getRows();
                 this .getRow(rowIndex);
            }

            Dispatch.put(row,  "Height" ,  new  Variant(rowHeight));
        }
    }

     /**
     * 设置指定表格的指定行的行高
     * 
     * @param tableIndex
     * @param rowHeight
     * @param rowIndex
     */
     public   void  setRowHeight( int  tableIndex,  float  rowHeight,  int  rowIndex) {
         this .getTable(tableIndex);

         this .setRowHeight(rowHeight, rowIndex);
    }

     /**
     * 设置当前表格的所有列的列宽
     * 
     * @param columnWidth
     *            列宽 取值范围：10<columnWidth 默认值：120
     */
     public   void  setColumnWidth( float  columnWidth) {
         if  (columnWidth <  11 ) {
            columnWidth =  120 ;
        }
         if  (columns ==  null )
             this .getColumns();
        Dispatch.put(columns,  "Width" ,  new  Variant(columnWidth));

    }

     /**
     * 设置指定表格的所有列的列宽
     * 
     * @param tableIndex
     * @param columnWidth
     */
     public   void  setColumnWidth( int  tableIndex,  float  columnWidth) {
         this .getColumns(tableIndex);

         this .setColumnWidth(columnWidth);
    }

     /**
     * 得到指定表格的多有列
     * 
     * @param tableIndex
     * @return
     */
     public  Dispatch getColumns( int  tableIndex) {
        getTable(tableIndex);

         return   this .getColumns();
    }

     /**
     * 复制表的某一行
     * 
     * @param tableIndex
     * @param rowIndex
     */
     public   void  copyRow( int  tableIndex,  int  rowIndex) {
        getTable(tableIndex);
        getRows();
        row = getRow(rowIndex);
        Dispatch.call(row,  "Select" );
        Dispatch.call(selection,  "Copy" );
    }

     /**
     * 查找表的全部行
     * 
     * @param tableIndex
     * @return
     */
     public  Dispatch getRows( int  tableIndex) {
        getTable(tableIndex);

         return   this .getRows();
    }

     /**
     * 查找当前表的全部行
     * 
     * @return
     * 
     * 
     */
     // 需要找到Dispatch对象,这里的Variant(1)不行一定要做成变量
     public  Dispatch getRows() {

        Dispatch tables = Dispatch.get(doc,  "Tables" ).toDispatch();
        Dispatch table = Dispatch.call(tables,  "Item" ,  new  Variant( 2 ))
                .toDispatch();
        rows = Dispatch.get(table,  "rows" ).toDispatch();
         return  rows;
    }

     /**
     * 查找指定表格的单元格
     * 
     * @param tableIndex
     * @param cellRow
     * @param cellColumn
     * @return
     */
     public  Dispatch getCell( int  tableIndex,  int  cellRow,  int  cellColumn) {
        getTable(tableIndex);

         return  getCell(cellRow, cellColumn);
    }

     /**
     * 查找当前所在表的某单元格
     * 
     * @param cellRow
     * @param cellColumn
     * @return
     * @throws Dispatch
     *             object expected
     */
     public  Dispatch getCell( int  cellRow,  int  cellColumn) {

         return  cell = Dispatch.call(table,  "Cell" ,  new  Variant(cellRow),
                 new  Variant(cellColumn)).toDispatch();
    }

     /**
     * 保存文档并退出程序
     * 
     * @param fileName
     *            保存的文件名称
     * @param isSave
     *            是否保存修改
     * @throws Exception
     */

     /*
     * public void saveDocAndExit(File fileName, boolean isSave) throws
     * Exception { if (fileName != null) { if (!fileName.exists()) {
     * fileName.createNewFile(); } Dispatch wordBasic = (Dispatch)
     * Dispatch.call(word, "WordBasic").getDispatch();
     * Dispatch.invoke(wordBasic, "FileSaveAs", Dispatch.Method, new Object[] {
     * fileName.getPath(), new Variant(true), new Variant(false) }, new int[1]); }
     * 
     * Dispatch.call(document, "Close", new Variant(isSave));
     * Dispatch.call(word, "Quit");
     * 
     * word = null; documents = null; document = null; selection = null; }
     */
     /**
     * 合并当前表格指定的单元格 如果需要一次合并几个单元格只需要指出第一个单元格和最后一个单元格
     * 
     * @param fstCellRowIndex
     *            第一个单元格的行索引
     * @param fstCellColIndex
     *            第一个单元格的列索引
     * @param secCellRowIndex
     *            第二个单元格的行索引
     * @param secCellColIndex
     *            第二个单元格的列索引
     */
     public   void  mergeCell( int  fstCellRowIndex,  int  fstCellColIndex,
             int  secCellRowIndex,  int  secCellColIndex) {
        Dispatch fstCell = Dispatch.call(table,  "Cell" ,
                 new  Variant(fstCellRowIndex),  new  Variant(fstCellColIndex))
                .toDispatch();
        Dispatch secCell = Dispatch.call(table,  "Cell" ,
                 new  Variant(secCellRowIndex),  new  Variant(secCellColIndex))
                .toDispatch();
        Dispatch.call(fstCell,  "Merge" , secCell);
    }

     /**
     * 合并当前表格指定的列
     * 
     * @param columnIndex
     *            列索引
     */
     public   void  mergeColumn( int  columnIndex) {
         this .getColumn(columnIndex);

        Dispatch cells = Dispatch.get(column,  "Cells" ).toDispatch();

        Dispatch.call(cells,  "Merge" );
    }

     /**
     * 合并当前表格的指定的行
     * 
     * @param rowIndex
     */
     public   void  mergeRow( int  rowIndex) {
         this .getRow(rowIndex);

        Dispatch cells = Dispatch.get(row,  "Cells" ).toDispatch();

        Dispatch.call(cells,  "Merge" );
    }

     /**
     * 合并指定表格的指定的行
     * 
     * @param tableIndex
     * @param rowIndex
     *            行索引
     */
     public   void  mergeRow( int  tableIndex,  int  rowIndex) {
         this .getTable(tableIndex);

         this .mergeRow(rowIndex);
    }

     /**
     * 合并指定表格的指定的列
     * 
     * @param tableIndex
     * @param columnIndex
     */
     public   void  mergeColumn( int  tableIndex,  int  columnIndex) {
         this .getTable(tableIndex);

         this .mergeColumn(columnIndex);
    }

     /**
     * 合并指定表格的指定的单元格
     * 
     * @param tableIndex
     * @param fstCellRowIndex
     * @param fstCellColIndex
     * @param secCellRowIndex
     * @param secCellColIndex
     */
     public   void  mergeCell( int  tableIndex,  int  fstCellRowIndex,
             int  fstCellColIndex,  int  secCellRowIndex,  int  secCellColIndex) {
         this .getTable(tableIndex);

         this .mergeCell(fstCellRowIndex, fstCellColIndex, secCellRowIndex,
                secCellColIndex);
    }

     public  Dispatch getRangeParagraphs()  throws  Exception {
         return  Dispatch.get(range,  "Paragraphs" ).toDispatch();
    }

     public  Dispatch getParagraph( int  tIndex)  throws  Exception {

         return  Dispatch.call(paragraphs,  "Item" ,  new  Variant(tIndex))
                .toDispatch();
    }

     public  Dispatch getParagraphRange()  throws  Exception {

         return  Dispatch.get(paragraph,  "range" ).toDispatch();
    }

     public  String getRangeText()  throws  Exception {
         return  Dispatch.get(range,  "Text" ).toString();
    }

     public   int  getParagraphsCount()  throws  Exception {
         int  count =  0 ;

        count = Dispatch.get(paragraphs,  "Count" ).toInt();

         return  count;
    }

     public   static   void  main(String[] args) {
         long  time1 = System.currentTimeMillis();
         int  i =  0 ;
        ComThread.InitSTA(); // 初始化com的线程，非常重要！！使用结束后要调用 realease方法
         // Instantiate objWord //Declare word object
        ActiveXComponent objWord =  new  ActiveXComponent( "Word.Application" );
         // Assign a local word object
        Dispatch wordObject = (Dispatch) objWord.getObject();
         // Create a Dispatch Parameter to show the document that is opened
        Dispatch.put((Dispatch) wordObject,  "Visible" ,  new  Variant( true )); // new
                                                                             // Variant(true)表示word应用程序可见
         // Instantiate the Documents Property
        Dispatch documents = objWord.getProperty( "Documents" ).toDispatch();  // documents表示word的所有文档窗口，（word是多文档应用程序）
         // Add a new word document, Current Active Document
         // Dispatch document = Dispatch.call(documents, "Add").toDispatch(); //
         // 使用Add命令创建一个新文档，用Open命令可以打开一个现有文档

         for  ( int  n =  0 ; n <=  10 ; n++) {
            Dispatch document = Dispatch.call(documents,  "Open" ,  "C:\\ABC.doc" )
                    .toDispatch();
            Dispatch wordContent = Dispatch.get(document,  "Content" )
                    .toDispatch();  // 取得word文件的内容
            Dispatch.call(wordContent,  "InsertAfter" ,  "这里是一个段落的内容" ); // 插入一个段落
            Dispatch paragraphs = Dispatch.get(wordContent,  "Paragraphs" )
                    .toDispatch();  // 所有段落
             int  paragraphCount = Dispatch.get(paragraphs,  "Count" ).toInt();  // 一共的段落数
             // 找到刚输入的段落，设置格式
            Dispatch lastParagraph = Dispatch.call(paragraphs,  "Item" ,
                     new  Variant(paragraphCount)).toDispatch();  // 最后一段
            Dispatch lastParagraphRange = Dispatch.get(lastParagraph,  "Range" )
                    .toDispatch();
            Dispatch font = Dispatch.get(lastParagraphRange,  "Font" )
                    .toDispatch();
            Dispatch.put(font,  "Bold" ,  new  Variant( true ));  // 设置为黑体
            Dispatch.put(font,  "Italic" ,  new  Variant( true ));  // 设置为斜体
            Dispatch.put(font,  "Name" ,  new  Variant( "宋体" ));  //
            Dispatch.put(font,  "Size" ,  new  Variant( 18 ));  // 小四
            Dispatch frames = Dispatch.call(wordContent,  "Frames" ).toDispatch();
        
             int  frameCount = Dispatch.call(frames,  "Count" ).toInt();
            System.out.println( ""  + frameCount + n +  "\n" );

            Dispatch.call(document,  "SaveAs" ,  new  Variant( "C:\\" + (i++)+ " abc.doc"));  // 保存一个新文档

            Dispatch.call(document,  "Close" ,  new  Variant( true ));
        }
         //
         // end for
        Dispatch.call(objWord,  "Quit" );
        ComThread.Release(); // 释放com线程。根据jacob的帮助文档，com的线程回收不由java的垃圾回收器处理

         long  time2 = System.currentTimeMillis();
         double  time3 = (time2 - time1) /  1000.0 ;
        System.out.println( "\n"  + time3 +  " 秒." );

    }
}