Apache POI - คู่มือฉบับย่อ

หลายครั้งจำเป็นต้องใช้แอปพลิเคชันซอฟต์แวร์เพื่อสร้างรายงานในรูปแบบไฟล์ Microsoft Excel บางครั้งแอปพลิเคชันคาดว่าจะได้รับไฟล์ Excel เป็นข้อมูลอินพุต ตัวอย่างเช่นแอปพลิเคชันที่พัฒนาขึ้นสำหรับแผนกการเงินของ บริษัท จะต้องสร้างผลลัพธ์ทั้งหมดใน Excel

โปรแกรมเมอร์ Java ที่ต้องการสร้างไฟล์ MS Office เป็นเอาต์พุตต้องใช้ API ที่กำหนดไว้ล่วงหน้าและอ่านอย่างเดียวจึงจะทำได้

Apache POI คืออะไร?

Apache POI เป็น API ยอดนิยมที่ช่วยให้โปรแกรมเมอร์สร้างแก้ไขและแสดงไฟล์ MS Office โดยใช้โปรแกรม Java เป็นไลบรารีโอเพ่นซอร์สที่พัฒนาและเผยแพร่โดย Apache Software Foundation เพื่อออกแบบหรือแก้ไขไฟล์ Microsoft Office โดยใช้โปรแกรม Java ประกอบด้วยคลาสและวิธีการถอดรหัสข้อมูลอินพุตของผู้ใช้หรือไฟล์ลงในเอกสาร MS Office

ส่วนประกอบของ Apache POI

Apache POI มีคลาสและวิธีการทำงานกับเอกสาร OLE2 Compound ทั้งหมดของ MS Office รายการส่วนประกอบของ API นี้มีให้ด้านล่าง

  • POIFS(ระบบไฟล์การติดตั้งการใช้งานที่ไม่ชัดเจน) - ส่วนประกอบนี้เป็นปัจจัยพื้นฐานขององค์ประกอบ POI อื่น ๆ ทั้งหมด ใช้เพื่ออ่านไฟล์ต่าง ๆ อย่างชัดเจน

  • HSSF (รูปแบบสเปรดชีตที่น่ากลัว) - ใช้เพื่ออ่านและเขียน xls รูปแบบของไฟล์ MS-Excel

  • XSSF (XML Spreadsheet Format) - ใช้สำหรับ xlsx รูปแบบไฟล์ของ MS-Excel

  • HPSF (รูปแบบชุดคุณสมบัติที่น่าสยดสยอง) - ใช้ในการแยก property sets ของไฟล์ MS-Office

  • HWPF (รูปแบบตัวประมวลผลคำที่น่ากลัว) - ใช้เพื่ออ่านและเขียน doc ไฟล์นามสกุลของ MS-Word

  • XWPF (XML Word Processor Format) - ใช้ในการอ่านและเขียน docx ไฟล์นามสกุลของ MS-Word

  • HSLF (รูปแบบเค้าโครงสไลด์ที่น่ากลัว) - ใช้สำหรับอ่านสร้างและแก้ไขงานนำเสนอ PowerPoint

  • HDGF (รูปแบบ DiaGram ที่น่ากลัว) - มีคลาสและวิธีการสำหรับ MS-Visio ไฟล์ไบนารี

  • HPBF (รูปแบบ PuBlisher ที่น่ากลัว) - ใช้เพื่ออ่านและเขียน MS-Publisher ไฟล์.

บทช่วยสอนนี้จะแนะนำคุณตลอดกระบวนการทำงานกับไฟล์ Excel โดยใช้ Java ดังนั้นการสนทนาจึง จำกัด อยู่ที่ส่วนประกอบ HSSF และ XSSF

Note - POI เวอร์ชันเก่ารองรับรูปแบบไฟล์ไบนารีเช่น doc, xls, ppt เป็นต้นเวอร์ชัน 3.5 เป็นต้นไป POI รองรับรูปแบบไฟล์ OOXML ของ MS-Office เช่น docx, xlsx, pptx เป็นต้น

เช่นเดียวกับ Apache POI มีไลบรารีอื่น ๆ ที่จัดหาโดยผู้จำหน่ายหลายรายสำหรับการสร้างไฟล์ Excel ซึ่งรวมถึงAspose cells for Java โดย Aspose JXL โดย Commons Libraries และ JExcel โดย Team Dev.

บทนี้จะนำคุณไปสู่รสชาติของ Java Excel API และคุณสมบัติต่างๆ มีผู้จำหน่ายจำนวนมากที่ให้บริการ API ที่เกี่ยวข้องกับ Java Excel บางส่วนได้รับการพิจารณาในบทนี้

Aspose Cells สำหรับ Java

Aspose Cells for Java เป็น Java Excel API ที่ได้รับอนุญาตอย่างหมดจดซึ่งพัฒนาและแจกจ่ายโดยผู้จำหน่าย Aspose เวอร์ชันล่าสุดของ API นี้คือ 8.1.2 ซึ่งเปิดตัวในเดือนกรกฎาคม 2014 เป็น API ที่สมบูรณ์และหนักหน่วง (การรวมกันของคลาส Java ธรรมดาและคลาส AWT) สำหรับการออกแบบคอมโพเนนต์ Excel ที่สามารถอ่านเขียนและจัดการสเปรดชีตได้

การใช้งานทั่วไปของ API นี้มีดังนี้ -

  • การรายงาน Excel สร้างรายงาน Excel แบบไดนามิก
  • การแสดงผลและการพิมพ์ Excel ที่มีความเที่ยงตรงสูง
  • นำเข้าและส่งออกข้อมูลจากสเปรดชีต Excel
  • สร้างแก้ไขและแปลงสเปรดชีต

JXL

JXL เป็นเฟรมเวิร์กของบุคคลที่สามที่ออกแบบมาสำหรับ Selenium ซึ่งสนับสนุนระบบอัตโนมัติที่ขับเคลื่อนด้วยข้อมูลบนเว็บเบราว์เซอร์ (อัปเดตข้อมูลบนเว็บเบราว์เซอร์อัตโนมัติ) อย่างไรก็ตามยังใช้เป็นไลบรารีการสนับสนุนทั่วไปสำหรับ JExcel API เนื่องจากมีคุณสมบัติพื้นฐานในการสร้างอ่านและเขียนสเปรดชีต

คุณสมบัติพื้นฐานมีดังนี้ -

  • สร้างไฟล์ Excel
  • นำเข้าข้อมูลจากสมุดงานและสเปรดชีต
  • รับจำนวนแถวและคอลัมน์ทั้งหมด

Note - JXL รองรับเฉพาะรูปแบบไฟล์. xls และไม่สามารถรองรับปริมาณข้อมูลขนาดใหญ่ได้

JExcel

JExcel เป็น API ที่ได้รับอนุญาตจาก Team Dev เมื่อใช้สิ่งนี้โปรแกรมเมอร์สามารถอ่านเขียนแสดงและปรับเปลี่ยนสมุดงาน Excel ได้ทั้งสองอย่าง.xls และ .xlsxรูปแบบ API นี้สามารถฝังเข้ากับ Java Swing และ AWT ได้อย่างง่ายดาย เวอร์ชันล่าสุดของ API นี้คือ Jexcel-2.6.12 เปิดตัวในปี 2552

คุณสมบัติหลักมีดังนี้ -

  • ทำให้แอปพลิเคชัน Excel สมุดงานสเปรดชีต ฯลฯ เป็นแบบอัตโนมัติ
  • ฝังสมุดงานในแอปพลิเคชัน Java Swing เป็นส่วนประกอบ Swing ธรรมดา
  • เพิ่มผู้ฟังเหตุการณ์ลงในสมุดงานและสเปรดชีต
  • เพิ่มตัวจัดการเหตุการณ์เพื่อจัดการพฤติกรรมของเวิร์กบุ๊กและเหตุการณ์ในสเปรดชีต
  • เพิ่มเพื่อนดั้งเดิมเพื่อพัฒนาฟังก์ชันการทำงานที่กำหนดเอง

Apache POI

Apache POI เป็นไลบรารีโอเพนซอร์ส 100% ที่จัดทำโดย Apache Software Foundation นักพัฒนาแอปพลิเคชันขนาดเล็กและขนาดกลางส่วนใหญ่พึ่งพา Apache POI (HSSF + XSSF) เป็นอย่างมาก รองรับคุณสมบัติพื้นฐานทั้งหมดของไลบรารี Excel อย่างไรก็ตามการแสดงผลและการแยกข้อความเป็นคุณสมบัติหลัก

บทนี้จะนำคุณผ่านขั้นตอนการตั้งค่า Apache POI บนระบบที่ใช้ Windows และ Linux Apache POI สามารถติดตั้งและรวมเข้ากับสภาพแวดล้อม Java ปัจจุบันของคุณได้อย่างง่ายดายโดยทำตามขั้นตอนง่ายๆไม่กี่ขั้นตอนโดยไม่มีขั้นตอนการตั้งค่าที่ซับซ้อน จำเป็นต้องมีการดูแลระบบผู้ใช้ขณะติดตั้ง

