Aspose.Words For .NET是一種高級(jí)Word文檔處理API，用于執(zhí)行各種文檔管理和操作任務(wù)。API支持生成，修改，轉(zhuǎn)換，呈現(xiàn)和打印文檔，而無(wú)需在跨平臺(tái)應(yīng)用程序中直接使用Microsoft Word。此外，API支持所有流行的Word處理文件格式，并允許將Word文檔導(dǎo)出或轉(zhuǎn)換為固定布局文件格式和最常用的圖像/多媒體格式。本文介紹了如何用Java從Word文檔中提取文本

從 Word 文檔中提取文本通常在不同的場(chǎng)景中執(zhí)行。例如，分析文本，提取文檔的特定部分并將它們組合成單個(gè)文檔，等等。在本文中，您將學(xué)習(xí)如何在 Java 中以編程方式從 Word 文檔中提取文本。此外，我們將介紹如何動(dòng)態(tài)提取段落、表格等特定元素之間的內(nèi)容。

Aspose.Words 最新下載

獲取從 Word 文檔中提取文本的 Java 庫(kù)

Aspose.Words for Java 是一個(gè)功能強(qiáng)大的庫(kù)，可讓您從頭開(kāi)始創(chuàng)建 MS Word 文檔。此外，它可以讓您操作現(xiàn)有的 Word 文檔進(jìn)行加密、轉(zhuǎn)換、文本提取等。我們將使用這個(gè)庫(kù)從 Word DOCX 或 DOC 文檔中提取文本。您可以下載API 的 JAR 或使用以下 Maven 配置安裝它。

<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>//repository.aspose.com/repo/</url>
</repository>
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-words</artifactId>
<version>22.6</version>
<type>pom</type>
</dependency>

在Java 中提取 Word DOC/DOCX 中的文本

MS Word 文檔由各種元素組成，包括段落、表格、圖像等。因此，文本提取的要求可能因場(chǎng)景而異。例如，您可能需要在段落、書(shū)簽、評(píng)論等之間提取文本。

Word DOC/DOCX 中的每種元素都表示為一個(gè)節(jié)點(diǎn)。因此，要處理文檔，您將不得不使用節(jié)點(diǎn)。那么讓我們開(kāi)始看看如何在不同的場(chǎng)景下從 Word 文檔中提取文本。

在 Java 中提取 Word DOC 中的文本

在本節(jié)中，我們將為 Word 文檔實(shí)現(xiàn)一個(gè) Java 文本提取器，文本提取的工作流程如下：

• 首先，我們將定義要包含在文本提取過(guò)程中的節(jié)點(diǎn)。
• 然后，我們將提取指定節(jié)點(diǎn)之間的內(nèi)容（包括或不包括開(kāi)始和結(jié)束節(jié)點(diǎn)）。
• 最后，我們將使用提取節(jié)點(diǎn)的克隆，例如創(chuàng)建一個(gè)包含提取內(nèi)容的新 Word 文檔。

現(xiàn)在讓我們編寫(xiě)一個(gè)名為extractContent的方法，我們將向該方法傳遞節(jié)點(diǎn)和一些其他參數(shù)來(lái)執(zhí)行文本提取。此方法將解析文檔并克隆節(jié)點(diǎn)。以下是我們將傳遞給此方法的參數(shù)。

1. startNode和endNode 分別作為內(nèi)容提取的起點(diǎn)和終點(diǎn)。這些可以是塊級(jí)（Paragraph、Table）或內(nèi)聯(lián)級(jí)（例如Run、FieldStart、BookmarkStart等）節(jié)點(diǎn)。
   1. 要傳遞一個(gè)字段，您應(yīng)該傳遞相應(yīng)的FieldStart對(duì)象。
   2. 要傳遞書(shū)簽，應(yīng)傳遞BookmarkStart和BookmarkEnd節(jié)點(diǎn)。
   3. 對(duì)于評(píng)論，應(yīng)使用CommentRangeStart和CommentRangeEnd節(jié)點(diǎn)。
2. isInclusive定義標(biāo)記是否包含在提取中。如果此選項(xiàng)設(shè)置為 false 并且傳遞相同的節(jié)點(diǎn)或連續(xù)節(jié)點(diǎn)，則將返回一個(gè)空列表。

以下是提取傳遞的節(jié)點(diǎn)之間的內(nèi)容的extractContent方法的完整實(shí)現(xiàn)。

