แยกข้อความจากเอกสาร Word ใน Java

การแยกข้อความจากเอกสาร Word มักดำเนินการในสถานการณ์ต่างๆ ตัวอย่างเช่น เพื่อวิเคราะห์ข้อความ เพื่อแยกส่วนเฉพาะของเอกสารและรวมเข้าด้วยกันเป็นเอกสารเดียว เป็นต้น ในบทความนี้ คุณจะได้เรียนรู้วิธีการแยกข้อความจากเอกสาร Word โดยทางโปรแกรมใน Java นอกจากนี้ เราจะกล่าวถึงวิธีการแยกเนื้อหาระหว่างองค์ประกอบเฉพาะ เช่น ย่อหน้า ตาราง ฯลฯ แบบไดนามิก

• Java Library เพื่อแยกข้อความจาก Word DOC DOCX
• Java Text Extraction ในเอกสาร Word
• แยกข้อความจากเอกสาร Word ใน Java
  • แยกข้อความระหว่างย่อหน้า
  • การสกัดข้อความระหว่างโหนดประเภทต่างๆ
  • แยกข้อความระหว่างย่อหน้าตามสไตล์

Java Library เพื่อดึงข้อความจากเอกสาร Word

Aspose.Words for Java เป็นไลบรารีอันทรงพลังที่ช่วยให้คุณสามารถสร้างเอกสาร MS Word ได้ตั้งแต่เริ่มต้น นอกจากนี้ ยังให้คุณจัดการเอกสาร Word ที่มีอยู่สำหรับการเข้ารหัส การแปลง การดึงข้อความ ฯลฯ เราจะใช้ไลบรารีนี้เพื่อแยกข้อความจากเอกสาร Word DOCX หรือ DOC คุณสามารถ ดาวน์โหลด JAR ของ API หรือติดตั้งโดยใช้การกำหนดค่า Maven ต่อไปนี้

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

การสกัดข้อความใน Word DOC/DOCX ใน Java

เอกสาร MS Word ประกอบด้วยองค์ประกอบต่างๆ ซึ่งรวมถึงย่อหน้า ตาราง รูปภาพ เป็นต้น ดังนั้นข้อกำหนดในการแยกข้อความจึงอาจแตกต่างกันไปในแต่ละสถานการณ์ ตัวอย่างเช่น คุณอาจต้องแยกข้อความระหว่างย่อหน้า ที่คั่นหน้า ความคิดเห็น ฯลฯ

องค์ประกอบแต่ละประเภทใน Word DOC/DOCX จะแสดงเป็นโหนด ดังนั้นในการประมวลผลเอกสาร คุณจะต้องเล่นกับโหนด เรามาเริ่มกันและดูวิธีแยกข้อความจากเอกสาร Word ในสถานการณ์ต่างๆ

แยกข้อความจาก Word DOC ใน Java

ในส่วนนี้ เราจะใช้ Java text extractor สำหรับเอกสาร Word และขั้นตอนการทำงานของการแยกข้อความจะเป็นดังนี้:

• ขั้นแรก เราจะกำหนดโหนดที่เราต้องการรวมไว้ในขั้นตอนการแยกข้อความ
• จากนั้นเราจะแยกเนื้อหาระหว่างโหนดที่ระบุ (รวมถึงหรือไม่รวมโหนดเริ่มต้นและสิ้นสุด)
• สุดท้าย เราจะใช้การโคลนของโหนดที่แยกออกมา เช่น เพื่อสร้างเอกสาร Word ใหม่ที่ประกอบด้วยเนื้อหาที่แยกออกมา

ตอนนี้มาเขียนเมธอดชื่อ extractContent ซึ่งเราจะส่งโหนดและพารามิเตอร์อื่นๆ เพื่อดำเนินการแยกข้อความ วิธีนี้จะแยกวิเคราะห์เอกสารและโคลนโหนด ต่อไปนี้คือพารามิเตอร์ที่เราจะส่งผ่านไปยังวิธีนี้