ความต้องการของระบบ

JDK Java SE 2 JDK 1.5 ขึ้นไป
หน่วยความจำ RAM 1 GB (แนะนำ)
พื้นที่ดิสก์ ไม่มีข้อกำหนดขั้นต่ำ
เวอร์ชันระบบปฏิบัติการ Windows XP ขึ้นไปลินุกซ์

ให้เราดำเนินการตามขั้นตอนเพื่อติดตั้ง Apache POI

ขั้นตอนที่ 1: ตรวจสอบการติดตั้ง Java ของคุณ

ก่อนอื่นคุณต้องติดตั้ง Java Software Development Kit (SDK) ในระบบของคุณ ในการตรวจสอบสิ่งนี้ให้ดำเนินการคำสั่งใด ๆ จากสองคำสั่งทั้งนี้ขึ้นอยู่กับแพลตฟอร์มที่คุณกำลังทำงานอยู่

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

แพลตฟอร์ม คำสั่ง ตัวอย่างผลลัพธ์
Windows

เปิดคอนโซลคำสั่งและพิมพ์ -

\>java –version

เวอร์ชัน Java "1.7.0_60"

Java (TM) SE Run Time Environment (บิวด์ 1.7.0_60-b19)

Java Hotspot (TM) 64-bit Server VM (build 24.60-b09, mixed mode)
ลินุกซ์

เปิดเทอร์มินัลคำสั่งแล้วพิมพ์ -

$java –version

เวอร์ชัน java "1.7.0_25"

เปิด JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64)

เปิด JDK 64-Bit Server VM (สร้าง 23.7-b01 โหมดผสม)

  • เราถือว่าผู้อ่านบทช่วยสอนนี้ติดตั้ง Java SDK เวอร์ชัน 1.7.0_60 ในระบบของตน

  • ในกรณีที่คุณไม่มี Java SDK ให้ดาวน์โหลดเวอร์ชันปัจจุบันจากไฟล์ https://www.oracle.com/technetwork/java/javase/downloads/index.html และติดตั้ง

ขั้นตอนที่ 2: ตั้งค่าสภาพแวดล้อม Java ของคุณ

ตั้งค่าตัวแปรสภาพแวดล้อม JAVA_HOME ให้ชี้ไปยังตำแหน่งไดเร็กทอรีฐานที่ติดตั้ง Java บนเครื่องของคุณ ตัวอย่างเช่น,

ซีเนียร์ แพลตฟอร์มและคำอธิบาย
1

Windows

ตั้งค่า JAVA_HOME เป็น C: \ ProgramFiles \ java \ jdk1.7.0_60
2

Linux

ส่งออก JAVA_HOME = / usr / local / java-current

ผนวกพา ธ แบบเต็มของตำแหน่งคอมไพเลอร์ Java เข้ากับ System Path

ซีเนียร์ แพลตฟอร์มและคำอธิบาย
1

Windows

ต่อท้าย String "C: \ Program Files \ Java \ jdk1.7.0_60 \ bin" ต่อท้ายตัวแปรระบบ PATH
2

Linux

ส่งออกเส้นทาง = $ PATH: $ JAVA_HOME / bin /

ดำเนินการคำสั่ง java -version จากพรอมต์คำสั่งตามที่อธิบายไว้ข้างต้น

ขั้นตอนที่ 3: ติดตั้ง Apache POI Library

ดาวน์โหลด Apache POI เวอร์ชันล่าสุดจาก https://poi.apache.org/download.htmlและคลายซิปเนื้อหาไปยังโฟลเดอร์ที่สามารถเชื่อมโยงไลบรารีที่ต้องการกับโปรแกรม Java ของคุณได้ ให้เราถือว่าไฟล์ถูกรวบรวมไว้ในโฟลเดอร์บนไดรฟ์ C

ภาพต่อไปนี้แสดงไดเร็กทอรีและโครงสร้างไฟล์ภายในโฟลเดอร์ที่ดาวน์โหลด

เพิ่มเส้นทางที่สมบูรณ์ของทั้งห้า jars ตามที่ไฮไลต์ในภาพด้านบนไปยัง CLASSPATH

ซีเนียร์ แพลตฟอร์มและคำอธิบาย
1

Windows

ต่อท้ายสตริงต่อไปนี้ที่ส่วนท้ายของตัวแปรผู้ใช้

คลาสสพา ธ -

“ C: \ poi-3.9 \ poi-3.9-20121203.jar;”

“ C: \ poi-3.9 \ poi-ooxml-3.9-20121203.jar;”

“ C: \ poi-3.9 \ poi-ooxml-schemas-3.9-20121203.jar;”

“ C: \ poi-3.9 \ ooxml-lib \ dom4j-1.6.1.jar;”

“ C: \ poi-3.9 \ ooxml-lib \ xmlbeans-2.3.0.jar; .;”
2

Linux

ส่งออก CLASSPATH = $ CLASSPATH:

/usr/share/poi-3.9/poi-3.9-20121203.tar:

/usr/share/poi-3.9/poi-ooxml-schemas-3.9-20121203.tar:

/usr/share/poi-3.9/poi-ooxml-3.9-20121203.tar:

/usr/share/poi-3.9/ooxml-lib/dom4j-1.6.1.tar:

/usr/share/poi-3.9/ooxml-lib/xmlbeans-2.3.0.tar

บทนี้จะอธิบายเกี่ยวกับคลาสและวิธีการบางอย่างภายใต้ Apache POI API ที่สำคัญในการทำงานกับไฟล์ Excel โดยใช้โปรแกรม Java

สมุดงาน

นี่คืออินเทอร์เฟซขั้นสูงของคลาสทั้งหมดที่สร้างหรือดูแลสมุดงาน Excel มันเป็นของorg.apache.poi.ss.usermodelแพ็คเกจ สองคลาสที่ใช้อินเทอร์เฟซนี้มีดังนี้ -

  • HSSFWorkbook- คลาสนี้มีวิธีการอ่านและเขียนไฟล์ Microsoft Excel ในรูปแบบ. xls เข้ากันได้กับ MS-Office เวอร์ชัน 97–2003

  • XSSFWorkbook- คลาสนี้มีวิธีการอ่านและเขียนไฟล์ Microsoft Excel และ OpenOffice xml ในรูปแบบ. xls หรือ. xlsx เข้ากันได้กับ MS-Office เวอร์ชัน 2007 หรือใหม่กว่า

HSSFWorkbook

เป็นคลาสระดับสูงภายใต้ org.apache.poi.hssf.usermodelแพ็คเกจ มันใช้Workbookอินเทอร์เฟซและใช้สำหรับไฟล์ Excel ในรูปแบบ. xls ด้านล่างนี้เป็นวิธีการและตัวสร้างบางส่วนภายใต้คลาสนี้

ตัวสร้างคลาส

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

HSSFWorkbook()

สร้างวัตถุ HSSFWorkbook ใหม่ตั้งแต่เริ่มต้น
2

HSSFWorkbook(DirectoryNode directory, boolean preserveNodes)

สร้างวัตถุ HSSFWworkbook ใหม่ภายในไดเร็กทอรีเฉพาะ
3

HSSFWorkbook(DirectoryNode directory, POIFSFileSystem fs, boolean preserveNodes)

ด้วยอ็อบเจ็กต์ POIFSFileSystem และไดเร็กทอรีเฉพาะภายในมันจะสร้างอ็อบเจ็กต์ SSFWorkbook เพื่ออ่านเวิร์กบุ๊กที่ระบุ
4

HSSFWorkbook(java.io.InputStream s)

สร้างอ็อบเจ็กต์ HSSFWorkbook ใหม่โดยใช้อินพุตสตรีม
5

HSSFWorkbook(java.io.InputStream s, boolean preserveNodes)

สร้างระบบไฟล์ POI รอบสตรีมอินพุตของคุณ
6

HSSFWorkbook(POIFSFileSystem fs)

สร้างอ็อบเจ็กต์ HSSFWorkbook ใหม่โดยใช้อ็อบเจ็กต์ POIFSFileSystem
7

HSSFWorkbook(POIFSFileSystem fs, boolean preserveNodes)

ด้วยอ็อบเจ็กต์ POIFSFileSystem จะสร้างอ็อบเจ็กต์ HSSFWorkbook ใหม่เพื่ออ่านเวิร์กบุ๊กที่ระบุ

พารามิเตอร์ที่ใช้บ่อยภายในตัวสร้างเหล่านี้คือ -

  • directory - เป็นไดเร็กทอรีระบบไฟล์ POI ที่จะประมวลผล

  • fs - เป็นระบบไฟล์ POI ที่มีสตรีมสมุดงาน

  • preservenodes- นี่เป็นพารามิเตอร์ทางเลือกที่ตัดสินใจว่าจะรักษาโหนดอื่น ๆ เช่นมาโครหรือไม่ มันใช้หน่วยความจำมากเนื่องจากเก็บ POIFileSystem ทั้งหมดไว้ในหน่วยความจำ (หากตั้งค่าไว้)

