工作中常要填写各种word表格，其中内容有很多是重复的。于是想做一个工具，输入word文件所对应的xml格式文件，自动填写表格。

word其实可以转化成xml来处理，这一步可以手工用word把.doc格式文件另存为.xml格式。word的表格中，每一行对应一个<w:tr>标签；每一个格子对应一个<w:tc>标签；格子中每行的内容，对应一个<w:t>标签。

对于xml的处理，可以用dom4j来处理。主要思路为：

1.将所要自动填写的内容，按key  -- value的格式，写进一个properties文件中。并通过程序将文件内容取出，放入到entityList当中。

2.从xml根节点开始，遍历所有节点。若当前为w:tc节点，则获取该节点下所有w:t的内容，与所有entityList中所有key值对比。若有匹配，则在下一个w:tc格子中，新加一个w:t把该key值对应的value填入该表格中。

3.生成新的xml格式文件

 

所有代码如下：

1.xml处理相关函数：

package com.XML.test;

import java.io.File;  
import java.io.FileOutputStream;  
import java.io.FileWriter;  
import java.io.OutputStreamWriter;  
import java.nio.charset.Charset;  
import java.nio.charset.CharsetEncoder;  
import java.util.ArrayList;
import java.util.Iterator;  
import java.util.List;  

import javax.xml.soap.Node;
  
import org.dom4j.Attribute;  
import org.dom4j.Document;  
import org.dom4j.Element;  
import org.dom4j.io.OutputFormat;  
import org.dom4j.io.SAXReader;  
import org.dom4j.io.XMLWriter;  
import org.junit.Test;  
  
public class Demo01 {  
  
    @Test  
    public void test() throws Exception {  
  
        // 创建saxReader对象  
        SAXReader reader = new SAXReader();  
        // 通过read方法读取一个文件 转换成Document对象  
        Document document = reader.read(new File("./src/倪锐个人简历表格.xml"));  
        //获取根节点元素对象  
        Element node = document.getRootElement();  
        //遍历所有的元素节点
        
        List<Entity> entityList= GetPro.GetEntityList();
        int i=0;
        for(Entity a:entityList){
        	System.out.println("Entity" +i +a.getKey()+" "+a.getValue()); 
        	i++;
        }
        listNodes(node,entityList);  
  
        
        // 写入到一个新的文件中  
        writer(document);  
  
    }  
  
    /** 
     * 把document对象写入新的文件 
     *  
     * @param document 
     * @throws Exception 
     */  
    public void writer(Document document) throws Exception {  
        // 紧凑的格式  
        // OutputFormat format = OutputFormat.createCompactFormat();  
        // 排版缩进的格式  
        OutputFormat format = OutputFormat.createPrettyPrint();  
        // 设置编码  
        format.setEncoding("UTF-8");  
        // 创建XMLWriter对象,指定了写出文件及编码格式  
        // XMLWriter writer = new XMLWriter(new FileWriter(new  
        // File("src//a.xml")),format);  
        XMLWriter writer = new XMLWriter(new OutputStreamWriter(  
                new FileOutputStream(new File("src//a.xml")), "UTF-8"), format);  
        // 写入  
        writer.write(document);  
        // 立即写入  
        writer.flush();  
        // 关闭操作  
        writer.close();  
    }  
  
    /** 
     * 遍历当前节点元素下面的所有(元素的)子节点 
     *  
     * @param node 
     */  
    public void listNodes(Element node,List<Entity>  fillList) {  
        System.out.println("当前节点的名称：：" + node.getName());  
        // 获取当前节点的所有属性节点  
        List<Attribute> list = node.attributes();  
        // 遍历属性节点  
        for (Attribute attr : list) {  
            System.out.println(attr.getText() + "-----" + attr.getName()  
                    + "---" + attr.getValue());  
        }  
         
       if (!(node.getTextTrim().equals(""))) {  
    	   System.out.println("文本内容：：：：" + node.getText()); 
       }
        if (node.getName().equals("tc")){
        	System.out.println("----------------enter tc------------------");
        	for(Entity ent:fillList){
        		rightFil(node,ent.getKey(),ent.getValue());
        	}        	
        }
        // 当前节点下面子节点迭代器  
        Iterator<Element> it = node.elementIterator();  
        // 遍历  
        while (it.hasNext()) {  
            // 获取某个子节点对象  
            Element e = it.next();  
            // 对子节点进行遍历  
            listNodes(e,fillList);  
        }  
    }  