// For complete examples and data files, please go to //github.com/aspose-words/Aspose.Words-for-Java
public static ArrayList extractContent(Node startNode, Node endNode, boolean isInclusive) throws Exception {
// First check that the nodes passed to this method are valid for use.
verifyParameterNodes(startNode, endNode);

// Create a list to store the extracted nodes.
ArrayList nodes = new ArrayList();

// Keep a record of the original nodes passed to this method so we can split marker nodes if needed.
Node originalStartNode = startNode;
Node originalEndNode = endNode;

// Extract content based on block level nodes (paragraphs and tables). Traverse through parent nodes to find them.
// We will split the content of first and last nodes depending if the marker nodes are inline
while (startNode.getParentNode().getNodeType() != NodeType.BODY)
startNode = startNode.getParentNode();

while (endNode.getParentNode().getNodeType() != NodeType.BODY)
endNode = endNode.getParentNode();

boolean isExtracting = true;
boolean isStartingNode = true;
boolean isEndingNode;
// The current node we are extracting from the document.
Node currNode = startNode;

// Begin extracting content. Process all block level nodes and specifically split the first and last nodes when needed so paragraph formatting is retained.
// Method is little more complex than a regular extractor as we need to factor in extracting using inline nodes, fields, bookmarks etc as to make it really useful.
while (isExtracting) {
// Clone the current node and its children to obtain a copy.
/*System.out.println(currNode.getNodeType());
if(currNode.getNodeType() == NodeType.EDITABLE_RANGE_START
|| currNode.getNodeType() == NodeType.EDITABLE_RANGE_END)
{
currNode = currNode.nextPreOrder(currNode.getDocument());
}*/
System.out.println(currNode);
System.out.println(endNode);

CompositeNode cloneNode = null;
///cloneNode = (CompositeNode) currNode.deepClone(true);

Node inlineNode = null;
if(currNode.isComposite())
{
cloneNode = (CompositeNode) currNode.deepClone(true);
}
else
{
if(currNode.getNodeType() == NodeType.BOOKMARK_END)
{
Paragraph paragraph = new Paragraph(currNode.getDocument());
paragraph.getChildNodes().add(currNode.deepClone(true));
cloneNode = (CompositeNode)paragraph.deepClone(true);
}
}

isEndingNode = currNode.equals(endNode);

if (isStartingNode || isEndingNode) {
// We need to process each marker separately so pass it off to a separate method instead.
if (isStartingNode) {
processMarker(cloneNode, nodes, originalStartNode, isInclusive, isStartingNode, isEndingNode);
isStartingNode = false;
}

// Conditional needs to be separate as the block level start and end markers maybe the same node.
if (isEndingNode) {
processMarker(cloneNode, nodes, originalEndNode, isInclusive, isStartingNode, isEndingNode);
isExtracting = false;
}
} else
// Node is not a start or end marker, simply add the copy to the list.
nodes.add(cloneNode);

// Move to the next node and extract it. If next node is null that means the rest of the content is found in a different section.
if (currNode.getNextSibling() == null && isExtracting) {
// Move to the next section.
Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
currNode = nextSection.getBody().getFirstChild();
} else {
// Move to the next node in the body.
currNode = currNode.getNextSibling();
}
}

// Return the nodes between the node markers.
return nodes;
}

extractContent方法還需要一些輔助方法來(lái)完成文本提取操作，如下所示。

/**
* Checks the input parameters are correct and can be used. Throws an exception
* if there is any problem.
*/
private static void verifyParameterNodes(Node startNode, Node endNode) throws Exception {
// The order in which these checks are done is important.
if (startNode == null)
throw new IllegalArgumentException("Start node cannot be null");
if (endNode == null)
throw new IllegalArgumentException("End node cannot be null");

if (!startNode.getDocument().equals(endNode.getDocument()))
throw new IllegalArgumentException("Start node and end node must belong to the same document");

if (startNode.getAncestor(NodeType.BODY) == null || endNode.getAncestor(NodeType.BODY) == null)
throw new IllegalArgumentException("Start node and end node must be a child or descendant of a body");

// Check the end node is after the start node in the DOM tree
// First check if they are in different sections, then if they're not check
// their position in the body of the same section they are in.
Section startSection = (Section) startNode.getAncestor(NodeType.SECTION);
Section endSection = (Section) endNode.getAncestor(NodeType.SECTION);

int startIndex = startSection.getParentNode().indexOf(startSection);
int endIndex = endSection.getParentNode().indexOf(endSection);

if (startIndex == endIndex) {
if (startSection.getBody().indexOf(startNode) > endSection.getBody().indexOf(endNode))
throw new IllegalArgumentException("The end node must be after the start node in the body");
} else if (startIndex > endIndex)
throw new IllegalArgumentException("The section of end node must be after the section start node");
}

/**
* Checks if a node passed is an inline node.
*/
private static boolean isInline(Node node) throws Exception {
// Test if the node is desendant of a Paragraph or Table node and also is not a
// paragraph or a table a paragraph inside a comment class which is decesant of
// a pararaph is possible.
return ((node.getAncestor(NodeType.PARAGRAPH) != null || node.getAncestor(NodeType.TABLE) != null)
&& !(node.getNodeType() == NodeType.PARAGRAPH || node.getNodeType() == NodeType.TABLE));
}