Note- คลาส HSSFWorkbook มีหลายวิธี อย่างไรก็ตามเข้ากันได้กับรูปแบบ xls เท่านั้น ในบทช่วยสอนนี้โฟกัสอยู่ที่รูปแบบไฟล์ Excel เวอร์ชันล่าสุด ดังนั้นวิธีการเรียนของ HSSFWorkbook ไม่ได้ระบุไว้ที่นี่ หากคุณต้องการเมธอดคลาสเหล่านี้ให้อ้างอิง POI-HSSFWorkbook class API ที่https://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFWorkbook.html.

XSSFWorkbook

เป็นคลาสที่ใช้เพื่อแสดงรูปแบบไฟล์ Excel ทั้งระดับสูงและระดับต่ำ มันเป็นของorg.apache.xssf.usemodel แพคเกจและดำเนินการ Workbookอินเตอร์เฟซ. ด้านล่างนี้เป็นวิธีการและตัวสร้างภายใต้คลาสนี้

ตัวสร้างคลาส

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

XSSFWorkbook()

สร้างวัตถุ XSSFworkbook ใหม่ตั้งแต่เริ่มต้น
2

XSSFWorkbook(java.io.File file)

สร้างวัตถุ XSSFWorkbook จากไฟล์ที่กำหนด
3

XSSFWorkbook(java.io.InputStream is)

สร้างอ็อบเจ็กต์ XSSFWorkbook โดยการบัฟเฟอร์สตรีมอินพุตทั้งหมดลงในหน่วยความจำจากนั้นเปิดอ็อบเจ็กต์ OPCPackage
4

XSSFWorkbook(java.lang.String path)

สร้างอ็อบเจ็กต์ XSSFWorkbook โดยกำหนดเส้นทางแบบเต็มของไฟล์

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

createSheet()

สร้าง XSSFSheet สำหรับเวิร์กบุ๊กนี้เพิ่มลงในชีตและส่งกลับการแสดงระดับสูง
2

createSheet(java.lang.String sheetname)

สร้างแผ่นงานใหม่สำหรับสมุดงานนี้และส่งคืนการแสดงระดับสูง
3

createFont()

สร้างแบบอักษรใหม่และเพิ่มลงในตารางแบบอักษรของสมุดงาน
4

createCellStyle()

สร้าง XSSFCellStyle ใหม่และเพิ่มลงในตารางสไตล์ของสมุดงาน
5

createFont()

สร้างแบบอักษรใหม่และเพิ่มลงในตารางแบบอักษรของสมุดงาน
6

setPrintArea(int sheetIndex, int startColumn, int endColumn, int startRow,int endRow)

ตั้งค่าพื้นที่พิมพ์ของแผ่นงานที่กำหนดตามพารามิเตอร์ที่ระบุ

สำหรับวิธีการที่เหลือของคลาสนี้โปรดดูเอกสาร API ฉบับสมบูรณ์ที่: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFWorkbook.html. สำหรับรายการวิธีการทั้งหมด

แผ่น

Sheet เป็นอินเทอร์เฟซภายใต้ไฟล์ org.apache.poi.ss.usermodelpackage และเป็น super-interface ของทุกคลาสที่สร้างสเปรดชีตระดับสูงหรือต่ำที่มีชื่อเฉพาะ สเปรดชีตที่พบบ่อยที่สุดคือแผ่นงานซึ่งแสดงเป็นตารางเซลล์

แผ่น HSSFS

นี่คือคลาสภายใต้ org.apache.poi.hssf.usermodelแพ็คเกจ สามารถสร้างสเปรดชีต excel และอนุญาตให้จัดรูปแบบสไตล์ชีตและข้อมูลชีต

ตัวสร้างคลาส

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

HSSFSheet(HSSFWorkbook workbook)

สร้าง HSSFSheet ใหม่ที่เรียกโดย HSSFWorkbook เพื่อสร้างแผ่นงานตั้งแต่เริ่มต้น
2

HSSFSheet(HSSFWorkbook workbook, InternalSheet sheet)

สร้าง HSSFSheet แทนวัตถุแผ่นงานที่กำหนด

XSSFSheet

นี่คือคลาสที่แสดงถึงการแสดงสเปรดชีต excel ระดับสูง มันอยู่ภายใต้org.apache.poi.hssf.usermodel แพ็คเกจ

ตัวสร้างคลาส

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

XSSFSheet()

สร้าง XSSFSheet ใหม่ - เรียกโดย XSSFWorkbook เพื่อสร้างแผ่นงานตั้งแต่เริ่มต้น
2

XSSFSheet(PackagePart part, PackageRelationship rel)

สร้าง XSSFSheet ที่แสดงส่วนของแพ็คเกจและความสัมพันธ์ที่กำหนด

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

addMergedRegion(CellRangeAddress region)

เพิ่มขอบเขตของเซลล์ที่รวมเข้าด้วยกัน (ดังนั้นเซลล์เหล่านั้นจึงรวมกันเป็นหนึ่ง)
2

autoSizeColumn(int column)

ปรับความกว้างของคอลัมน์ให้พอดีกับเนื้อหา
3

iterator()

วิธีนี้เป็นนามแฝงสำหรับ rowIterator () เพื่ออนุญาตให้ foreach ลูป
4

addHyperlink(XSSFHyperlink hyperlink)

ลงทะเบียนไฮเปอร์ลิงก์ในคอลเลกชันของไฮเปอร์ลิงก์บนแผ่นงานนี้

สำหรับวิธีการที่เหลือของคลาสนี้โปรดดู API ทั้งหมดที่: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFSheet.html.

แถว

นี่คืออินเทอร์เฟซภายใต้ไฟล์ org.apache.poi.ss.usermodelแพ็คเกจ ใช้สำหรับการแสดงแถวระดับสูงของสเปรดชีต เป็นซูเปอร์อินเทอร์เฟซของคลาสทั้งหมดที่แสดงแถวในไลบรารี POI

XSSFRow

นี่คือคลาสภายใต้ org.apache.poi.xssf.usermodelแพ็คเกจ ใช้อินเทอร์เฟซ Row ดังนั้นจึงสามารถสร้างแถวในสเปรดชีต ด้านล่างนี้เป็นวิธีการและตัวสร้างภายใต้คลาสนี้

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

createCell(int columnIndex)

สร้างเซลล์ใหม่ภายในแถวและส่งกลับ
2

setHeight(short height)

ตั้งค่าความสูงเป็นหน่วยสั้น

สำหรับวิธีการที่เหลือของคลาสนี้ให้ไปที่ลิงค์ที่ระบุ https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFRow.html

เซลล์

นี่คืออินเทอร์เฟซภายใต้ไฟล์ org.apache.poi.ss.usermodelแพ็คเกจ เป็นซูเปอร์อินเทอร์เฟซของคลาสทั้งหมดที่แสดงเซลล์ในแถวของสเปรดชีต

เซลล์สามารถรับแอตทริบิวต์ต่างๆเช่นว่างตัวเลขวันที่ข้อผิดพลาด ฯลฯ เซลล์ควรมีตัวเลขของตัวเอง (ตาม 0) ก่อนที่จะเพิ่มลงในแถว

XSSFCell

นี่คือคลาสภายใต้ org.apache.poi.xssf.usermodelแพ็คเกจ มันใช้อินเทอร์เฟซเซลล์ เป็นการแสดงเซลล์ระดับสูงในแถวของสเปรดชีต

สรุปฟิลด์

ด้านล่างนี้เป็นฟิลด์บางส่วนของคลาส XSSFCell พร้อมกับคำอธิบาย

ซีเนียร์ ประเภทและคำอธิบายของเซลล์
1

CELL_TYPE_BLANK

แสดงถึงเซลล์ว่าง
2

CELL_TYPE_BOOLEAN

แสดงถึงเซลล์บูลีน (จริงหรือเท็จ)
3

CELL_TYPE_ERROR

แสดงถึงค่าความผิดพลาดบนเซลล์
4

CELL_TYPE_FORMULA

แสดงผลลัพธ์ของสูตรในเซลล์
5

CELL_TYPE_NUMERIC

แสดงข้อมูลตัวเลขบนเซลล์
6

CELL_TYPE_STRING

แสดงสตริง (ข้อความ) บนเซลล์

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

setCellStyle(CellStyle style)

ตั้งค่ารูปแบบสำหรับเซลล์
2

setCellType(int cellType)

ตั้งค่าชนิดของเซลล์ (ตัวเลขสูตรหรือสตริง)
3

setCellValue(boolean value)

ตั้งค่าบูลีนสำหรับเซลล์
4

setCellValue(java.util.Calendar value)

ตั้งค่าวันที่สำหรับเซลล์
5

setCellValue(double value)

ตั้งค่าตัวเลขสำหรับเซลล์
6

setCellValue(java.lang.String str)

ตั้งค่าสตริงสำหรับเซลล์
7

setHyperlink(Hyperlink hyperlink)