1. startNode และ endNode เป็นจุดเริ่มต้นและจุดสิ้นสุดสำหรับการแยกเนื้อหา ตามลำดับ สิ่งเหล่านี้สามารถเป็นได้ทั้งโหนดระดับบล็อก (ย่อหน้า ตาราง) หรือระดับอินไลน์ (เช่น Run, FieldStart, BookmarkStart เป็นต้น)
   1. ในการส่งฟิลด์ คุณควรส่งวัตถุ FieldStart ที่สอดคล้องกัน
   2. ในการส่งผ่านบุ๊กมาร์ก ควรผ่านโหนด BookmarkStart และ BookmarkEnd
   3. สำหรับความคิดเห็น ควรใช้โหนด CommentRangeStart และ CommentRangeEnd
2. isInclusive กำหนดว่าเครื่องหมายรวมอยู่ในการแยกหรือไม่ หากตั้งค่าตัวเลือกนี้เป็น False และโหนดเดียวกันหรือโหนดที่ต่อเนื่องกันจะถูกส่งกลับ รายการว่างจะถูกส่งกลับ

ต่อไปนี้เป็นการนำเมธอด extractContent ไปใช้โดยสมบูรณ์ซึ่งจะแยกเนื้อหาระหว่างโหนดที่ส่งผ่าน