/**
* Removes the content before or after the marker in the cloned node depending
* on the type of marker.
*/
private static void processMarker(CompositeNode cloneNode, ArrayList nodes, Node node, boolean isInclusive,
boolean isStartMarker, boolean isEndMarker) throws Exception {
// If we are dealing with a block level node just see if it should be included
// and add it to the list.
if (!isInline(node)) {
// Don't add the node twice if the markers are the same node
if (!(isStartMarker && isEndMarker)) {
if (isInclusive)
nodes.add(cloneNode);
}
return;
}

// If a marker is a FieldStart node check if it's to be included or not.
// We assume for simplicity that the FieldStart and FieldEnd appear in the same
// paragraph.
if (node.getNodeType() == NodeType.FIELD_START) {
// If the marker is a start node and is not be included then skip to the end of
// the field.
// If the marker is an end node and it is to be included then move to the end
// field so the field will not be removed.
if ((isStartMarker && !isInclusive) || (!isStartMarker && isInclusive)) {
while (node.getNextSibling() != null && node.getNodeType() != NodeType.FIELD_END)
node = node.getNextSibling();

}
}

// If either marker is part of a comment then to include the comment itself we
// need to move the pointer forward to the Comment
// node found after the CommentRangeEnd node.
if (node.getNodeType() == NodeType.COMMENT_RANGE_END) {
while (node.getNextSibling() != null && node.getNodeType() != NodeType.COMMENT)
node = node.getNextSibling();

}

// Find the corresponding node in our cloned node by index and return it.
// If the start and end node are the same some child nodes might already have
// been removed. Subtract the
// difference to get the right index.
int indexDiff = node.getParentNode().getChildNodes().getCount() - cloneNode.getChildNodes().getCount();

// Child node count identical.
if (indexDiff == 0)
node = cloneNode.getChildNodes().get(node.getParentNode().indexOf(node));
else
node = cloneNode.getChildNodes().get(node.getParentNode().indexOf(node) - indexDiff);

// Remove the nodes up to/from the marker.
boolean isSkip;
boolean isProcessing = true;
boolean isRemoving = isStartMarker;
Node nextNode = cloneNode.getFirstChild();

while (isProcessing && nextNode != null) {
Node currentNode = nextNode;
isSkip = false;

if (currentNode.equals(node)) {
if (isStartMarker) {
isProcessing = false;
if (isInclusive)
isRemoving = false;
} else {
isRemoving = true;
if (isInclusive)
isSkip = true;
}
}

nextNode = nextNode.getNextSibling();
if (isRemoving && !isSkip)
currentNode.remove();
}

// After processing the composite node may become empty. If it has don't include
// it.
if (!(isStartMarker && isEndMarker)) {
if (cloneNode.hasChildNodes())
nodes.add(cloneNode);
}
}

public static Document generateDocument(Document srcDoc, ArrayList nodes) throws Exception {

// Create a blank document.
Document dstDoc = new Document();
// Remove the first paragraph from the empty document.
dstDoc.getFirstSection().getBody().removeAllChildren();

// Import each node from the list into the new document. Keep the original
// formatting of the node.
NodeImporter importer = new NodeImporter(srcDoc, dstDoc, ImportFormatMode.KEEP_SOURCE_FORMATTING);

for (Node node : (Iterable<Node>) nodes) {
Node importNode = importer.importNode(node, true);
dstDoc.getFirstSection().getBody().appendChild(importNode);
}

// Return the generated document.
return dstDoc;
}

現(xiàn)在我們準(zhǔn)備好使用這些方法并從 Word 文檔中提取文本。

在Java 提取 Word DOC 中段落之間的文本

讓我們看看如何在 Word DOCX 文檔的兩個(gè)段落之間提取內(nèi)容。以下是在 Java 中執(zhí)行此操作的步驟。

• 首先，使用Document類(lèi)加載 Word 文檔。
• 使用Document.getFirstSection().getChild(NodeType.PARAGRAPH, int, bool)方法將開(kāi)始和結(jié)束段落的引用獲取到兩個(gè)對(duì)象中。
• 調(diào)用extractContent(startPara, endPara, true)方法將節(jié)點(diǎn)提取到對(duì)象中。
• 調(diào)用generateDocument(Document, extractNodes)輔助方法來(lái)創(chuàng)建包含提取內(nèi)容的文檔。
• 最后，使用Document.save(String)方法保存返回的文檔。

以下代碼示例展示了如何在 Java 的 Word DOCX 中提取第 7 段和第 11 段之間的文本。

// Load document
Document doc = new Document("TestFile.doc");