กำหนดไฮเปอร์ลิงก์ให้กับเซลล์นี้

สำหรับวิธีการและฟิลด์ที่เหลือของคลาสนี้โปรดไปที่ลิงค์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCell.html

XSSFCellStyle

นี่คือคลาสภายใต้ org.apache.poi.xssf.usermodelแพ็คเกจ จะให้ข้อมูลที่เป็นไปได้เกี่ยวกับรูปแบบของเนื้อหาในเซลล์ของสเปรดชีต นอกจากนี้ยังมีตัวเลือกสำหรับการปรับเปลี่ยนรูปแบบนั้น มันใช้อินเทอร์เฟซ CellStyle

สรุปฟิลด์

ตารางต่อไปนี้แสดงรายการฟิลด์สองสามฟิลด์ที่สืบทอดมาจากอินเทอร์เฟซ CellStyle

ซีเนียร์ ฟิลด์และคำอธิบาย
1

ALIGN_CENTER

จัดกึ่งกลางเนื้อหาของเซลล์
2

ALIGN_CENTER_SELECTION

การจัดตำแหน่งแนวนอนแบบเลือกกึ่งกลาง
3

ALIGN_FILL

เซลล์พอดีกับขนาดเนื้อหา
4

ALIGN_JUSTIFY

ใส่เนื้อหาเซลล์ให้พอดีกับความกว้าง
5

ALIGN_LEFT

จัดแนวเนื้อหาของเซลล์ให้ชิดซ้าย
6

ALIGN_RIGHT

จัดแนวเนื้อหาของเซลล์ให้ถูกต้อง
7

BORDER_DASH_DOT

สไตล์เซลล์ที่มีเส้นประและจุด
8

BORDER_DOTTED

ลักษณะเซลล์ที่มีเส้นประ
9

BORDER_DASHED

สไตล์เซลล์ที่มีเส้นประ
10

BORDER_THICK

ลักษณะเซลล์ที่มีขอบหนา
11

BORDER_THIN

ลักษณะเซลล์ที่มีเส้นขอบบาง ๆ
12

VERTICAL_BOTTOM

จัดแนวเนื้อหาของเซลล์ด้านล่างตามแนวตั้ง
13

VERTICAL_CENTER

จัดแนวเนื้อหาของเซลล์ตรงกลางแนวตั้ง
15

VERTICAL_JUSTIFY

จัดแนวและปรับเนื้อหาของเซลล์ในแนวตั้ง
16

VERTICAL_TOP

การจัดแนวตามแนวตั้งด้านบน

ตัวสร้างคลาส

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

XSSFCellStyle(int cellXfId, int cellStyleXfId, StylesTable stylesSource, ThemesTable theme)

สร้างสไตล์เซลล์จากชิ้นส่วนที่ให้มา
2

XSSFCellStyle(StylesTable stylesSource)

สร้างสไตล์เซลล์ว่าง

วิธีการเรียน

ส. เลขที่ วิธีการและคำอธิบาย
1

setAlignment(short align)

ตั้งค่าประเภทของการจัดแนวแนวนอนสำหรับเซลล์
2

setBorderBottom(short border)

ตั้งค่าประเภทของเส้นขอบสำหรับเส้นขอบด้านล่างของเซลล์
3

setBorderColor(XSSFCellBorder.BorderSide side, XSSFColor color)

ตั้งค่าสีสำหรับเส้นขอบที่เลือก
4

setBorderLeft(Short border)

ตั้งค่าประเภทของเส้นขอบสำหรับเส้นขอบด้านซ้ายของเซลล์
5

setBorderRight(short border)

ตั้งค่าประเภทของเส้นขอบสำหรับเส้นขอบด้านขวาของเซลล์
6

setBorderTop(short border)

ตั้งค่าประเภทของเส้นขอบสำหรับเส้นขอบด้านบนของเซลล์
7

setFillBackgroundColor(XSSFColor color)

ตั้งค่าสีเติมพื้นหลังที่แสดงเป็นค่า XSSFColor
8

setFillForegroundColor(XSSFColor color)

ตั้งค่าสีเติมพื้นหน้าที่แสดงเป็นค่า XSSFColor
9

setFillPattern(short fp)

ระบุข้อมูลการเติมเซลล์สำหรับรูปแบบและการเติมเซลล์สีทึบ
10

setFont(Font font)

ตั้งค่าแบบอักษรสำหรับลักษณะนี้
11

setRotation(short rotation)

ตั้งค่าระดับการหมุนของข้อความในเซลล์
12

setVerticalAlignment(short align)

ตั้งค่าประเภทของการจัดแนวตามแนวตั้งสำหรับเซลล์

สำหรับวิธีการและฟิลด์ที่เหลือในคลาสนี้ให้ไปที่ลิงค์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCellStyle.html

HSSFColor

นี่คือคลาสภายใต้ org.apache.poi.hssf.utilแพ็คเกจ ให้สีที่แตกต่างกันเป็นชั้นเรียนที่ซ้อนกัน โดยปกติคลาสที่ซ้อนกันเหล่านี้จะแสดงโดยใช้ดัชนีของตนเอง ใช้อินเตอร์เฟซสี

คลาสที่ซ้อนกัน

คลาสที่ซ้อนกันทั้งหมดของคลาสนี้เป็นแบบคงที่และแต่ละคลาสมีดัชนี คลาสสีที่ซ้อนกันเหล่านี้ใช้สำหรับการจัดรูปแบบเซลล์เช่นเนื้อหาของเซลล์เส้นขอบพื้นหน้าและพื้นหลัง ด้านล่างนี้คือคลาสที่ซ้อนกัน

ซีเนียร์ ชื่อชั้น (สี)
1 HSSFColor.AQUA
2 HSSFColor อัตโนมัติ
3 HSSFColor.BLACK
4 HSSFColor.BLUE
5 HSSFColor.BRIGHT_GREEN
6 HSSFColor.BRIGHT_GRAY
7 HSSFColor.CORAL
8 HSSFColor.DARK_BLUE
9 HSSFColor.DARK_GREEN
10 HSSFColor.SKY_BLUE
11 HSSFColor สีขาว
12 HSSFColor สีเหลือง

วิธีการเรียน

วิธีการเดียวของคลาสนี้มีความสำคัญและใช้เพื่อรับค่าดัชนี

ซีเนียร์ วิธีการและคำอธิบาย
1

getIndex()

วิธีนี้ใช้เพื่อรับค่าดัชนีของคลาสที่ซ้อนกัน

สำหรับเมธอดที่เหลือและคลาสที่ซ้อนกันโปรดดูลิงก์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/hssf/util/HSSFColor.html

XSSFColor

นี่คือคลาสภายใต้ org.apache.poi.xssf.usermodelแพ็คเกจ ใช้เพื่อแสดงสีในสเปรดชีต ใช้อินเตอร์เฟซสี ด้านล่างนี้เป็นวิธีการและตัวสร้างบางส่วน

ตัวสร้างคลาส

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

XSSFColor()

สร้างอินสแตนซ์ใหม่ของ XSSFColor
2

XSSFColor(byte[] rgb)

สร้างอินสแตนซ์ใหม่ของ XSSFColor โดยใช้ RGB
3

XSSFColor(java.awt.Color clr)

สร้างอินสแตนซ์ใหม่ของ XSSFColor โดยใช้คลาสสีจากแพ็คเกจ awt

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

setAuto(boolean auto)

ตั้งค่าบูลีนเพื่อระบุว่า ctColor เป็นแบบอัตโนมัติและ ctColor ของระบบขึ้นอยู่กับ
2

setIndexed(int indexed)

ตั้งค่า ctColor ที่จัดทำดัชนีเป็น ctColor ของระบบ

สำหรับวิธีการที่เหลือโปรดไปที่ลิงค์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFColor.html

XSSFont

นี่คือคลาสภายใต้ org.apache.poi.xssf.usermodelแพ็คเกจ มันใช้อินเทอร์เฟซแบบอักษรดังนั้นจึงสามารถจัดการแบบอักษรต่างๆในสมุดงานได้

ตัวสร้างคลาส

ซีเนียร์ ตัวสร้างและคำอธิบาย
1

XSSFFont()

สร้างอินสแตนซ์ XSSFont ใหม่

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

setBold(boolean bold)

ตั้งค่าบูลีนสำหรับแอตทริบิวต์ "ตัวหนา"
2

setColor(short color)

ตั้งค่าสีที่จัดทำดัชนีสำหรับฟอนต์
3

setColor(XSSFColor color)

ตั้งค่าสีสำหรับแบบอักษรในค่าสี Standard Alpha RGB
4

setFontHeight(short height)

ตั้งค่าความสูงของแบบอักษรเป็นจุด
5

setFontName(java.lang.String name)

ตั้งชื่อสำหรับฟอนต์
6

setItalic(boolean italic)

ตั้งค่าบูลีนสำหรับคุณสมบัติ 'italic'

สำหรับวิธีการที่เหลือไปที่ลิงค์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFFont.html

XSSF Hyperlink