// สำหรับตัวอย่างและไฟล์ข้อมูลทั้งหมด โปรดไปที่ https://github.com/aspose-words/Aspose.Words-for-Java
public static ArrayList extractContent(Node startNode, Node endNode, boolean isInclusive) throws Exception {
    // ตรวจสอบก่อนว่าโหนดที่ผ่านไปยังเมธอดนี้ถูกต้องสำหรับการใช้งาน
    verifyParameterNodes(startNode, endNode);

    // สร้างรายการเพื่อจัดเก็บโหนดที่แยกออกมา
    ArrayList nodes = new ArrayList();

    // เก็บบันทึกของโหนดดั้งเดิมที่ส่งผ่านไปยังวิธีนี้ เพื่อให้เราสามารถแยกโหนดเครื่องหมายได้หากจำเป็น
    Node originalStartNode = startNode;
    Node originalEndNode = endNode;

    // แยกเนื้อหาตามโหนดระดับบล็อก (ย่อหน้าและตาราง) สำรวจผ่านโหนดหลักเพื่อค้นหา
    // เราจะแบ่งเนื้อหาของโหนดแรกและโหนดสุดท้าย โดยขึ้นอยู่กับว่าโหนดเครื่องหมายอยู่ในบรรทัดหรือไม่
    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;
    // โหนดปัจจุบันที่เรากำลังแยกออกจากเอกสาร
    Node currNode = startNode;

    // เริ่มแยกเนื้อหา ประมวลผลโหนดระดับบล็อกทั้งหมดและแยกโหนดแรกและโหนดสุดท้ายโดยเฉพาะเมื่อจำเป็น เพื่อให้การจัดรูปแบบย่อหน้ายังคงอยู่
    // วิธีการนี้ซับซ้อนกว่าตัวแยกข้อมูลทั่วไปเล็กน้อย เนื่องจากเราจำเป็นต้องแยกส่วนโดยใช้โหนดอินไลน์ ฟิลด์ บุ๊กมาร์ก ฯลฯ เพื่อให้มีประโยชน์จริงๆ
    while (isExtracting) {
        // โคลนโหนดปัจจุบันและโหนดย่อยเพื่อรับสำเนา
        /*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(จริง);

        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) {
            // เราจำเป็นต้องประมวลผลเครื่องหมายแต่ละรายการแยกกัน ดังนั้นส่งต่อไปยังวิธีอื่นแทน
            if (isStartingNode) {
                processMarker(cloneNode, nodes, originalStartNode, isInclusive, isStartingNode, isEndingNode);
                isStartingNode = false;
            }

            // เงื่อนไขต้องแยกจากกันเนื่องจากเครื่องหมายเริ่มต้นและสิ้นสุดระดับบล็อกอาจเป็นโหนดเดียวกัน
            if (isEndingNode) {
                processMarker(cloneNode, nodes, originalEndNode, isInclusive, isStartingNode, isEndingNode);
                isExtracting = false;
            }
        } else
            // โหนดไม่ใช่เครื่องหมายเริ่มต้นหรือจุดสิ้นสุด เพียงเพิ่มสำเนาลงในรายการ
            nodes.add(cloneNode);

        // ย้ายไปยังโหนดถัดไปและแตกไฟล์ หากโหนดถัดไปเป็น null นั่นหมายถึงพบเนื้อหาที่เหลือในส่วนอื่น
        if (currNode.getNextSibling() == null && isExtracting) {
            // ย้ายไปยังส่วนถัดไป
            Section nextSection = (Section) currNode.getAncestor(NodeType.SECTION).getNextSibling();
            currNode = nextSection.getBody().getFirstChild();
        } else {
            // ย้ายไปยังโหนดถัดไปในเนื้อหา
            currNode = currNode.getNextSibling();
        }
    }

    // ส่งกลับโหนดระหว่างเครื่องหมายโหนด
    return nodes;
}

วิธีตัวช่วยบางอย่างจำเป็นต้องใช้โดยวิธี extractContent เพื่อดำเนินการแยกข้อความให้สำเร็จ ซึ่งแสดงไว้ด้านล่าง

/**
 * ตรวจสอบพารามิเตอร์อินพุตว่าถูกต้องและใช้งานได้ พ่นข้อยกเว้น
 * หากมีปัญหาใดๆ
 */
private static void verifyParameterNodes(Node startNode, Node endNode) throws Exception {
	// ลำดับในการตรวจสอบเหล่านี้มีความสำคัญ
	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");

	// ตรวจสอบว่าโหนดสิ้นสุดอยู่หลังโหนดเริ่มต้นในแผนผัง DOM
	// ก่อนอื่นให้ตรวจสอบว่าอยู่ในส่วนต่างๆ หรือไม่ จากนั้นหากไม่ได้ตรวจสอบ
	// ตำแหน่งของพวกเขาในเนื้อหาของส่วนเดียวกันกับที่พวกเขาอยู่
	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");
}

/**
 * ตรวจสอบว่าโหนดที่ผ่านเป็นโหนดอินไลน์หรือไม่
 */
private static boolean isInline(Node node) throws Exception {
	// ทดสอบว่าโหนดนั้นมาจากโหนดย่อหน้าหรือตาราง และไม่ใช่โหนด a
	// ย่อหน้าหรือตารางย่อหน้าในคลาสความคิดเห็นซึ่งอยู่ถัดจาก
	// วรรคหนึ่งเป็นไปได้
	return ((node.getAncestor(NodeType.PARAGRAPH) != null || node.getAncestor(NodeType.TABLE) != null)
			&& !(node.getNodeType() == NodeType.PARAGRAPH || node.getNodeType() == NodeType.TABLE));
}

/**
 * ลบเนื้อหาก่อนหรือหลังเครื่องหมายในโหนดโคลนขึ้นอยู่กับ
 * เกี่ยวกับประเภทของเครื่องหมาย
 */
private static void processMarker(CompositeNode cloneNode, ArrayList nodes, Node node, boolean isInclusive,
		boolean isStartMarker, boolean isEndMarker) throws Exception {
	// หากเรากำลังจัดการกับโหนดระดับบล็อก ให้ดูว่าควรรวมไว้หรือไม่
	// และเพิ่มลงในรายการ
	if (!isInline(node)) {
		// อย่าเพิ่มโหนดสองครั้งหากเครื่องหมายเป็นโหนดเดียวกัน
		if (!(isStartMarker && isEndMarker)) {
			if (isInclusive)
				nodes.add(cloneNode);
		}
		return;
	}

	// หากเครื่องหมายเป็นโหนด FieldStart ให้ตรวจสอบว่าจำเป็นต้องรวมหรือไม่
	// เราสันนิษฐานว่า FieldStart และ FieldEnd ปรากฏในรายการเดียวกันเพื่อความเรียบง่าย
	// ย่อหน้า
	if (node.getNodeType() == NodeType.FIELD_START) {
		// หากเครื่องหมายเป็นโหนดเริ่มต้นและไม่ได้รวมไว้ ให้ข้ามไปที่จุดสิ้นสุดของ
		// สนาม.
		// หากเครื่องหมายเป็นโหนดสิ้นสุดและจะรวมไว้ ให้ย้ายไปที่จุดสิ้นสุด
		// ฟิลด์เพื่อไม่ให้ฟิลด์ถูกลบออก
		if ((isStartMarker && !isInclusive) || (!isStartMarker && isInclusive)) {
			while (node.getNextSibling() != null && node.getNodeType() != NodeType.FIELD_END)
				node = node.getNextSibling();

		}
	}

	// หากเครื่องหมายใดเป็นส่วนหนึ่งของความคิดเห็น ให้รวมความคิดเห็นนั้นไว้ด้วย
	// ต้องเลื่อนตัวชี้ไปข้างหน้าเพื่อแสดงความคิดเห็น
	// พบโหนดหลังโหนด CommentRangeEnd
	if (node.getNodeType() == NodeType.COMMENT_RANGE_END) {
		while (node.getNextSibling() != null && node.getNodeType() != NodeType.COMMENT)
			node = node.getNextSibling();

	}

	// ค้นหาโหนดที่เกี่ยวข้องในโหนดโคลนของเราตามดัชนีแล้วส่งคืน
	// หากโหนดเริ่มต้นและโหนดสิ้นสุดเหมือนกัน โหนดย่อยบางโหนดอาจมีอยู่แล้ว
	// ถูกลบออก ลบออก
	// ความแตกต่างเพื่อให้ได้ดัชนีที่เหมาะสม
	int indexDiff = node.getParentNode().getChildNodes().getCount() - cloneNode.getChildNodes().getCount();

	// โหนดลูกนับเหมือนกัน
	if (indexDiff == 0)
		node = cloneNode.getChildNodes().get(node.getParentNode().indexOf(node));
	else
		node = cloneNode.getChildNodes().get(node.getParentNode().indexOf(node) - indexDiff);

	// ลบโหนดจนถึง/ออกจากเครื่องหมาย
	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();
	}

	// หลังจากประมวลผลแล้ว โหนดคอมโพสิตอาจว่างเปล่า หากมีไม่รวมถึง
	// มัน.
	if (!(isStartMarker && isEndMarker)) {
		if (cloneNode.hasChildNodes())
			nodes.add(cloneNode);
	}
}

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

	// สร้างเอกสารเปล่า
	Document dstDoc = new Document();
	// ลบย่อหน้าแรกออกจากเอกสารเปล่า
	dstDoc.getFirstSection().getBody().removeAllChildren();

	// นำเข้าแต่ละโหนดจากรายการไปยังเอกสารใหม่ เก็บไว้ที่เดิม
	// การจัดรูปแบบของโหนด
	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 dstDoc;
}

