在 Aspose.Words for Java 中將文件分割為頁面
內容
[
隱藏
]如果您正在使用 Java 進行文件處理，Aspose.Words for Java 是一個功能強大的 API，可以幫助您有效地將文件分割為單獨的頁面。在本逐步教學中，我們將引導您使用提供的原始程式碼完成分割文件的過程。在本教學結束時，您將能夠輕鬆拆分文檔，從而提高文檔管理能力。
一、簡介
Aspose.Words for Java 是一個 Java 函式庫，可讓您以程式設計方式操作 Word 文件。一項常見任務是將文件拆分為單獨的頁面，這可用於多種目的，例如歸檔、列印或文件處理。
2. 前提條件
在我們深入研究程式碼之前，請確保您具備以下先決條件：
- 您的系統上安裝了 Java 開發工具包 (JDK)。
- Aspose.Words for Java 函式庫，您可以下載這裡.
3. 設定您的環境
首先，請如下所示設定您的開發環境：
- 在您首選的整合開發環境 (IDE) 中建立 Java 專案。
- 將 Aspose.Words for Java 函式庫加入您的專案中。您可以參考文件取得詳細說明。
4. 理解原始碼
您提供的原始程式碼旨在將文件拆分為單獨的頁面。讓我們分解一下關鍵組件：
String fileName = FilenameUtils.getBaseName(docName);
String extensionName = FilenameUtils.getExtension(docName);
System.out.println("Processing document: " + fileName + "." + extensionName);
Document doc = new Document(docName);
- 我們提取輸入文件的基本名稱和副檔名。
- 我們使用 Aspose.Words for Java 載入文件。
5. 逐步拆分文檔
5.1.載入文檔
Document doc = new Document(docName);
在此步驟中，我們將輸入文件載入到Document對象，它允許我們處理文件的內容。
5.2.初始化 DocumentPageSplitter
DocumentPageSplitter splitter = new DocumentPageSplitter(doc);
我們初始化一個DocumentPageSplitter物件與我們載入的文檔。這個類別是由Aspose.Words for Java提供的，可以幫助我們將文件分割成頁面。
5.3.儲存每一頁
for (int page = 1; page <= doc.getPageCount(); page++) {
Document pageDoc = splitter.getDocumentOfPage(page);
pageDoc.save("Your Directory Path" + MessageFormat.format("{0} - page{1}.{2}", fileName, page, extensionName));
}
在此步驟中，我們迭代文件的每個頁面並將其儲存為單獨的文件。您可以指定儲存分頁的目錄路徑。
6. 運行程式碼
若要成功執行此程式碼，請確保您已設定環境並將 Aspose.Words for Java 程式庫新增至您的專案。然後，執行程式碼，您的文件就會被分成單獨的頁面。
DocumentPageSplitter原始碼
/// <摘要>
//將一個文檔拆分為多個文檔，每頁一個。
/// </摘要>
class DocumentPageSplitter
{
private PageNumberFinder pageNumberFinder;
/// <摘要>
/// 初始化 <see cref="DocumentPageSplitter"/> 類別的新實例。
/// 此方法將文件拆分為多個部分，以便每個頁面在部分邊界處開始和結束。
/// 建議事後不要修改該文件。
/// </摘要>
/// <param name="source">來源文件</param>
public DocumentPageSplitter(Document source) throws Exception
{
pageNumberFinder = PageNumberFinderFactory.create(source);
}
private Document getDocument() {
return pageNumberFinder.getDocument();
}
/// <摘要>
/// 取得頁面的文檔。
/// </摘要>
/// <參數名稱=“頁面索引”>
///1 為基礎的頁面索引。
/// </參數>
/// <返回>
/// <請參閱 cref="文檔"/>。
/// </返回>
public Document getDocumentOfPage(int pageIndex) throws Exception {
return getDocumentOfPageRange(pageIndex, pageIndex);
}
/// <摘要>
/// 取得文件的一個頁面範圍。
/// </摘要>
//<參數名稱=“startIndex”>
///1 基於起始頁的索引。
/// </參數>
/// <參數名稱=“endIndex”>
/// 1 為結束頁面的索引。
/// </參數>
/// <返回>
/// <請參閱 cref="文檔"/>。
/// </返回>
public Document getDocumentOfPageRange(int startIndex, int endIndex) throws Exception {
Document result = (Document) getDocument().deepClone(false);
for (Node section : pageNumberFinder.retrieveAllNodesOnPages(startIndex, endIndex, NodeType.SECTION))
{
result.appendChild(result.importNode(section, true));
}
return result;
}
}
/// <摘要>
/// 提供提取在指定頁面上呈現的文檔節點的方法。
/// </摘要>
class PageNumberFinder
{
//將節點對應到起始/結束頁碼。
//這用於在拆分文件時覆蓋收集器提供的基線頁碼。
private Map<Node, Integer> nodeStartPageLookup = new HashMap<>();
private Map<Node, Integer> nodeEndPageLookup = new HashMap<>();
private LayoutCollector collector;
//將頁碼對應到該頁面上找到的節點清單。
private Map<Integer, ArrayList<Node>> reversePageLookup;
/// <摘要>
/// 初始化 <see cref="PageNumberFinder"/> 類別的新實例。
/// </摘要>
/// <param name="collector">具有文件佈局模型記錄的收集器實例。
public PageNumberFinder(LayoutCollector collector)
{
this.collector = collector;
}
public Document getDocument()
{
return collector.getDocument();
}
/// <摘要>
/// 檢索節點開始的頁面的從 1 開始的索引。
/// </摘要>
/// <參數名稱=“節點”>
/// 節點。
/// </參數>
/// <返回>
/// 頁面索引。
/// </返回>
public int getPage(Node node) throws Exception {
return nodeStartPageLookup.containsKey(node)
? nodeStartPageLookup.get(node)
: collector.getStartPageIndex(node);
}
/// <摘要>
/// 檢索節點結束的頁面的從 1 開始的索引。
/// </摘要>
/// <參數名稱=“節點”>
/// 節點。
/// </參數>
/// <返回>
/// 頁面索引。
/// </返回>
public int getPageEnd(Node node) throws Exception {
return nodeEndPageLookup.containsKey(node)
? nodeEndPageLookup.get(node)
: collector.getEndPageIndex(node);
}
/// <摘要>
//傳回指定節點跨越的頁數。如果該節點包含在一頁內，則傳回 1。
/// </摘要>
/// <參數名稱=“節點”>
/// 節點。
/// </參數>
/// <返回>
/// 頁面索引。
/// </返回>
public int pageSpan(Node node) throws Exception {
return getPageEnd(node) - getPage(node) + 1;
}
/// <摘要>
/// 傳回指定頁面上任何位置所包含的節點清單或與指定節點類型相符的頁面。
/// </摘要>
/// <參數名稱=“起始頁”>
/// 起始頁。
/// </參數>
/// <參數名稱=“endPage”>
/// 最後一頁。
/// </參數>
/// <參數名稱=“節點類型”>
/// 節點類型。
/// </參數>
/// <返回>
/// <參見 cref="IList{T}"/>。
/// </返回>
public ArrayList<Node> retrieveAllNodesOnPages(int startPage, int endPage, /*NodeType*/int nodeType) throws Exception
{
if (startPage < 1 || startPage > collector.getDocument().getPageCount())
{
throw new IllegalStateException("'startPage' is out of range");
}
if (endPage < 1 || endPage > collector.getDocument().getPageCount() || endPage < startPage)
{
throw new IllegalStateException("'endPage' is out of range");
}
checkPageListsPopulated();
ArrayList<Node> pageNodes = new ArrayList<>();
for (int page = startPage; page <= endPage; page++)
{
//有些頁面可能為空。
if (!reversePageLookup.containsKey(page))
{
continue;
}
for (Node node : reversePageLookup.get(page))
{
if (node.getParentNode() != null
&& (nodeType == NodeType.ANY || node.getNodeType() == nodeType)
&& !pageNodes.contains(node))
{
pageNodes.add(node);
}
}
}
return pageNodes;
}
/// <摘要>
/// 將出現在兩個或多個頁面上的節點拆分為單獨的節點，以便它們仍然以相同的方式顯示
//但不再出現在頁面上。
/// </摘要>
public void splitNodesAcrossPages() throws Exception
{
for (Paragraph paragraph : (Iterable<Paragraph>) collector.getDocument().getChildNodes(NodeType.PARAGRAPH, true))
{
if (getPage(paragraph) != getPageEnd(paragraph))
{
splitRunsByWords(paragraph);
}
}
clearCollector();
//訪問任何可能跨頁面拆分的組合並將它們拆分為單獨的節點。
collector.getDocument().accept(new SectionSplitter(this));
}
/// <摘要>
/// 這是由<see cref="SectionSplitter"/>呼叫來更新分割節點的頁碼。
/// </摘要>
/// <參數名稱=“節點”>
/// 節點。
/// </參數>
/// <參數名稱=“起始頁”>
/// 起始頁。
/// </參數>
/// <參數名稱=“endPage”>
/// 最後一頁。
/// </參數>
void addPageNumbersForNode(Node node, int startPage, int endPage)
{
if (startPage > 0)
{
nodeStartPageLookup.put(node, startPage);
}
if (endPage > 0)
{
nodeEndPageLookup.put(node, endPage);
}
}
private boolean isHeaderFooterType(Node node)
{
return node.getNodeType() == NodeType.HEADER_FOOTER || node.getAncestor(NodeType.HEADER_FOOTER) != null;
}
private void checkPageListsPopulated() throws Exception {
if (reversePageLookup != null)
{
return;
}
reversePageLookup = new HashMap<Integer, ArrayList<Node>>();
//將每個節點新增到表示每個頁面上找到的節點的清單中。
for (Node node : (Iterable<Node>) collector.getDocument().getChildNodes(NodeType.ANY, true))
{
//頁首/頁尾位於各部分之後，且不會自行分割。
if (isHeaderFooterType(node))
{
continue;
}
int startPage = getPage(node);
int endPage = getPageEnd(node);
for (int page = startPage; page <= endPage; page++)
{
if (!reversePageLookup.containsKey(page))
{
reversePageLookup.put(page, new ArrayList<Node>());
}
reversePageLookup.get(page).add(node);
}
}
}
private void splitRunsByWords(Paragraph paragraph) throws Exception {
for (Run run : paragraph.getRuns())
{
if (getPage(run) == getPageEnd(run))
{
continue;
}
splitRunByWords(run);
}
}
private void splitRunByWords(Run run)
{
String[] words = reverseWord(run.getText());
for (String word : words)
{
int pos = run.getText().length() - word.length() - 1;
if (pos > 1)
{
splitRun(run, run.getText().length() - word.length() - 1);
}
}
}
private static String[] reverseWord(String str) {
String words[] = str.split(" ");
String reverseWord = "";
for (String w : words) {
StringBuilder sb = new StringBuilder(w);
sb.reverse();
reverseWord += sb.toString() + " ";
}
return reverseWord.split(" ");
}
/// <摘要>
/// 將指定運行的文字拆分為兩個運行。
/// 在指定的運行之後插入新的運行。
/// </摘要>
private void splitRun(Run run, int position)
{
Run afterRun = (Run) run.deepClone(true);
afterRun.setText(run.getText().substring(position));
run.setText(run.getText().substring((0), (0) + (position)));
run.getParentNode().insertAfter(afterRun, run);
}
private void clearCollector() throws Exception
{
collector.clear();
collector.getDocument().updatePageLayout();
nodeStartPageLookup.clear();
nodeEndPageLookup.clear();
}
}
class PageNumberFinderFactory
{
public static PageNumberFinder create(Document document) throws Exception
{
LayoutCollector layoutCollector = new LayoutCollector(document);
document.updatePageLayout();
PageNumberFinder pageNumberFinder = new PageNumberFinder(layoutCollector);
pageNumberFinder.splitNodesAcrossPages();
return pageNumberFinder;
}
}
/// <摘要>
/// 將文件拆分為多個部分，以便每個頁面在部分邊界處開始和結束。
/// </摘要>
class SectionSplitter extends DocumentVisitor
{
private PageNumberFinder pageNumberFinder;
public SectionSplitter(PageNumberFinder pageNumberFinder)
{
this.pageNumberFinder = pageNumberFinder;
}
public int visitParagraphStart(Paragraph paragraph) throws Exception {
return continueIfCompositeAcrossPageElseSkip(paragraph);
}
public int visitTableStart(Table table) throws Exception {
return continueIfCompositeAcrossPageElseSkip(table);
}
public int visitRowStart(Row row) throws Exception {
return continueIfCompositeAcrossPageElseSkip(row);
}
public int visitCellStart(Cell cell) throws Exception {
return continueIfCompositeAcrossPageElseSkip(cell);
}
public int visitStructuredDocumentTagStart(StructuredDocumentTag sdt) throws Exception {
return continueIfCompositeAcrossPageElseSkip(sdt);
}
public int visitSmartTagStart(SmartTag smartTag) throws Exception {
return continueIfCompositeAcrossPageElseSkip(smartTag);
}
public int visitSectionStart(Section section) throws Exception {
Section previousSection = (Section) section.getPreviousSibling();
//如果存在前一部分，請嘗試複製任何連結的頁首頁腳。
//否則，如果上一部分遺失，它們將不會出現在提取的文件中。
if (previousSection != null)
{
HeaderFooterCollection previousHeaderFooters = previousSection.getHeadersFooters();
if (!section.getPageSetup().getRestartPageNumbering())
{
section.getPageSetup().setRestartPageNumbering(true);
section.getPageSetup().setPageStartingNumber(previousSection.getPageSetup().getPageStartingNumber() +
pageNumberFinder.pageSpan(previousSection));
}
for (HeaderFooter previousHeaderFooter : (Iterable<HeaderFooter>) previousHeaderFooters)
{
if (section.getHeadersFooters().getByHeaderFooterType(previousHeaderFooter.getHeaderFooterType()) == null)
{
HeaderFooter newHeaderFooter =
(HeaderFooter) previousHeaderFooters.getByHeaderFooterType(previousHeaderFooter.getHeaderFooterType()).deepClone(true);
section.getHeadersFooters().add(newHeaderFooter);
}
}
}
return continueIfCompositeAcrossPageElseSkip(section);
}
public int visitSmartTagEnd(SmartTag smartTag) throws Exception {
splitComposite(smartTag);
return VisitorAction.CONTINUE;
}
public int visitStructuredDocumentTagEnd(StructuredDocumentTag sdt) throws Exception {
splitComposite(sdt);
return VisitorAction.CONTINUE;
}
public int visitCellEnd(Cell cell) throws Exception {
splitComposite(cell);
return VisitorAction.CONTINUE;
}
public int visitRowEnd(Row row) throws Exception {
splitComposite(row);
return VisitorAction.CONTINUE;
}
public int visitTableEnd(Table table) throws Exception {
splitComposite(table);
return VisitorAction.CONTINUE;
}
public int visitParagraphEnd(Paragraph paragraph) throws Exception {
//如果段落僅包含分節符，請新增假運行。
if (paragraph.isEndOfSection() && paragraph.getChildNodes().getCount() == 1 &&
"\f".equals(paragraph.getChildNodes().get(0).getText()))
{
Run run = new Run(paragraph.getDocument());
paragraph.appendChild(run);
int currentEndPageNum = pageNumberFinder.getPageEnd(paragraph);
pageNumberFinder.addPageNumbersForNode(run, currentEndPageNum, currentEndPageNum);
}
for (Node cloneNode : splitComposite(paragraph))
{
Paragraph clonePara = (Paragraph) cloneNode;
//從複製的段落中刪除清單編號，但縮排保持不變
//因為該段落應該是先前項目的一部分。
if (paragraph.isListItem())
{
double textPosition = clonePara.getListFormat().getListLevel().getTextPosition();
clonePara.getListFormat().removeNumbers();
clonePara.getParagraphFormat().setLeftIndent(textPosition);
}
//重置表格中分割段落的間距，因為額外的間距可能會導致它們看起來不同。
if (paragraph.isInCell())
{
clonePara.getParagraphFormat().setSpaceBefore(0.0);
paragraph.getParagraphFormat().setSpaceAfter(0.0);
}
}
return VisitorAction.CONTINUE;
}
public int visitSectionEnd(Section section) throws Exception {
for (Node cloneNode : splitComposite(section))
{
Section cloneSection = (Section) cloneNode;
cloneSection.getPageSetup().setSectionStart(SectionStart.NEW_PAGE);
cloneSection.getPageSetup().setRestartPageNumbering(true);
cloneSection.getPageSetup().setPageStartingNumber(section.getPageSetup().getPageStartingNumber() +
(section.getDocument().indexOf(cloneSection) -
section.getDocument().indexOf(section)));
cloneSection.getPageSetup().setDifferentFirstPageHeaderFooter(false);
//更正該節末尾的分頁符號。
SplitPageBreakCorrector.processSection(cloneSection);
}
SplitPageBreakCorrector.processSection(section);
//也為該部分的正文添加新的頁碼。
pageNumberFinder.addPageNumbersForNode(section.getBody(), pageNumberFinder.getPage(section),
pageNumberFinder.getPageEnd(section));
return VisitorAction.CONTINUE;
}
private /*VisitorAction*/int continueIfCompositeAcrossPageElseSkip(CompositeNode composite) throws Exception {
return pageNumberFinder.pageSpan(composite) > 1
? VisitorAction.CONTINUE
: VisitorAction.SKIP_THIS_NODE;
}
private ArrayList<Node> splitComposite(CompositeNode composite) throws Exception {
ArrayList<Node> splitNodes = new ArrayList<>();
for (Node splitNode : findChildSplitPositions(composite))
{
splitNodes.add(splitCompositeAtNode(composite, splitNode));
}
return splitNodes;
}
private Iterable<Node> findChildSplitPositions(CompositeNode node) throws Exception {
//一個節點可能跨越多個頁面，因此傳回分割位置清單。
//分割節點是下一頁的第一個節點。
ArrayList<Node> splitList = new ArrayList<Node>();
int startingPage = pageNumberFinder.getPage(node);
Node[] childNodes = node.getNodeType() == NodeType.SECTION
? ((Section) node).getBody().getChildNodes().toArray()
: node.getChildNodes().toArray();
for (Node childNode : childNodes)
{
int pageNum = pageNumberFinder.getPage(childNode);
if (childNode instanceof Run)
{
pageNum = pageNumberFinder.getPageEnd(childNode);
}
//如果子節點的頁面發生了變化，那麼這就是分割位置。
//將其添加到列表中。
if (pageNum > startingPage)
{
splitList.add(childNode);
startingPage = pageNum;
}
if (pageNumberFinder.pageSpan(childNode) > 1)
{
pageNumberFinder.addPageNumbersForNode(childNode, pageNum, pageNum);
}
}
//向後分割複合，以便克隆的節點以正確的順序插入。
Collections.reverse(splitList);
return splitList;
}
private CompositeNode splitCompositeAtNode(CompositeNode baseNode, Node targetNode) throws Exception {
CompositeNode cloneNode = (CompositeNode) baseNode.deepClone(false);
Node node = targetNode;
int currentPageNum = pageNumberFinder.getPage(baseNode);
//將下一頁上找到的所有節點移動到複製的節點中。單獨處理行節點。
if (baseNode.getNodeType() != NodeType.ROW)
{
CompositeNode composite = cloneNode;
if (baseNode.getNodeType() == NodeType.SECTION)
{
cloneNode = (CompositeNode) baseNode.deepClone(true);
Section section = (Section) cloneNode;
section.getBody().removeAllChildren();
composite = section.getBody();
}
while (node != null)
{
Node nextNode = node.getNextSibling();
composite.appendChild(node);
node = nextNode;
}
}
else
{
//如果我們正在處理一行，我們需要為複製行新增虛擬儲存格。
int targetPageNum = pageNumberFinder.getPage(targetNode);
Node[] childNodes = baseNode.getChildNodes().toArray();
for (Node childNode : childNodes)
{
int pageNum = pageNumberFinder.getPage(childNode);
if (pageNum == targetPageNum)
{
if (cloneNode.getNodeType() == NodeType.ROW)
((Row) cloneNode).ensureMinimum();
if (cloneNode.getNodeType() == NodeType.CELL)
((Cell) cloneNode).ensureMinimum();
cloneNode.getLastChild().remove();
cloneNode.appendChild(childNode);
}
else if (pageNum == currentPageNum)
{
cloneNode.appendChild(childNode.deepClone(false));
if (cloneNode.getLastChild().getNodeType() != NodeType.CELL)
{
((CompositeNode) cloneNode.getLastChild()).appendChild(
((CompositeNode) childNode).getFirstChild().deepClone(false));
}
}
}
}
//將分割節點插入到原始節點之後。
baseNode.getParentNode().insertAfter(cloneNode, baseNode);
//更新基本節點和克隆節點（包括其後代）的新頁碼。
//這將只是一個頁面，因為克隆的複合材料被拆分為一頁。
int currentEndPageNum = pageNumberFinder.getPageEnd(baseNode);
pageNumberFinder.addPageNumbersForNode(baseNode, currentPageNum, currentEndPageNum - 1);
pageNumberFinder.addPageNumbersForNode(cloneNode, currentEndPageNum, currentEndPageNum);
for (Node childNode : (Iterable<Node>) cloneNode.getChildNodes(NodeType.ANY, true))
{
pageNumberFinder.addPageNumbersForNode(childNode, currentEndPageNum, currentEndPageNum);
}
return cloneNode;
}
}
class SplitPageBreakCorrector
{
private static final String PAGE_BREAK_STR = "\f";
private static final char PAGE_BREAK = '\f';
public static void processSection(Section section)
{
if (section.getChildNodes().getCount() == 0)
{
return;
}
Body lastBody = (Body) Arrays.stream(new Iterator[]{section.getChildNodes().iterator()}).reduce((first, second) -> second)
.orElse(null);
RunCollection runs = (RunCollection) lastBody.getChildNodes(NodeType.RUN, true).iterator();
Run run = Arrays.stream(runs.toArray()).filter(p -> p.getText().endsWith(PAGE_BREAK_STR)).findFirst().get();
if (run != null)
{
removePageBreak(run);
}
}
public void removePageBreakFromParagraph(Paragraph paragraph)
{
Run run = (Run) paragraph.getFirstChild();
if (PAGE_BREAK_STR.equals(run.getText()))
{
paragraph.removeChild(run);
}
}
private void processLastParagraph(Paragraph paragraph)
{
Node lastNode = paragraph.getChildNodes().get(paragraph.getChildNodes().getCount() - 1);
if (lastNode.getNodeType() != NodeType.RUN)
{
return;
}
Run run = (Run) lastNode;
removePageBreak(run);
}
private static void removePageBreak(Run run)
{
Paragraph paragraph = run.getParentParagraph();
if (PAGE_BREAK_STR.equals(run.getText()))
{
paragraph.removeChild(run);
}
else if (run.getText().endsWith(PAGE_BREAK_STR))
{
run.setText(StringUtils.stripEnd(run.getText(), String.valueOf(PAGE_BREAK)));
}
if (paragraph.getChildNodes().getCount() == 0)
{
CompositeNode parent = paragraph.getParentNode();
parent.removeChild(paragraph);
}
}
}
結論
現在您已經學習如何使用 Aspose.Words for Java 將文件分割為單獨的頁面。本指南提供了帶有原始程式碼範例的全面逐步教學。您可以進一步自訂和擴充此程式碼，以滿足您在處理文件時的特定要求。 當然！讓我們在使用 Aspose.Words for Java 將文件拆分為頁面的指南中新增常見問題解答部分。
常見問題解答
如何將 Aspose.Words for Java 加入我的專案？
若要將 Aspose.Words for Java 新增至您的專案中，請依照下列步驟操作：
- 從下列位置下載 Aspose.Words for Java 函式庫這裡.
- 將下載的 JAR 檔案新增至專案的類別路徑。
- 現在您可以開始在專案中使用 Aspose.Words for Java。
我可以分割其他格式的文檔，例如 PDF 或 DOCX 嗎？
不，本指南專門介紹使用 Aspose.Words for Java 分割 DOC 格式的文件。如果您需要分割其他格式的文檔，您可能需要探索支援這些格式的其他程式庫或工具。
Aspose.Words for Java 是免費函式庫嗎？
不，Aspose.Words for Java 不是免費的函式庫。它是一種需要支付許可費的商業產品。您可以訪問Aspose.Words for Java 定價頁面有關許可和定價詳情的更多資訊。
我可以將文件拆分為自訂頁面大小和格式嗎？
是的，您可以透過修改 Aspose.Words for Java 中的頁面設定屬性來自訂分割文件的頁面大小和格式。有關如何根據您的要求自訂頁面設定的詳細信息，請參閱 Aspose.Words 文件。
可以拆分的頁面數量有限制嗎？
Aspose.Words for Java 不會對可以分割的頁面數量施加具體限制。但是，請記住，非常大的文件可能需要更多的記憶體和處理時間。處理大型文件時請注意系統資源。
拆分文件時如何處理頁首和頁尾？
使用 Aspose.Words for Java 函式庫分割文件時可以處理頁首和頁尾。您可以將頁首和頁尾內容從原始文檔複製到分割文檔，確保它們正確保留。您可能需要根據特定的頁首和頁尾要求自訂此流程。