// Gather the nodes. The GetChild method uses 0-based index
Paragraph startPara = (Paragraph) doc.getFirstSection().getChild(NodeType.PARAGRAPH, 6, true);
Paragraph endPara = (Paragraph) doc.getFirstSection().getChild(NodeType.PARAGRAPH, 10, true);
// Extract the content between these nodes in the document. Include these
// markers in the extraction.
ArrayList extractedNodes = extractContent(startPara, endPara, true);

// Insert the content into a new separate document and save it to disk.
Document dstDoc = generateDocument(doc, extractedNodes);
dstDoc.save("output.doc");

在Java 中提取 DOC 中文本 - 在不同類(lèi)型的節(jié)點(diǎn)之間

您還可以在不同類(lèi)型的節(jié)點(diǎn)之間提取內(nèi)容。為了演示，讓我們提取段落和表格之間的內(nèi)容并將其保存到新的 Word 文檔中。以下是在 Java 中提取 Word 文檔中不同節(jié)點(diǎn)之間的文本的步驟。

• 使用Document類(lèi)加載 Word 文檔。
• 使用Document.getFirstSection().getChild(NodeType, int, bool)方法將起始節(jié)點(diǎn)和結(jié)束節(jié)點(diǎn)引用到兩個(gè)對(duì)象中。
• 調(diào)用extractContent(startPara, endPara, true)方法將節(jié)點(diǎn)提取到對(duì)象中。
• 調(diào)用generateDocument(Document, extractNodes)輔助方法來(lái)創(chuàng)建包含提取內(nèi)容的文檔。
• 使用Document.save(String)方法保存返回的文檔。

以下代碼示例展示了如何使用 Java 在 DOCX 中提取段落和表格之間的文本。

// Load documents
Document doc = new Document("TestFile.doc");

// Get reference of starting paragraph
Paragraph startPara = (Paragraph) doc.getLastSection().getChild(NodeType.PARAGRAPH, 2, true);
Table endTable = (Table) doc.getLastSection().getChild(NodeType.TABLE, 0, true);

// Extract the content between these nodes in the document. Include these markers in the extraction.
ArrayList extractedNodes = extractContent(startPara, endTable, true);

// Lets reverse the array to make inserting the content back into the document easier.
Collections.reverse(extractedNodes);

while (extractedNodes.size() > 0) {
// Insert the last node from the reversed list
endTable.getParentNode().insertAfter((Node) extractedNodes.get(0), endTable);
// Remove this node from the list after insertion.
extractedNodes.remove(0);
}

// Save the generated document to disk.
doc.save("output.doc");

在Java 中提取 DOCX 中文本 - 基于樣式的段落之間

現(xiàn)在讓我們看看如何根據(jù)樣式提取段落之間的內(nèi)容。為了演示，我們將提取 Word 文檔中第一個(gè)“標(biāo)題 1”和第一個(gè)“標(biāo)題 3”之間的內(nèi)容。以下步驟演示了如何在 Java 中實(shí)現(xiàn)此目的。

• 首先，使用Document類(lèi)加載 Word 文檔。
• 然后，使用paragraphsByStyleName(Document, “Heading 1”)輔助方法將段落提取到一個(gè)對(duì)象中。
• 使用paragraphsByStyleName(Document, “Heading 3”)輔助方法將段落提取到另一個(gè)對(duì)象中。
• 調(diào)用extractContent(startPara, endPara, true)方法并將兩個(gè)段落數(shù)組中的第一個(gè)元素作為第一個(gè)和第二個(gè)參數(shù)傳遞。
• 調(diào)用generateDocument(Document, extractNodes)輔助方法來(lái)創(chuàng)建包含提取內(nèi)容的文檔。
• 最后，使用Document.save(String)方法保存返回的文檔。

以下代碼示例展示了如何根據(jù)樣式提取段落之間的內(nèi)容。

// Load document
Document doc = new Document(dataDir + "TestFile.doc");

// Gather a list of the paragraphs using the respective heading styles.
ArrayList parasStyleHeading1 = paragraphsByStyleName(doc, "Heading 1");
ArrayList parasStyleHeading3 = paragraphsByStyleName(doc, "Heading 3");

// Use the first instance of the paragraphs with those styles.
Node startPara1 = (Node) parasStyleHeading1.get(0);
Node endPara1 = (Node) parasStyleHeading3.get(0);

// Extract the content between these nodes in the document. Don't include these markers in the extraction.
ArrayList extractedNodes = extractContent(startPara1, endPara1, false);

// Insert the content into a new separate document and save it to disk.
Document dstDoc = generateDocument(doc, extractedNodes);
dstDoc.save("output.doc");

以上便是如何用Java從Word文檔中提取文本 ，要是您還有其他關(guān)于產(chǎn)品方面的問(wèn)題，歡迎咨詢(xún)我們，或者加入我們官方技術(shù)交流群。

歡迎下載|體驗(yàn)更多Aspose產(chǎn)品