    //node is where you find key value
    public String merge(Element node,String tag,String ini){
    	StringBuffer strMerg=new StringBuffer(ini);
    	Iterator<Element> it = node.elementIterator();  
    	if(node.getName().equals(tag)){
            strMerg.append(node.getText());
//            System.out.println("for strMerg-----" + strMerg);
//            System.out.println("for node.getText()=" + node.getText());
    	}
        while (it.hasNext()) {  
            // 获取某个子节点对象  
            Element e = it.next();  
            // 对子节点进行遍历  
            strMerg=new StringBuffer(merge(e,tag,strMerg.toString())); 
            
        }
//        System.err.println("strMerg=" + strMerg);

    	return strMerg.toString().replace(" ", "");
    }
    public String mergebackup(Element node,String tag){
    	try{
    		List<Element> sibList=node.elements("p");
            System.err.println("size=-----" + sibList.size());

    		
        	StringBuffer strMerg=new StringBuffer("");
        	int i=0;
            for (Element elm : sibList) {  
                System.out.println("sibList-----" + elm.element("r").element("t").getText());
                strMerg.append(elm.element("r").element("t").getText());
                System.out.println("for strMerg =" + strMerg);
                i++;
                System.err.println("i======" + i);
            }
//            System.out.println("strMerg-----" + strMerg);
            
            System.out.println("strMerg del blanks-----" + strMerg.toString().replace(" ", ""));
            return strMerg.toString().replace(" ", "");
    	}catch(NullPointerException e){
    		System.out.println("merge: no t in this tc -----" );
    		return "";
    	}


    }
    public void rightFil(Element node,String key,String value){//node 为tc级别，合并所有t标签
    	String strMerg=merge(node,"t","");
    	if(strMerg.equals(key)&&strMerg.length()>0){
        	System.out.println("***********************"+key+"found");
        	System.out.println(node.getName());

        	//int j=node.indexOf(node.getParent());
        	Element father=node;//self tc tag
        	System.out.println(father.getName());
       	
        	Element sib=(Element) father.selectSingleNode("following-sibling::w:tc[1]");//next tc tag
        	if(sib!= null){
        		insertT(sib,value);
        	}
        	else{
        		
        	}
        }
    }
    
    public void rightFilBackup(Element node,String key,String value){//node 为t级别，不能合并所有t标签
    	if(node.getText().replace(" ", "").equals(key)){
        	System.out.println("***********************"+key+"found");
        	System.out.println(node.getName());

        	//int j=node.indexOf(node.getParent());
        	Element father=(Element) node.getParent().getParent().getParent();//self tc tag
        	System.out.println(father.getName());
       	
        	Element sib=(Element) father.selectSingleNode("following-sibling::w:tc[1]");//next tc tag
        	insertT(sib,value);
        	
        }
    }   
    public void insertT(Element tc,String value){
        
        List<Attribute> list = tc.attributes();  
        // 遍历属性节点  
        for (Attribute attr : list) {  
            System.out.println(attr.getText() + "-----" + attr.getName()  
                    + "---" + attr.getValue());  
        } 
 
        System.out.println("tc.attribute(\"id\")========");
        System.out.println(tc.attribute("id"));  
 

    	Element adE=tc.element("p");
    	System.out.println("adEtest++++++++++++====="+adE.getName());               
    	System.out.println("adEtest++++++++++++=====END"+adE.getName());  
    	Element r=adE.addElement("w:r");            	
    	Element rPr=r.addElement("w:rPr");
    	rPr.addElement("w:rFonts hint=\"eastAsia\"");
    	rPr.addElement("w:sz val=\"24\"");
    	Element t=r.addElement("w:t");
    	t.setText(value);
    }
    
    /** 
     * 介绍Element中的element方法和elements方法的使用 
     *  
     * @param node 
     */  
    public void elementMethod(Element node) {  
        // 获取node节点中，子节点的元素名称为西游记的元素节点。  
        Element e = node.element("西游记");  
        // 获取西游记元素节点中，子节点为作者的元素节点(可以看到只能获取第一个作者元素节点)  
        Element author = e.element("作者");  
  
        System.out.println(e.getName() + "----" + author.getText());  
  
        // 获取西游记这个元素节点 中，所有子节点名称为作者元素的节点 。  
  
        List<Element> authors = e.elements("作者");  
        for (Element aut : authors) {  
            System.out.println(aut.getText());  
        }  
  
        // 获取西游记这个元素节点 所有元素的子节点。  
        List<Element> elements = e.elements();  
  
        for (Element el : elements) {  
            System.out.println(el.getText());  
        }  
  
    }  
  
}  


2.自动填写格式设定：（key姓名--value张三） 

package com.XML.test;

public class Entity {
	String key;
	String value;

	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

}

3.从properties文件读出到entityList程序 

package com.XML.test;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;

import org.dom4j.DocumentException;

//关于Properties类常用的操作
public class GetPro {

  
  //读取Properties的全部信息
  public static List GetEntityList() throws IOException {
	  List<Entity> entityList= new ArrayList();
      Properties pps = new Properties();
      InputStream in = new BufferedInputStream(new FileInputStream("./src/com/XML/test/properties"));
      pps.load(new InputStreamReader( in, "utf-8"));
      Enumeration en = pps.propertyNames(); //得到配置文件的名字
      
      while(en.hasMoreElements()) {
          String strKey = (String) en.nextElement();
          String strValue = pps.getProperty(strKey);
          Entity entity =new Entity();
          entity.setKey(strKey);
          entity.setValue(strValue);
          entityList.add(entity);
          System.out.println(strKey + "=" + strValue);
          
          
      }
	return entityList;
      
  }
  public static void main(String[] args) throws DocumentException,
  IOException {
   Entity entity_1 =new Entity();
    List<Entity> entityList_1=GetEntityList();
    for(int i=0;i<entityList_1.size();i++){
     entity_1=entityList_1.get(i);
     System.out.println(entity_1.getKey() + "=" + entity_1.getValue());
    } 
   
  }

  }