นี่คือคลาสภายใต้ org.apache.poi.xssf.usermodelแพ็คเกจ ใช้อินเทอร์เฟซไฮเปอร์ลิงก์ ใช้เพื่อตั้งค่าไฮเปอร์ลิงก์ไปยังเนื้อหาเซลล์ของสเปรดชีต

ฟิลด์

ฟิลด์ของคลาสนี้มีดังนี้ ในที่นี้ฟิลด์หมายถึงประเภทของไฮเปอร์ลิงก์ที่ใช้

ซีเนียร์ ฟิลด์และคำอธิบาย
1

LINK_DOCUMENT

ใช้เพื่อเชื่อมโยงเอกสารอื่น ๆ
2

LINK_EMAIL

ใช้เพื่อเชื่อมโยงอีเมล
3

LINK_FILE

ใช้เพื่อเชื่อมโยงไฟล์อื่น ๆ ในรูปแบบใดก็ได้
4

LINK_URL

ใช้เพื่อเชื่อมโยง URL ของเว็บ

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

setAddress(java.lang.String address)

ที่อยู่ไฮเปอร์ลิงก์

สำหรับวิธีการที่เหลือโปรดไปที่ลิงค์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFHyperlink.html

XSSFCreationHelper

นี่คือคลาสภายใต้ org.apache.poi.xssf.usermodelแพ็คเกจ มันใช้อินเทอร์เฟซ CreationHelper ใช้เป็นคลาสสนับสนุนสำหรับการประเมินสูตรและการตั้งค่าไฮเปอร์ลิงก์

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

createFormulaEvaluator()

สร้างอินสแตนซ์ XSSFFormulaEvaluator ซึ่งเป็นวัตถุที่ประเมินเซลล์สูตร
2

createHyperlink(int type)

สร้าง XSSFHyperlink ใหม่

สำหรับวิธีการที่เหลือโปรดดูลิงค์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCreationHelper.html

XSSFPrintSetup

นี่คือคลาสภายใต้ org.apache.poi.xsssf.usermodelแพ็คเกจ มันใช้PrintSetupอินเตอร์เฟซ. ใช้เพื่อกำหนดขนาดหน้าพิมพ์พื้นที่ตัวเลือกและการตั้งค่า

วิธีการเรียน

ซีเนียร์ วิธีการและคำอธิบาย
1

setLandscape(boolean ls)

ตั้งค่าบูลีนเพื่ออนุญาตหรือบล็อกการพิมพ์แนวนอน
2

setLeftToRight(boolean ltor)

ตั้งค่าว่าจะไปทางซ้ายไปขวาหรือจากบนลงล่างตามลำดับขณะพิมพ์
3

setPaperSize(short size)

ตั้งค่าขนาดกระดาษ

สำหรับวิธีการที่เหลือโปรดไปที่ลิงค์ต่อไปนี้: https://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFPrintSetup.html

ในที่นี้คำว่า 'สมุดงาน' หมายถึงไฟล์ Microsoft Excel หลังจากเสร็จสิ้นบทนี้คุณจะสามารถสร้างสมุดงานใหม่และเปิดสมุดงานที่มีอยู่ด้วยโปรแกรม Java ของคุณ

สร้างสมุดงานเปล่า

โปรแกรมง่ายๆต่อไปนี้ใช้เพื่อสร้างสมุดงาน Microsoft Excel เปล่า

import java.io.*;
import org.apache.poi.xssf.usermodel.*;

public class CreateWorkBook {
   public static void main(String[] args)throws Exception {
      //Create Blank workbook
      XSSFWorkbook workbook = new XSSFWorkbook(); 

      //Create file system using specific name
      FileOutputStream out = new FileOutputStream(new File("createworkbook.xlsx"));

      //write operation workbook using file out object 
      workbook.write(out);
      out.close();
      System.out.println("createworkbook.xlsx written successfully");
   }
}

ให้เราบันทึกโค้ด Java ด้านบนเป็น CreateWorkBook.javaจากนั้นรวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้ -

$javac CreateWorkBook.java $java CreateWorkBook

หากสภาพแวดล้อมระบบของคุณถูกกำหนดค่าด้วยไลบรารี POI ระบบจะคอมไพล์และดำเนินการเพื่อสร้างไฟล์ Excel เปล่าที่ชื่อ createworkbook.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้ในพรอมต์คำสั่ง

createworkbook.xlsx written successfully

เปิดสมุดงานที่มีอยู่

ใช้รหัสต่อไปนี้เพื่อเปิดสมุดงานที่มีอยู่

import java.io.*;
import org.apache.poi.xssf.usermodel.*;

public class OpenWorkBook {
   public static void main(String args[])throws Exception { 
      File file = new File("openworkbook.xlsx");
      FileInputStream fIP = new FileInputStream(file);
      
      //Get the workbook instance for XLSX file 
      XSSFWorkbook workbook = new XSSFWorkbook(fIP);
      
      if(file.isFile() && file.exists()) {
         System.out.println("openworkbook.xlsx file open successfully.");
      } else {
         System.out.println("Error to open openworkbook.xlsx file.");
      }
   }
}

บันทึกโค้ด Java ด้านบนเป็น OpenWorkBook.javaจากนั้นรวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้ -

$javac OpenWorkBook.java $java OpenWorkBook

มันจะคอมไพล์และดำเนินการเพื่อสร้างผลลัพธ์ต่อไปนี้

openworkbook.xlsx file open successfully.

หลังจากเปิดเวิร์กบุ๊กคุณสามารถดำเนินการอ่านและเขียนได้

บทนี้อธิบายวิธีสร้างสเปรดชีตและจัดการโดยใช้ Java สเปรดชีตคือหน้าในไฟล์ Excel ประกอบด้วยแถวและคอลัมน์ที่มีชื่อเฉพาะ

หลังจากจบบทนี้แล้วคุณจะสามารถสร้างสเปรดชีตและดำเนินการอ่านได้

สร้างสเปรดชีต

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

ข้อมูลโค้ดต่อไปนี้ใช้เพื่อสร้างสเปรดชีต

//Create Blank workbook
XSSFWorkbook workbook = new XSSFWorkbook();

//Create a blank spreadsheet
XSSFSheet spreadsheet = workbook.createSheet("Sheet Name");

แถวบนสเปรดชีต

สเปรดชีตมีเค้าโครงตาราง แถวและคอลัมน์ถูกระบุด้วยชื่อเฉพาะ คอลัมน์จะระบุด้วยตัวอักษรและแถวด้วยตัวเลข

ข้อมูลโค้ดต่อไปนี้ใช้เพื่อสร้างแถว

XSSFRow row = spreadsheet.createRow((short)1);

เขียนลงในสเปรดชีต

ให้เราพิจารณาตัวอย่างของข้อมูลพนักงาน ข้อมูลพนักงานจะได้รับในรูปแบบตาราง

รหัส Emp ชื่อ Emp การกำหนด
Tp01 โกปาล ผู้จัดการฝ่ายเทคนิค
TP02 มานิชา เครื่องอ่านหลักฐาน
Tp03 มาธาน นักเขียนด้านเทคนิค
Tp04 Satish นักเขียนด้านเทคนิค
Tp05 กฤษณะ นักเขียนด้านเทคนิค

รหัสต่อไปนี้ใช้เพื่อเขียนข้อมูลข้างต้นลงในสเปรดชีต