ตอนนี้เราพร้อมที่จะใช้วิธีการเหล่านี้และดึงข้อความจากเอกสาร Word แล้ว

Java แยกข้อความระหว่างย่อหน้าใน Word DOC

มาดูวิธีแยกเนื้อหาระหว่างสองย่อหน้าในเอกสาร Word DOCX ต่อไปนี้เป็นขั้นตอนในการดำเนินการนี้ใน Java

• ขั้นแรก ให้โหลดเอกสาร Word โดยใช้คลาส Document
• รับการอ้างอิงของย่อหน้าเริ่มต้นและสิ้นสุดเป็นสองวัตถุโดยใช้เมธอด Document.getFirstSection().getChild(NodeType.PARAGRAPH, int, bool)
• เรียกใช้เมธอด extractContent(startPara, endPara, true) เพื่อแยกโหนดออกเป็นวัตถุ
• เรียกใช้เมธอดตัวช่วย createDocument(Document, extractedNodes) เพื่อสร้างเอกสารที่ประกอบด้วยเนื้อหาที่แยกออกมา
• สุดท้าย บันทึกเอกสารที่ส่งคืนโดยใช้เมธอด Document.save(String)

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีการแยกข้อความระหว่างย่อหน้าที่ 7 และ 11 ใน Word DOCX ใน Java

// โหลดเอกสาร
Document doc = new Document("TestFile.doc");

// รวบรวมโหนด เมธอด GetChild ใช้ดัชนีแบบ 0
Paragraph startPara = (Paragraph) doc.getFirstSection().getChild(NodeType.PARAGRAPH, 6, true);
Paragraph endPara = (Paragraph) doc.getFirstSection().getChild(NodeType.PARAGRAPH, 10, true);
// แยกเนื้อหาระหว่างโหนดเหล่านี้ในเอกสาร รวมสิ่งเหล่านี้
// เครื่องหมายในการสกัด
ArrayList extractedNodes = extractContent(startPara, endPara, true);

// ใส่เนื้อหาลงในเอกสารใหม่แยกต่างหากและบันทึกลงในดิสก์
Document dstDoc = generateDocument(doc, extractedNodes);
dstDoc.save("output.doc");

Java แยกข้อความจาก DOC - ระหว่างโหนดประเภทต่างๆ

คุณยังสามารถแยกเนื้อหาระหว่างโหนดประเภทต่างๆ สำหรับการสาธิต ลองแยกเนื้อหาระหว่างย่อหน้าและตารางแล้วบันทึกลงในเอกสาร Word ใหม่ ต่อไปนี้เป็นขั้นตอนในการแยกข้อความระหว่างโหนดต่างๆ ในเอกสาร Word ใน Java

• โหลดเอกสาร Word โดยใช้คลาส Document
• รับการอ้างอิงของโหนดเริ่มต้นและสิ้นสุดเป็นสองวัตถุโดยใช้เมธอด Document.getFirstSection().getChild(NodeType, int, bool)
• เรียกใช้เมธอด extractContent(startPara, endPara, true) เพื่อแยกโหนดออกเป็นวัตถุ
• เรียกใช้เมธอดตัวช่วย createDocument(Document, extractedNodes) เพื่อสร้างเอกสารที่ประกอบด้วยเนื้อหาที่แยกออกมา
• บันทึกเอกสารที่ส่งคืนโดยใช้เมธอด Document.save(String)

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีการแยกข้อความระหว่างย่อหน้าและตารางใน DOCX โดยใช้ Java

// โหลดเอกสาร
Document doc = new Document("TestFile.doc");

// รับการอ้างอิงของย่อหน้าเริ่มต้น
Paragraph startPara = (Paragraph) doc.getLastSection().getChild(NodeType.PARAGRAPH, 2, true);
Table endTable = (Table) doc.getLastSection().getChild(NodeType.TABLE, 0, true);

// แยกเนื้อหาระหว่างโหนดเหล่านี้ในเอกสาร รวมเครื่องหมายเหล่านี้ในการแยก
ArrayList extractedNodes = extractContent(startPara, endTable, true);

// ให้ย้อนกลับอาร์เรย์เพื่อให้แทรกเนื้อหากลับเข้าไปในเอกสารได้ง่ายขึ้น
Collections.reverse(extractedNodes);

while (extractedNodes.size() > 0) {
    // แทรกโหนดสุดท้ายจากรายการที่กลับรายการ
    endTable.getParentNode().insertAfter((Node) extractedNodes.get(0), endTable);
    // ลบโหนดนี้ออกจากรายการหลังจากการแทรก
    extractedNodes.remove(0);
}

// บันทึกเอกสารที่สร้างขึ้นลงดิสก์
doc.save("output.doc");

Java แยกข้อความจาก DOCX - ระหว่างย่อหน้าตามสไตล์

มาดูวิธีแยกเนื้อหาระหว่างย่อหน้าตามสไตล์กัน สำหรับการสาธิต เราจะแยกเนื้อหาระหว่าง “หัวเรื่อง 1” แรกและ “หัวเรื่อง 3” แรกในเอกสาร Word ขั้นตอนต่อไปนี้จะสาธิตวิธีบรรลุสิ่งนี้ใน Java

• ขั้นแรก ให้โหลดเอกสาร Word โดยใช้คลาส Document
• จากนั้นแยกย่อหน้าลงในวัตถุโดยใช้วิธีการช่วยของ paragraphsByStyleName(Document, “Heading 1”)
• แยกย่อหน้าลงในวัตถุอื่นโดยใช้วิธีการช่วยของ paragraphsByStyleName(Document, “Heading 3”)
• เรียกใช้เมธอด extractContent(startPara, endPara, true) และส่งองค์ประกอบแรกในอาร์เรย์ย่อหน้าทั้งสองเป็นพารามิเตอร์ตัวแรกและตัวที่สอง
• เรียกใช้เมธอดตัวช่วย createDocument(Document, extractedNodes) เพื่อสร้างเอกสารที่ประกอบด้วยเนื้อหาที่แยกออกมา
• สุดท้าย บันทึกเอกสารที่ส่งคืนโดยใช้เมธอด Document.save(String)

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีการแยกเนื้อหาระหว่างย่อหน้าตามสไตล์

// โหลดเอกสาร
Document doc = new Document(dataDir + "TestFile.doc");

// รวบรวมรายการของย่อหน้าโดยใช้รูปแบบหัวเรื่องที่เกี่ยวข้อง
ArrayList parasStyleHeading1 = paragraphsByStyleName(doc, "Heading 1");
ArrayList parasStyleHeading3 = paragraphsByStyleName(doc, "Heading 3");

// ใช้ตัวอย่างแรกของย่อหน้ากับสไตล์เหล่านั้น
Node startPara1 = (Node) parasStyleHeading1.get(0);
Node endPara1 = (Node) parasStyleHeading3.get(0);

// แยกเนื้อหาระหว่างโหนดเหล่านี้ในเอกสาร อย่ารวมเครื่องหมายเหล่านี้ในการแยก
ArrayList extractedNodes = extractContent(startPara1, endPara1, false);

// ใส่เนื้อหาลงในเอกสารใหม่แยกต่างหากและบันทึกลงในดิสก์
Document dstDoc = generateDocument(doc, extractedNodes);
dstDoc.save("output.doc");

Java Word Text Extractor - อ่านเพิ่มเติม

คุณสามารถสำรวจสถานการณ์อื่นๆ ในการแยกข้อความจากเอกสาร Word โดยใช้บทความคู่มือ this

Java API เพื่อแยกข้อความจาก DOC/DOCX - รับใบอนุญาตฟรี

คุณสามารถรับ ใบอนุญาตชั่วคราว เพื่อใช้ Aspose.Words for Java โดยไม่มีข้อจำกัดในการประเมิน

บทสรุป

ในบทความนี้ คุณได้เรียนรู้วิธีแยกข้อความจาก MS Word DOC DOCX ใน Java นอกจากนี้ คุณได้เห็นวิธีแยกเนื้อหาระหว่างโหนดประเภทเดียวกันหรือต่างชนิดกันในเอกสาร Word โดยทางโปรแกรม ดังนั้น คุณสามารถสร้างตัวแยกข้อความ MS Word ของคุณเองใน Java นอกจากนี้ คุณสามารถสำรวจคุณลักษณะอื่นๆ ของ Aspose.Words for Java โดยใช้ เอกสารประกอบ ในกรณีที่คุณมีคำถามใดๆ โปรดแจ้งให้เราทราบผ่านทาง ฟอรัม ของเรา

ดูสิ่งนี้ด้วย

• สร้างเอกสาร Word ด้วย C# โดยไม่ต้องใช้ MS Office
• สร้างเอกสาร Word จากเทมเพลตใน C# .NET