4.propeties文件 

#Update long name
#Sat Sep 22 00:57:39 CST 2018
姓名=牛逼
性别=女
出身年月=1987年7月
身份证号码=518209387428982347
民族=汗
政治面貌=中共党员
婚姻状况=已婚
健康状况=良好
身高=175
现户口所在地=北京
所学专业=英语
学历=本科
最后毕业学校=清华大学
毕业时间=2017年8月
技术职称=高级工程师
现工作单位=百度
参加工作时间=2017年10月
现从事专业=搬砖


 

    在MS WORD中，当有大量的表格出现时，调整每个表格的的高和宽和大小将是一件非常累的事情，拖来拖去，非常耗时间，而且当WORD文档达到300页以上时，调整反应非常的慢，每次拖拉线后，需要等待一段时间其才完成调整，劳心劳力。
    其实解决这个问题有一个很好的办法，MS WORD做的这个功能确实不错，有一定的智能性。这个功能就是表格的自动调整功能。表格的自动调整功能有根据内容调整表格和根据窗口调整表格。
一、表格根据内容自动调整

1、根据内容调整表格
    主要利器之一，当表格比较凌乱，内容较少时，用它可以起到立即美化的作用，其会合理调整列宽，使包含英文字母或数字的项尽可能显示在一行，而不是折行，对于内容比较少的列会自动压缩其所占空间。使用后表格内容分布会变得比较匀称，几乎不需要再行调整，或只需简单的微调即可达到理想的效果。
2、根据窗口调整表格
    当表格所占内容较多，当前表格又比较小时可用，它能充分利用页面的宽度。或者当需要表格内容显示不要过于拥挤，让表格显得更加清爽，也可以用到它。

二、使用快捷键调整表格
    当文档中出现数十个或数百个表格时，先要移动到要编辑表格上，再接着点每个表格的右键，然后移动到“自动调整”菜单，然后移动到根据内容/窗口调整表格菜单，最后点击执行调整，就会显得非常的耗时间了，能不能用快捷来实现一键调整呢。
针对根据内容(或窗口）调整表格的功能，可以通过对功能autoFitContent（或autoFitWindow）设置快捷键来解决，步骤:
1、先在MS WORD 工具栏空白处点右键，在弹出菜单中选择“自定义功能区”。
2、在自定义功能区中，在窗口下方找到键盘快捷方式-自定义按钮并点击。
3、在弹出窗口左侧框中找到类别：“表格工具|布局选项卡”，点击。
4、在右侧框中找到命令：AutoFitContent(或AutoFitWindow)。
5、点击请按快捷键输入框，输入快捷键，例如：Ctrl+F。
6、保存，点“指定”按钮。
    做完以上步骤后，再在WORD中点选表格，按快捷键：Ctrl+F，你就发现表格瞬间调整完毕。

    这一招适合经常写文档的朋友。

设置word2016表格随字体大小变化自动调整行高度
方法
结果

方法
具体操作步骤如下图：


结果
字体为10.5时，表格高度如下图：



将字体改为6时，表格高度如下图：

工作中经常会遇到word表格换页的情况，而经常是需要有续前表的要求的，如果是不经常改动或比较简单的表，可以在整片文档内容及格式调整完成后，从头到尾依次通过以下两种比较“笨“”的办法实现：


	
在分页后表格中第一行填写相应内容，并设置边框为透明
	
	

	
通过ctrl+shift+enter拆分表格后，在后一页表格填写相应“续表”内容
	
以上两种办法的弊端在于，只要表格调整或表格前后调整都需要重新设置，比较繁琐。

所以下面介绍一种还算比较灵活的办法：通过页眉来实现

1. 设置重复标题行

选中表格标题行，在“布局”选择重复标题行
	
这样，会看到分页后的表格依然有标题行
 

2. 在表格首页和尾页分别插入类型为“连续”的“分节符”

将光标定位后，选择“页面布局”-->“分隔符”-->“连续分节符”，分节后，作为单独的一部分不会影响其他页页眉页脚的内容
	
如果要看到分节符，可以通过查看草稿或者在选项中的显示中设置为“显示所有格式标记”
3.插入或编辑页眉

双击要添加续表页的页眉，取消“链接到上一节页眉” 
	
插入文本框，并输入内容，调整位置，设置文本框格式为“悬浮于文字上方”，如果影响到页边距，尤其是上边距，则再调整下上边距即可
4. 结束语：

              优点：这样设置后，再新增或删除部分列表内容后，不需要重复调整。

              缺点：删除内容很多后，需要撤销续表的页眉