import java.io.File;
import java.io.FileOutputStream;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Writesheet {
   public static void main(String[] args) throws Exception {

      //Create blank workbook
      XSSFWorkbook workbook = new XSSFWorkbook(); 

      //Create a blank sheet
      XSSFSheet spreadsheet = workbook.createSheet(" Employee Info ");

      //Create row object
      XSSFRow row;

      //This data needs to be written (Object[])
      Map < String, Object[] > empinfo = 
      new TreeMap < String, Object[] >();
      empinfo.put( "1", new Object[] { "EMP ID", "EMP NAME", "DESIGNATION" });
      empinfo.put( "2", new Object[] { "tp01", "Gopal", "Technical Manager" });
      empinfo.put( "3", new Object[] { "tp02", "Manisha", "Proof Reader" });
      empinfo.put( "4", new Object[] { "tp03", "Masthan", "Technical Writer" });
      empinfo.put( "5", new Object[] { "tp04", "Satish", "Technical Writer" });
      empinfo.put( "6", new Object[] { "tp05", "Krishna", "Technical Writer" });
      
      //Iterate over data and write to sheet
      Set < String > keyid = empinfo.keySet();
      int rowid = 0;

      for (String key : keyid) {
         row = spreadsheet.createRow(rowid++);
         Object [] objectArr = empinfo.get(key);
         int cellid = 0;

         for (Object obj : objectArr) {
            Cell cell = row.createCell(cellid++);
            cell.setCellValue((String)obj);
         }
      }

      //Write the workbook in file system
      FileOutputStream out = new FileOutputStream(new File("Writesheet.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("Writesheet.xlsx written successfully");
   }
}

บันทึกโค้ด Java ด้านบนเป็น Writesheet.javaแล้วคอมไพล์และเรียกใช้จากพรอมต์คำสั่งดังนี้ -

$javac Writesheet.java $java Writesheet

มันจะรวบรวมและดำเนินการเพื่อสร้างไฟล์ Excel ชื่อ Writesheet.xlsx ในไดเร็กทอรีปัจจุบันของคุณและคุณจะได้รับผลลัพธ์ต่อไปนี้ในพรอมต์คำสั่ง

Writesheet.xlsx written successfully

Writesheet.xlsx ไฟล์มีลักษณะดังนี้

อ่านจากสเปรดชีต

ให้เราพิจารณาไฟล์ excel ด้านบนที่ชื่อ Writesheet.xslxเป็นอินพุต สังเกตรหัสต่อไปนี้ ใช้สำหรับอ่านข้อมูลจากสเปรดชีต

import java.io.File;
import java.io.FileInputStream;

import java.util.Iterator;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Readsheet {
   static XSSFRow row;
   public static void main(String[] args) throws Exception {
      FileInputStream fis = new FileInputStream(new File("WriteSheet.xlsx"));
      
      XSSFWorkbook workbook = new XSSFWorkbook(fis);
      XSSFSheet spreadsheet = workbook.getSheetAt(0);
      Iterator < Row >  rowIterator = spreadsheet.iterator();
      
      while (rowIterator.hasNext()) {
         row = (XSSFRow) rowIterator.next();
         Iterator < Cell >  cellIterator = row.cellIterator();
         
         while ( cellIterator.hasNext()) {
            Cell cell = cellIterator.next();
            
            switch (cell.getCellType()) {
               case Cell.CELL_TYPE_NUMERIC:
                  System.out.print(cell.getNumericCellValue() + " \t\t ");
                  break;
               
               case Cell.CELL_TYPE_STRING:
                  System.out.print(
                  cell.getStringCellValue() + " \t\t ");
                  break;
            }
         }
         System.out.println();
      }
      fis.close();
   }
}

ให้เราเก็บรหัสด้านบนไว้ Readsheet.java จากนั้นคอมไพล์และเรียกใช้จากพรอมต์คำสั่งดังต่อไปนี้ -

$javac Readsheet.java $java Readsheet

หากสภาพแวดล้อมระบบของคุณถูกกำหนดค่าด้วยไลบรารี POI ระบบจะคอมไพล์และดำเนินการเพื่อสร้างเอาต์พุตต่อไปนี้ในพรอมต์คำสั่ง

EMP ID   EMP NAME       DESIGNATION 
 tp01     Gopal       Technical Manager 
 tp02     Manisha     Proof Reader 
 tp03     Masthan     Technical Writer 
 tp04     Satish      Technical Writer 
 tp05     Krishna     Technical Writer

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

สร้างเซลล์

คุณต้องสร้างแถวก่อนสร้างเซลล์ แถวเป็นเพียงชุดของเซลล์

ข้อมูลโค้ดต่อไปนี้ใช้สำหรับสร้างเซลล์

//create new workbook
XSSFWorkbook workbook = new XSSFWorkbook(); 

//create spreadsheet with a name
XSSFSheet spreadsheet = workbook.createSheet("new sheet");

//create first row on a created spreadsheet
XSSFRow row = spreadsheet.createRow(0);

//create first cell on created row
XSSFCell cell = row.createCell(0);

ประเภทของเซลล์

ประเภทเซลล์ระบุว่าเซลล์สามารถมีสตริงค่าตัวเลขหรือสูตรได้หรือไม่ เซลล์สตริงไม่สามารถเก็บค่าตัวเลขและเซลล์ตัวเลขไม่สามารถเก็บสตริงได้ ด้านล่างนี้คือประเภทของเซลล์ค่าและประเภทไวยากรณ์

ประเภทของค่าเซลล์ พิมพ์ไวยากรณ์
ค่าเซลล์ว่าง XSSFCell.CELL_TYPE_BLANK
ค่าเซลล์บูลีน XSSFCell.CELL.TYPE_BOOLEAN
ค่าเซลล์ผิดพลาด XSSFCell.CELL_TYPE_ERROR
ค่าเซลล์ตัวเลข XSSFCell.CELL_TYPE_NUMERIC
ค่าเซลล์สตริง XSSFCell.CELL_TYPE_STRING

รหัสต่อไปนี้ใช้เพื่อสร้างเซลล์ประเภทต่างๆในสเปรดชีต

import java.io.File;
import java.io.FileOutputStream;

import java.util.Date;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class TypesofCells {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("cell types");
      
      XSSFRow row = spreadsheet.createRow((short) 2);
      row.createCell(0).setCellValue("Type of Cell");
      row.createCell(1).setCellValue("cell value");
      
      row = spreadsheet.createRow((short) 3);
      row.createCell(0).setCellValue("set cell type BLANK");
      row.createCell(1);
      
      row = spreadsheet.createRow((short) 4);
      row.createCell(0).setCellValue("set cell type BOOLEAN");
      row.createCell(1).setCellValue(true);
      
      row = spreadsheet.createRow((short) 5);
      row.createCell(0).setCellValue("set cell type ERROR");
      row.createCell(1).setCellValue(XSSFCell.CELL_TYPE_ERROR );
      
      row = spreadsheet.createRow((short) 6);
      row.createCell(0).setCellValue("set cell type date");
      row.createCell(1).setCellValue(new Date());
      
      row = spreadsheet.createRow((short) 7);
      row.createCell(0).setCellValue("set cell type numeric");
      row.createCell(1).setCellValue(20 );
      
      row = spreadsheet.createRow((short) 8);
      row.createCell(0).setCellValue("set cell type string");
      row.createCell(1).setCellValue("A String");
      
      FileOutputStream out = new FileOutputStream(new File("typesofcells.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("typesofcells.xlsx written successfully");
   }
}

บันทึกรหัสข้างต้นในไฟล์ชื่อ TypesofCells.javaรวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้

$javac TypesofCells.java $java TypesofCells

หากระบบของคุณถูกกำหนดค่าด้วยไลบรารี POI ระบบจะคอมไพล์และดำเนินการเพื่อสร้างไฟล์ Excel ที่มีชื่อว่า typesofcells.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้

typesofcells.xlsx written successfully

typesofcells.xlsx ไฟล์มีลักษณะดังนี้

ลักษณะเซลล์

ที่นี่คุณสามารถเรียนรู้วิธีจัดรูปแบบเซลล์และใช้สไตล์ต่างๆเช่นการผสานเซลล์ที่อยู่ติดกันการเพิ่มเส้นขอบการตั้งค่าการจัดแนวเซลล์และการเติมสี

รหัสต่อไปนี้ใช้เพื่อใช้สไตล์ต่างๆกับเซลล์โดยใช้การเขียนโปรแกรม Java

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class CellStyle {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("cellstyle");
      XSSFRow row = spreadsheet.createRow((short) 1);
      row.setHeight((short) 800);
      XSSFCell cell = (XSSFCell) row.createCell((short) 1);
      cell.setCellValue("test of merging");

      //MEARGING CELLS 
      //this statement for merging cells

      spreadsheet.addMergedRegion(
         new CellRangeAddress(
            1, //first row (0-based)
            1, //last row (0-based)
            1, //first column (0-based)
            4 //last column (0-based)
         )
      );
      
      //CELL Alignment
      row = spreadsheet.createRow(5); 
      cell = (XSSFCell) row.createCell(0);
      row.setHeight((short) 800);
      
      // Top Left alignment 
      XSSFCellStyle style1 = workbook.createCellStyle();
      spreadsheet.setColumnWidth(0, 8000);
      style1.setAlignment(XSSFCellStyle.ALIGN_LEFT);
      style1.setVerticalAlignment(XSSFCellStyle.VERTICAL_TOP);
      cell.setCellValue("Top Left");
      cell.setCellStyle(style1);
      row = spreadsheet.createRow(6); 
      cell = (XSSFCell) row.createCell(1);
      row.setHeight((short) 800);
      
      // Center Align Cell Contents 
      XSSFCellStyle style2 = workbook.createCellStyle();
      style2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
      style2.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
      cell.setCellValue("Center Aligned"); 
      cell.setCellStyle(style2);
      row = spreadsheet.createRow(7); 
      cell = (XSSFCell) row.createCell(2);
      row.setHeight((short) 800);
      
      // Bottom Right alignment 
      XSSFCellStyle style3 = workbook.createCellStyle();
      style3.setAlignment(XSSFCellStyle.ALIGN_RIGHT);
      style3.setVerticalAlignment(XSSFCellStyle.VERTICAL_BOTTOM);
      cell.setCellValue("Bottom Right");
      cell.setCellStyle(style3);
      row = spreadsheet.createRow(8);
      cell = (XSSFCell) row.createCell(3);
      
      // Justified Alignment 
      XSSFCellStyle style4 = workbook.createCellStyle();
      style4.setAlignment(XSSFCellStyle.ALIGN_JUSTIFY);
      style4.setVerticalAlignment(XSSFCellStyle.VERTICAL_JUSTIFY);
      cell.setCellValue("Contents are Justified in Alignment"); 
      cell.setCellStyle(style4);
      
      //CELL BORDER
      row = spreadsheet.createRow((short) 10);
      row.setHeight((short) 800);
      cell = (XSSFCell) row.createCell((short) 1);
      cell.setCellValue("BORDER");
      
      XSSFCellStyle style5 = workbook.createCellStyle();
      style5.setBorderBottom(XSSFCellStyle.BORDER_THICK);
      style5.setBottomBorderColor(IndexedColors.BLUE.getIndex());
      style5.setBorderLeft(XSSFCellStyle.BORDER_DOUBLE);
      style5.setLeftBorderColor(IndexedColors.GREEN.getIndex());
      style5.setBorderRight(XSSFCellStyle.BORDER_HAIR);
      style5.setRightBorderColor(IndexedColors.RED.getIndex());
      style5.setBorderTop(XSSFCellStyle.BIG_SPOTS);
      style5.setTopBorderColor(IndexedColors.CORAL.getIndex());
      cell.setCellStyle(style5);
      
      //Fill Colors
      //background color
      row = spreadsheet.createRow((short) 10 );
      cell = (XSSFCell) row.createCell((short) 1);
      
      XSSFCellStyle style6 = workbook.createCellStyle();
      style6.setFillBackgroundColor(HSSFColor.LEMON_CHIFFON.index );
      style6.setFillPattern(XSSFCellStyle.LESS_DOTS);
      style6.setAlignment(XSSFCellStyle.ALIGN_FILL);
      spreadsheet.setColumnWidth(1,8000);
      cell.setCellValue("FILL BACKGROUNG/FILL PATTERN");
      cell.setCellStyle(style6);
      
      //Foreground color
      row = spreadsheet.createRow((short) 12);
      cell = (XSSFCell) row.createCell((short) 1);
      
      XSSFCellStyle style7 = workbook.createCellStyle();
      style7.setFillForegroundColor(HSSFColor.BLUE.index);
      style7.setFillPattern( XSSFCellStyle.LESS_DOTS);
      style7.setAlignment(XSSFCellStyle.ALIGN_FILL);
      cell.setCellValue("FILL FOREGROUND/FILL PATTERN");
      cell.setCellStyle(style7);

      FileOutputStream out = new FileOutputStream(new File("cellstyle.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("cellstyle.xlsx written successfully");
   }
}

บันทึกรหัสข้างต้นในไฟล์ชื่อ CellStyle.javaรวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้

$javac CellStyle.java $java CellStyle

มันจะสร้างไฟล์ Excel ชื่อ cellstyle.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้

cellstyle.xlsx written successfully

ไฟล์ cellstyle.xlsx มีลักษณะดังนี้

บทนี้จะอธิบายถึงวิธีการตั้งค่าฟอนต์ต่างๆปรับใช้สไตล์และแสดงข้อความในมุมทิศทางต่างๆในสเปรดชีต Excel

ทุกระบบมาพร้อมกับชุดฟอนต์มากมายเช่น Arial, Impact, Times New Roman และอื่น ๆ นอกจากนี้คอลเลคชันยังสามารถอัปเดตด้วยฟอนต์ใหม่ได้หากจำเป็น ในทำนองเดียวกันมีรูปแบบต่างๆที่สามารถแสดงแบบอักษรได้เช่นตัวหนาตัวเอียงขีดเส้นใต้ขีดทับ ฯลฯ

แบบอักษรและแบบอักษร

รหัสต่อไปนี้ใช้เพื่อใช้ฟอนต์และสไตล์เฉพาะกับเนื้อหาของเซลล์

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class FontStyle {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Fontstyle");
      XSSFRow row = spreadsheet.createRow(2);

      //Create a new font and alter it.
      XSSFFont font = workbook.createFont();
      font.setFontHeightInPoints((short) 30);
      font.setFontName("IMPACT");
      font.setItalic(true);
      font.setColor(HSSFColor.BRIGHT_GREEN.index);

      //Set font into style
      XSSFCellStyle style = workbook.createCellStyle();
      style.setFont(font);

      // Create a cell with a value and set style to it.
      XSSFCell cell = row.createCell(1);
      cell.setCellValue("Font Style");
      cell.setCellStyle(style);
      
      FileOutputStream out = new FileOutputStream(new File("fontstyle.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("fontstyle.xlsx written successfully");
   }
}

ให้เราบันทึกรหัสข้างต้นในไฟล์ชื่อ FontStyle.java. รวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้

$javac FontStyle.java $java FontStyle

มันสร้างไฟล์ Excel ชื่อ fontstyle.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้บนพรอมต์คำสั่ง

fontstyle.xlsx written successfully

fontstyle.xlsx ไฟล์มีลักษณะดังนี้

ทิศทางข้อความ

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

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class TextDirection {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Text direction");
      XSSFRow row = spreadsheet.createRow(2);
      XSSFCellStyle myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 0);
      XSSFCell cell = row.createCell(1);
      cell.setCellValue("0D angle");
      cell.setCellStyle(myStyle);

      //30 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 30);
      cell = row.createCell(3);
      cell.setCellValue("30D angle");
      cell.setCellStyle(myStyle);

      //90 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 90);
      cell = row.createCell(5);
      cell.setCellValue("90D angle");
      cell.setCellStyle(myStyle);

      //120 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 120);
      cell = row.createCell(7);
      cell.setCellValue("120D angle");
      cell.setCellStyle(myStyle);

      //270 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 270);
      cell = row.createCell(9);
      cell.setCellValue("270D angle");
      cell.setCellStyle(myStyle);

      //360 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 360);
      cell = row.createCell(12);
      cell.setCellValue("360D angle");
      cell.setCellStyle(myStyle);
      
      FileOutputStream out = new FileOutputStream(new File("textdirection.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("textdirection.xlsx written successfully");
   }
}

เก็บรหัสด้านบนไว้ TextDirectin.java จากนั้นคอมไพล์และเรียกใช้งานจากพรอมต์คำสั่งดังต่อไปนี้

$javac TextDirection.java $java TextDirection

มันจะรวบรวมและดำเนินการเพื่อสร้างไฟล์ Excel ชื่อ textdirection.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้บนพรอมต์คำสั่ง

textdirection.xlsx written successfully

textdirection.xlsx ไฟล์มีลักษณะดังนี้

บทนี้จะนำคุณเข้าสู่ขั้นตอนการใช้สูตรต่างๆบนเซลล์โดยใช้การเขียนโปรแกรม Java วัตถุประสงค์พื้นฐานของแอปพลิเคชัน Excel คือการรักษาข้อมูลที่เป็นตัวเลขโดยใช้สูตรกับมัน

ในสูตรเราส่งผ่านค่าไดนามิกหรือตำแหน่งของค่าในแผ่นงาน Excel เมื่อดำเนินการตามสูตรนี้คุณจะได้ผลลัพธ์ที่ต้องการ ตารางต่อไปนี้แสดงสูตรพื้นฐานสองสามสูตรที่ใช้บ่อยใน Excel

การดำเนินการ ไวยากรณ์
การเพิ่มตัวเลขหลายตัว = SUM (Loc1: Locn) or = SUM (n1, n2,)
นับ = COUNT (Loc1: Locn) or = COUNT (n1, n2,)
พลังของตัวเลขสองตัว = พลังงาน (Loc1, Loc2) or = POWER (ตัวเลขกำลัง)
จำนวนสูงสุดของตัวเลข = สูงสุด (Loc1: Locn) or = สูงสุด (n1, n2,)
สินค้า = ผลิตภัณฑ์ (Loc1: Locn) or = ผลิตภัณฑ์ (n1, n2,)
แฟกทอเรียล = FACT (Locn) or = FACT (ตัวเลข)
จำนวนสัมบูรณ์ = ABS (Locn) or = ABS (ตัวเลข)
วันนี้วันที่ = วันนี้ ()
แปลงตัวพิมพ์เล็ก = ล่าง (Locn) or = LOWER (ข้อความ)
รากที่สอง = SQRT (locn) or = SQRT (ตัวเลข)

รหัสต่อไปนี้ใช้เพื่อเพิ่มสูตรลงในเซลล์และดำเนินการ

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Formula {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("formula");
      XSSFRow row = spreadsheet.createRow(1);
      XSSFCell cell = row.createCell(1);
      
      cell.setCellValue("A = ");
      cell = row.createCell(2);
      cell.setCellValue(2);
      row = spreadsheet.createRow(2);
      cell = row.createCell(1);
      cell.setCellValue("B = ");
      cell = row.createCell(2);
      cell.setCellValue(4);
      row = spreadsheet.createRow(3);
      cell = row.createCell(1);
      cell.setCellValue("Total = ");
      cell = row.createCell(2);
      
      // Create SUM formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("SUM(C2:C3)");
      cell = row.createCell(3);
      cell.setCellValue("SUM(C2:C3)");
      row = spreadsheet.createRow(4);
      cell = row.createCell(1);
      cell.setCellValue("POWER =");
      cell=row.createCell(2);
      
      // Create POWER formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("POWER(C2,C3)");
      cell = row.createCell(3);
      cell.setCellValue("POWER(C2,C3)");
      row = spreadsheet.createRow(5);
      cell = row.createCell(1);
      cell.setCellValue("MAX = ");
      cell = row.createCell(2);
      
      // Create MAX formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("MAX(C2,C3)");
      cell = row.createCell(3);
      cell.setCellValue("MAX(C2,C3)");
      row = spreadsheet.createRow(6);
      cell = row.createCell(1);
      cell.setCellValue("FACT = ");
      cell = row.createCell(2);
      
      // Create FACT formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("FACT(C3)");
      cell = row.createCell(3);
      cell.setCellValue("FACT(C3)");
      row = spreadsheet.createRow(7);
      cell = row.createCell(1);
      cell.setCellValue("SQRT = ");
      cell = row.createCell(2);
      
      // Create SQRT formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("SQRT(C5)");
      cell = row.createCell(3);
      cell.setCellValue("SQRT(C5)");
      workbook.getCreationHelper().createFormulaEvaluator().evaluateAll();
      FileOutputStream out = new FileOutputStream(new File("formula.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("fromula.xlsx written successfully");
   }
}

บันทึกรหัสด้านบนเป็น Formula.java จากนั้นรวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้

$javac Formula.java $java Formula

มันจะสร้างไฟล์ Excel ชื่อ formula.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้บนพรอมต์คำสั่ง

fromula.xlsx written successfully

formula.xlsx ไฟล์มีลักษณะดังนี้

บทนี้จะอธิบายถึงวิธีการเพิ่มไฮเปอร์ลิงก์ไปยังเนื้อหาในเซลล์ โดยปกติแล้วไฮเปอร์ลิงก์จะใช้เพื่อเข้าถึง URL ของเว็บอีเมลหรือไฟล์ภายนอก

รหัสต่อไปนี้แสดงวิธีสร้างไฮเปอร์ลิงก์บนเซลล์

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.common.usermodel.Hyperlink;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFHyperlink;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class HyperlinkEX {
   public static void main(String[] args) throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Hyperlinks");
      XSSFCell cell;
      CreationHelper createHelper = workbook.getCreationHelper();
      XSSFCellStyle hlinkstyle = workbook.createCellStyle();
      XSSFFont hlinkfont = workbook.createFont();
      hlinkfont.setUnderline(XSSFFont.U_SINGLE);
      hlinkfont.setColor(HSSFColor.BLUE.index);
      hlinkstyle.setFont(hlinkfont);

      //URL Link
      cell = spreadsheet.createRow(1).createCell((short) 1);
      cell.setCellValue("URL Link");
      XSSFHyperlink link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_URL);
      link.setAddress("http://www.tutorialspoint.com/");
      cell.setHyperlink((XSSFHyperlink) link);
      cell.setCellStyle(hlinkstyle);

      //Hyperlink to a file in the current directory
      cell = spreadsheet.createRow(2).createCell((short) 1);
      cell.setCellValue("File Link");
      link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_FILE);
      link.setAddress("cellstyle.xlsx");
      cell.setHyperlink(link);
      cell.setCellStyle(hlinkstyle);

      //e-mail link
      cell = spreadsheet.createRow(3).createCell((short) 1);
      cell.setCellValue("Email Link");
      link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_EMAIL);
      link.setAddress("mailto:[email protected]?" + "subject = Hyperlink");
      cell.setHyperlink(link);
      cell.setCellStyle(hlinkstyle);
      
      FileOutputStream out = new FileOutputStream(new File("hyperlink.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("hyperlink.xlsx written successfully");
   }
}

บันทึกรหัสด้านบนเป็น HyperlinkEX.java. รวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้

$javac HyperlinkEX.java $java HyperlinkEX

มันจะสร้างไฟล์ Excel ชื่อ hyperlink.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้บนพรอมต์คำสั่ง

hyperlink.xlsx written successfully

hyperlink.xlsx ไฟล์มีลักษณะดังนี้

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

รหัสต่อไปนี้ใช้เพื่อตั้งค่าพื้นที่พิมพ์บนสเปรดชีต

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFPrintSetup;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class PrintArea {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Print Area");

      //set print area with indexes
      workbook.setPrintArea(
         0, //sheet index
         0, //start column
         5, //end column
         0, //start row
         5 //end row
      );
      
      //set paper size
      spreadsheet.getPrintSetup().setPaperSize(XSSFPrintSetup.A4_PAPERSIZE);
      
      //set display grid lines or not
      spreadsheet.setDisplayGridlines(true);
      
      //set print grid lines or not
      spreadsheet.setPrintGridlines(true);
      
      FileOutputStream out = new FileOutputStream(new File("printarea.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("printarea.xlsx written successfully"); 
   }
}

ให้เราบันทึกรหัสด้านบนเป็น PrintArea.java. รวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้

$javac PrintArea.java $java PrintArea

มันจะสร้างไฟล์ชื่อ printarea.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้บนพรอมต์คำสั่ง

printarea.xlsx written successfully

ในโค้ดด้านบนเรายังไม่ได้เพิ่มค่าเซลล์ใด ๆ ดังนั้นprintarea.xlsxเป็นไฟล์เปล่า แต่คุณสามารถสังเกตได้ในรูปต่อไปนี้ว่าตัวอย่างก่อนพิมพ์จะแสดงพื้นที่พิมพ์ด้วยเส้นตาราง

บทนี้จะอธิบายถึงวิธีที่ไลบรารี POI โต้ตอบกับฐานข้อมูล ด้วยความช่วยเหลือของ JDBC คุณสามารถดึงข้อมูลจากฐานข้อมูลและแทรกข้อมูลนั้นลงในสเปรดชีตโดยใช้ไลบรารี POI ให้เราพิจารณาฐานข้อมูล MySQL สำหรับการดำเนินการ SQL

เขียนลงใน Excel จากฐานข้อมูล

ให้เราถือว่าตารางข้อมูลพนักงานต่อไปนี้เรียกว่า emp_tbl จะถูกดึงมาจากฐานข้อมูล MySQL test.

รหัส EMP ชื่อ EMP DEG เงินเดือน ทบ
1201 โกปาล ผู้จัดการฝ่ายเทคนิค 45000 มัน
1202 มานิชา เครื่องอ่านหลักฐาน 45000 การทดสอบ
1203 Masthanvali นักเขียนด้านเทคนิค 45000 มัน
1204 Kiran Hr Admin 40000 ชม
1205 กระท้อน Op Admin 30000 ธุรการ

ใช้รหัสต่อไปนี้เพื่อดึงข้อมูลจากฐานข้อมูลและแทรกข้อมูลเดียวกันลงในสเปรดชีต

import java.io.File;
import java.io.FileOutputStream;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class ExcelDatabase {
   public static void main(String[] args) throws Exception {
      Class.forName("com.mysql.jdbc.Driver");
      Connection connect = DriverManager.getConnection( 
         "jdbc:mysql://localhost:3306/test" , 
         "root" , 
         "root"
      );
      
      Statement statement = connect.createStatement();
      ResultSet resultSet = statement.executeQuery("select * from emp_tbl");
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("employe db");
      
      XSSFRow row = spreadsheet.createRow(1);
      XSSFCell cell;
      cell = row.createCell(1);
      cell.setCellValue("EMP ID");
      cell = row.createCell(2);
      cell.setCellValue("EMP NAME");
      cell = row.createCell(3);
      cell.setCellValue("DEG");
      cell = row.createCell(4);
      cell.setCellValue("SALARY");
      cell = row.createCell(5);
      cell.setCellValue("DEPT");
      int i = 2;

      while(resultSet.next()) {
         row = spreadsheet.createRow(i);
         cell = row.createCell(1);
         cell.setCellValue(resultSet.getInt("eid"));
         cell = row.createCell(2);
         cell.setCellValue(resultSet.getString("ename"));
         cell = row.createCell(3);
         cell.setCellValue(resultSet.getString("deg"));
         cell = row.createCell(4);
         cell.setCellValue(resultSet.getString("salary"));
         cell = row.createCell(5);
         cell.setCellValue(resultSet.getString("dept"));
         i++;
      }

      FileOutputStream out = new FileOutputStream(new File("exceldatabase.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("exceldatabase.xlsx written successfully");
   }
}

ให้เราบันทึกรหัสด้านบนเป็น ExcelDatabase.java. รวบรวมและดำเนินการจากพรอมต์คำสั่งดังต่อไปนี้

$javac ExcelDatabase.java $java ExcelDatabase

มันจะสร้างไฟล์ Excel ชื่อ exceldatabase.xlsx ในไดเร็กทอรีปัจจุบันของคุณและแสดงผลลัพธ์ต่อไปนี้บนพรอมต์คำสั่ง

exceldatabase.xlsx written successfully

exceldatabase.xlsx ไฟล์มีลักษณะดังนี้

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved