Apache POI - Krótki przewodnik

Niejednokrotnie wymagana jest aplikacja do generowania raportów w formacie pliku Microsoft Excel. Czasami oczekuje się nawet, że aplikacja otrzyma pliki Excela jako dane wejściowe. Na przykład aplikacja opracowana dla działu finansów firmy będzie musiała generować wszystkie wyniki w programie Excel.

Każdy programista Java, który chce tworzyć pliki MS Office jako dane wyjściowe, musi w tym celu użyć predefiniowanego interfejsu API tylko do odczytu.

Co to jest Apache POI?

Apache POI to popularny interfejs API, który umożliwia programistom tworzenie, modyfikowanie i wyświetlanie plików MS Office przy użyciu programów Java. Jest to biblioteka open source opracowana i rozpowszechniana przez Apache Software Foundation w celu projektowania lub modyfikowania plików Microsoft Office przy użyciu programu Java. Zawiera klasy i metody dekodowania danych wejściowych użytkownika lub pliku do dokumentów MS Office.

Komponenty Apache POI

Apache POI zawiera klasy i metody do pracy ze wszystkimi dokumentami OLE2 Compound MS Office. Lista składników tego API znajduje się poniżej.

  • POIFS(Słaby system plików implementacji zaciemniania) - ten komponent jest podstawowym czynnikiem wszystkich innych elementów POI. Służy do jawnego odczytywania różnych plików.

  • HSSF (Straszny format arkusza kalkulacyjnego) - służy do czytania i pisania xls format plików MS-Excel.

  • XSSF (Format arkusza kalkulacyjnego XML) - jest używany do xlsx format pliku MS-Excel.

  • HPSF (Straszny format zestawu właściwości) - służy do wyodrębniania property sets plików MS-Office.

  • HWPF (Horrible Word Processor Format) - Służy do czytania i pisania doc pliki rozszerzeń MS-Word.

  • XWPF (XML Word Processor Format) - służy do odczytu i zapisu docx pliki rozszerzeń MS-Word.

  • HSLF (Straszny format układu slajdów) - służy do czytania, tworzenia i edytowania prezentacji PowerPoint.

  • HDGF (Horrible DiaGram Format) - Zawiera klasy i metody dla MS-Visio pliki binarne.

  • HPBF (Horrible PuBlisher Format) - Służy do czytania i pisania MS-Publisher akta.

Ten samouczek przeprowadzi Cię przez proces pracy z plikami Excel przy użyciu języka Java. Dlatego dyskusja ogranicza się do komponentów HSSF i XSSF.

Note - Starsze wersje POI obsługują binarne formaty plików, takie jak doc, xls, ppt, itp. Od wersji 3.5 POI obsługuje formaty plików OOXML MS-Office, takie jak docx, xlsx, pptx itp.

Podobnie jak Apache POI, istnieją inne biblioteki dostarczane przez różnych dostawców do generowania plików Excel. Obejmują oneAspose cells for Java przez Aspose, JXL przez Commons Libraries i JExcel przez Team Dev.

W tym rozdziale poznasz niektóre smaki Java Excel API i ich funkcje. Jest wielu dostawców, którzy zapewniają interfejsy API związane z Java Excel; niektóre z nich są omówione w tym rozdziale.

Aspose Cells for Java

Aspose Cells for Java to całkowicie licencjonowany interfejs API Java Excel opracowany i dystrybuowany przez dostawcę Aspose. Najnowsza wersja tego API to 8.1.2, wydana w lipcu 2014. Jest to bogate i ciężkie API (połączenie zwykłych klas Java i klas AWT) do projektowania komponentu Excela, który potrafi czytać, pisać i manipulować arkuszami kalkulacyjnymi.

Typowe zastosowania tego interfejsu API są następujące -

  • Raportowanie Excel, tworzenie dynamicznych raportów Excel
  • Wysokiej jakości renderowanie i drukowanie w programie Excel
  • Importuj i eksportuj dane z arkuszy kalkulacyjnych Excel
  • Generuj, edytuj i konwertuj arkusze kalkulacyjne

JXL

JXL to platforma zewnętrzna zaprojektowana dla Selenium, która obsługuje automatyzację opartą na danych w przeglądarkach internetowych (automatyczna aktualizacja danych w przeglądarkach internetowych). Jednak jest również używany jako wspólna biblioteka obsługująca interfejs API JExcel, ponieważ ma podstawowe funkcje tworzenia, odczytywania i zapisywania arkuszy kalkulacyjnych.

Podstawowe funkcje są następujące -

  • Generuj pliki Excel
  • Importuj dane ze skoroszytów i arkuszy kalkulacyjnych
  • Uzyskaj całkowitą liczbę wierszy i kolumn

Note - JXL obsługuje tylko format plików .xls i nie obsługuje dużych ilości danych.

JExcel

JExcel to całkowicie licencjonowany interfejs API dostarczany przez Team Dev. Korzystając z tego, programiści mogą łatwo czytać, pisać, wyświetlać i modyfikować skoroszyty programu Excel w obu.xls i .xlsxformaty. To API można łatwo osadzić za pomocą Java Swing i AWT. Najnowsza wersja tego interfejsu API to Jexcel-2.6.12, wydana w 2009 roku.

Główne cechy są następujące -

  • Zautomatyzuj aplikację Excel, skoroszyty, arkusze kalkulacyjne itp
  • Osadzaj skoroszyty w aplikacji Java Swing jako zwykły komponent Swing
  • Dodawaj detektory zdarzeń do skoroszytów i arkuszy kalkulacyjnych
  • Dodaj programy obsługi zdarzeń, aby obsłużyć zachowanie zdarzeń w skoroszycie i arkuszu kalkulacyjnym
  • Dodaj natywnych rówieśników, aby opracować niestandardowe funkcje

Apache POI

Apache POI to w 100% biblioteka open source dostarczana przez Apache Software Foundation. Większość programistów aplikacji na małą i średnią skalę jest w dużym stopniu zależna od Apache POI (HSSF + XSSF). Obsługuje wszystkie podstawowe funkcje bibliotek programu Excel; jednak renderowanie i wyodrębnianie tekstu to jego główne cechy.

W tym rozdziale omówiono proces konfiguracji Apache POI w systemach opartych na systemach Windows i Linux. Apache POI można łatwo zainstalować i zintegrować z aktualnym środowiskiem Java, wykonując kilka prostych kroków bez żadnych skomplikowanych procedur konfiguracyjnych. Administracja użytkownikami jest wymagana podczas instalacji.

wymagania systemowe

JDK Java SE 2 JDK 1.5 lub nowsza
Pamięć 1 GB RAM (zalecane)
Miejsca na dysku Brak minimalnych wymagań
Wersja systemu operacyjnego Windows XP lub nowszy, Linux

Przejdźmy teraz do kroków instalacji Apache POI.

Krok 1: Zweryfikuj instalację Java

Przede wszystkim musisz mieć zainstalowany zestaw Java Software Development Kit (SDK) w swoim systemie. Aby to sprawdzić, wykonaj dowolne z dwóch poleceń w zależności od platformy, na której pracujesz.

Jeśli instalacja Java została wykonana poprawnie, wyświetli się aktualna wersja i specyfikacja instalacji Java. Przykładowe dane wyjściowe podano w poniższej tabeli.

Platforma Komenda Przykładowe wyjście
Windows

Otwórz konsolę poleceń i wpisz -

\>java –version

Wersja Java „1.7.0_60”

Środowisko wykonawcze Java (TM) SE (kompilacja 1.7.0_60-b19)

Java Hotspot (TM) 64-bitowa maszyna wirtualna serwera (kompilacja 24.60-b09, tryb mieszany)

Linux

Otwórz terminal poleceń i wpisz -

$java –version

wersja java „1.7.0_25”

Otwórz środowisko wykonawcze JDK (rhel-2.3.10.4.el6_4-x86_64)

Otwórz 64-bitową maszynę wirtualną serwera JDK (kompilacja 23.7-b01, tryb mieszany)

  • Zakładamy, że czytelnicy tego samouczka mają zainstalowany pakiet Java SDK w wersji 1.7.0_60 w swoim systemie.

  • Jeśli nie masz Java SDK, pobierz jego aktualną wersję z https://www.oracle.com/technetwork/java/javase/downloads/index.html i zainstaluj.

Krok 2: Skonfiguruj środowisko Java

Ustaw zmienną środowiskową JAVA_HOME, aby wskazywała lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład,

Sr.No. Platforma i opis
1

Windows

Ustaw JAVA_HOME na C: \ ProgramFiles \ java \ jdk1.7.0_60

2

Linux

Eksportuj JAVA_HOME = / usr / local / java-current

Dołącz pełną ścieżkę lokalizacji kompilatora Java do ścieżki systemowej.

Sr.No. Platforma i opis
1

Windows

Dołącz ciąg „C: \ Program Files \ Java \ jdk1.7.0_60 \ bin” na końcu zmiennej systemowej PATH.

2

Linux

Export PATH = $ PATH: $ JAVA_HOME / bin /

Wykonaj polecenie java -version z wiersza polecenia, jak wyjaśniono powyżej.

Krok 3: Zainstaluj bibliotekę Apache POI

Pobierz najnowszą wersję Apache POI z https://poi.apache.org/download.htmli rozpakuj jego zawartość do folderu, z którego wymagane biblioteki można połączyć z programem Java. Załóżmy, że pliki są zebrane w folderze na dysku C.

Poniższe obrazy przedstawiają katalogi i strukturę plików w pobranym folderze.

Dodaj pełną ścieżkę pięciu jars jak podkreślono na powyższym obrazku do CLASSPATH.

Sr.No. Platforma i opis
1

Windows

Dołącz następujące ciągi na końcu zmiennej użytkownika

ŚCIEŻKA KLASY -

„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

Eksportuj 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

W tym rozdziale opisano kilka klas i metod dostępnych w interfejsie API Apache POI, które są niezbędne do pracy z plikami Excel przy użyciu programów Java.

zeszyt ćwiczeń

To jest super-interfejs wszystkich klas, które tworzą lub obsługują skoroszyty programu Excel. Należy doorg.apache.poi.ss.usermodelpakiet. Dwie klasy implementujące ten interfejs są następujące -

  • HSSFWorkbook- Ta klasa zawiera metody do odczytu i zapisu plików Microsoft Excel w formacie .xls. Jest kompatybilny z wersjami MS-Office 97–2003.

  • XSSFWorkbook- Ta klasa zawiera metody do odczytu i zapisu plików Microsoft Excel i OpenOffice xml w formacie .xls lub .xlsx. Jest kompatybilny z MS-Office w wersji 2007 lub nowszej.

HSSFWorkbook

Jest to klasa wysokiego poziomu w ramach org.apache.poi.hssf.usermodelpakiet. ImplementujeWorkbookinterfejs i jest używany do plików Excel w formacie .xls. Poniżej wymieniono niektóre metody i konstruktory w tej klasie.

Konstruktorzy klas

Sr.No. Konstruktor i opis
1

HSSFWorkbook()

Tworzy od podstaw nowy obiekt HSSFWorkbook.

2

HSSFWorkbook(DirectoryNode directory, boolean preserveNodes)

Tworzy nowy obiekt HSSFWworkbook wewnątrz określonego katalogu.

3

HSSFWorkbook(DirectoryNode directory, POIFSFileSystem fs, boolean preserveNodes)

Biorąc pod uwagę obiekt POIFSFileSystem i określony w nim katalog, tworzy obiekt SSFWorkbook w celu odczytania określonego skoroszytu.

4

HSSFWorkbook(java.io.InputStream s)

Tworzy nowy obiekt HSSFWorkbook przy użyciu strumienia wejściowego.

5

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

Tworzy system plików POI wokół strumienia wejściowego.

6

HSSFWorkbook(POIFSFileSystem fs)

Konstruuje nowy obiekt HSSFWorkbook przy użyciu obiektu POIFSFileSystem.

7

HSSFWorkbook(POIFSFileSystem fs, boolean preserveNodes)

Biorąc pod uwagę obiekt POIFSFileSystem, tworzy nowy obiekt HSSFWorkbook do odczytu określonego skoroszytu.

Często używane parametry wewnątrz tych konstruktorów to -

  • directory - Jest to katalog systemu plików POI do przetwarzania.

  • fs - Jest to system plików POI zawierający strumień skoroszytu.

  • preservenodes- Jest to opcjonalny parametr, który decyduje, czy zachować inne węzły, takie jak makra. Zużywa dużo pamięci, ponieważ przechowuje cały system POIFile w pamięci (jeśli jest ustawiony).

Note- Klasa HSSFWorkbook zawiera kilka metod; jednak są one zgodne tylko z formatem xls. W tym samouczku skupiamy się na najnowszej wersji formatów plików programu Excel. W związku z tym metody klas HSSFWorkbook nie są tutaj wymienione. Jeśli potrzebujesz tych metod klas, zapoznaj się z API klasy POI-HSSFWorkbook pod adresemhttps://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFWorkbook.html.

XSSFWorkbook

Jest to klasa, która jest używana do reprezentowania zarówno wysokiego, jak i niskiego poziomu formatów plików Excel. Należy doorg.apache.xssf.usemodel pakiet i implementuje Workbookberło. Poniżej wymienione są metody i konstruktory w tej klasie.

Konstruktorzy klas

Sr.No. Konstruktor i opis
1

XSSFWorkbook()

Tworzy od podstaw nowy obiekt XSSFworkbook.

2

XSSFWorkbook(java.io.File file)

Konstruuje obiekt XSSFWorkbook z podanego pliku.

3

XSSFWorkbook(java.io.InputStream is)

Konstruuje obiekt XSSFWorkbook, buforując cały strumień wejściowy do pamięci, a następnie otwierając dla niego obiekt OPCPackage.

4

XSSFWorkbook(java.lang.String path)

Konstruuje obiekt XSSFWorkbook, podając pełną ścieżkę do pliku.

Metody klasowe

Sr.No. Metoda i opis
1

createSheet()

Tworzy arkusz XSSFS dla tego skoroszytu, dodaje go do arkuszy i zwraca reprezentację wysokiego poziomu.

2

createSheet(java.lang.String sheetname)

Tworzy nowy arkusz dla tego skoroszytu i zwraca reprezentację wysokiego poziomu.

3

createFont()

Tworzy nową czcionkę i dodaje ją do tabeli czcionek skoroszytu.

4

createCellStyle()

Tworzy nowy XSSFCellStyle i dodaje go do tabeli stylów skoroszytu.

5

createFont()

Tworzy nową czcionkę i dodaje ją do tabeli czcionek skoroszytu.

6

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

Ustawia obszar drukowania danego arkusza zgodnie z określonymi parametrami.

Pozostałe metody tej klasy można znaleźć w pełnym dokumencie API pod adresem: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFWorkbook.html. aby uzyskać pełną listę metod.

Arkusz

Arkusz to interfejs pod org.apache.poi.ss.usermodelpakiet i jest to super-interfejs wszystkich klas, które tworzą arkusze kalkulacyjne wysokiego lub niskiego poziomu o określonych nazwach. Najpopularniejszym typem arkusza kalkulacyjnego jest arkusz roboczy, który jest reprezentowany jako siatka komórek.

Arkusz HSSFS

To jest klasa poniżej org.apache.poi.hssf.usermodelpakiet. Może tworzyć arkusze kalkulacyjne Excela i umożliwia formatowanie stylu arkusza i danych arkusza.

Konstruktorzy klas

Sr.No. Konstruktor i opis
1

HSSFSheet(HSSFWorkbook workbook)

Tworzy nowy arkusz HSSFS o nazwie przez HSSFWorkbook, aby utworzyć arkusz od podstaw.

2

HSSFSheet(HSSFWorkbook workbook, InternalSheet sheet)

Tworzy arkusz HSSFS reprezentujący dany obiekt arkusza.

XSSFSheet

Jest to klasa reprezentująca arkusz kalkulacyjny Excel na wysokim poziomie. Jest podorg.apache.poi.hssf.usermodel pakiet.

Konstruktorzy klas

Sr.No. Konstruktor i opis
1

XSSFSheet()

Tworzy nowy arkusz XSSFS - wywoływany przez XSSFWorkbook do tworzenia arkusza od podstaw.

2

XSSFSheet(PackagePart part, PackageRelationship rel)

Tworzy arkusz XSSFS przedstawiający daną część pakietu i relację.

Metody klasowe

Sr.No. Metoda i opis
1

addMergedRegion(CellRangeAddress region)

Dodaje scalony region komórek (stąd te komórki tworzą jeden).

2

autoSizeColumn(int column)

Dopasowuje szerokość kolumny do zawartości.

3

iterator()

Ta metoda jest aliasem dla rowIterator (), aby zezwolić na pętle foreach

4

addHyperlink(XSSFHyperlink hyperlink)

Rejestruje hiperłącze w zbiorze hiperłączy na tym arkuszu

W przypadku pozostałych metod tej klasy zapoznaj się z pełnym interfejsem API pod adresem: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFSheet.html.

Rząd

To jest interfejs pod org.apache.poi.ss.usermodelpakiet. Służy do reprezentacji wysokiego poziomu wiersza arkusza kalkulacyjnego. Jest to super-interfejs wszystkich klas reprezentujących wiersze w bibliotece POI.

XSSFRow

To jest klasa poniżej org.apache.poi.xssf.usermodelpakiet. Implementuje interfejs Row, dlatego może tworzyć wiersze w arkuszu kalkulacyjnym. Poniżej wymienione są metody i konstruktory w tej klasie.

Metody klasowe

Sr.No. Metoda i opis
1

createCell(int columnIndex)

Tworzy nowe komórki w wierszu i zwraca je.

2

setHeight(short height)

Ustawia wysokość w krótkich jednostkach.

W przypadku pozostałych metod tej klasy kliknij podany link https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFRow.html

Komórka

To jest interfejs pod org.apache.poi.ss.usermodelpakiet. Jest to superinterfejs wszystkich klas, które reprezentują komórki w wierszach arkusza kalkulacyjnego.

Komórki mogą mieć różne atrybuty, takie jak puste, numeryczne, data, błąd itp. Komórki powinny mieć własne liczby (oparte na 0) przed dodaniem do wiersza.

XSSFCell

To jest klasa poniżej org.apache.poi.xssf.usermodelpakiet. Implementuje interfejs komórki. Jest to wysokopoziomowa reprezentacja komórek w wierszach arkusza kalkulacyjnego.

Podsumowanie pola

Poniżej wymienione są niektóre pola klasy XSSFCell wraz z ich opisem.

Sr.No. Typ i opis komórki
1

CELL_TYPE_BLANK

Reprezentuje pustą komórkę

2

CELL_TYPE_BOOLEAN

Reprezentuje komórkę logiczną (prawda lub fałsz)

3

CELL_TYPE_ERROR

Reprezentuje wartość błędu w komórce

4

CELL_TYPE_FORMULA

Reprezentuje wynik formuły w komórce

5

CELL_TYPE_NUMERIC

Reprezentuje dane liczbowe w komórce

6

CELL_TYPE_STRING

Reprezentuje ciąg (tekst) w komórce

Metody klasowe

Sr.No. Metoda i opis
1

setCellStyle(CellStyle style)

Ustawia styl komórki.

2

setCellType(int cellType)

Ustawia typ komórek (liczba, formuła lub ciąg).

3

setCellValue(boolean value)

Ustawia wartość logiczną dla komórki.

4

setCellValue(java.util.Calendar value)

Ustawia wartość daty dla komórki.

5

setCellValue(double value)

Ustawia wartość liczbową dla komórki.

6

setCellValue(java.lang.String str)

Ustawia wartość ciągu dla komórki.

7

setHyperlink(Hyperlink hyperlink)

Przypisuje hiperłącze do tej komórki.

Aby zapoznać się z pozostałymi metodami i polami tej klasy, odwiedź poniższy link: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCell.html

XSSFCellStyle

To jest klasa poniżej org.apache.poi.xssf.usermodelpakiet. Zapewni to ewentualne informacje dotyczące formatu treści w komórce arkusza kalkulacyjnego. Udostępnia również opcje modyfikowania tego formatu. Implementuje interfejs CellStyle.

Podsumowanie pola

W poniższej tabeli wymieniono kilka pól, które są dziedziczone z interfejsu CellStyle.

Sr.No. Pole i opis
1

ALIGN_CENTER

Wyśrodkuj zawartość komórki

2

ALIGN_CENTER_SELECTION

Wyrównanie do środka w poziomie

3

ALIGN_FILL

Dopasowanie komórki do rozmiaru zawartości

4

ALIGN_JUSTIFY

Dopasuj zawartość komórki do jej szerokości

5

ALIGN_LEFT

Wyrównaj zawartość komórki do lewej

6

ALIGN_RIGHT

Wyrównaj zawartość komórki do prawej

7

BORDER_DASH_DOT

Styl komórki z kreską i kropką

8

BORDER_DOTTED

Styl komórki z przerywaną obwódką

9

BORDER_DASHED

Styl komórki z przerywaną obwódką

10

BORDER_THICK

Styl komórki z grubym obramowaniem

11

BORDER_THIN

Styl komórki z cienką obwódką

12

VERTICAL_BOTTOM

Wyrównaj zawartość komórki pionowo do dołu

13

VERTICAL_CENTER

Wyrównaj zawartość komórki do środka w pionie

15

VERTICAL_JUSTIFY

Wyrównaj i wyrównaj zawartość komórki w pionie

16

VERTICAL_TOP

Wyrównanie do góry w pionie

Konstruktorzy klas

Sr.No. Konstruktor i opis
1

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

Tworzy styl komórki z dostarczonych części

2

XSSFCellStyle(StylesTable stylesSource)

Tworzy styl pustej komórki

Metody klasowe

S.Nr Metoda i opis
1

setAlignment(short align)

Ustawia typ wyrównania poziomego komórki

2

setBorderBottom(short border)

Ustawia typ obramowania dla dolnej krawędzi komórki

3

setBorderColor(XSSFCellBorder.BorderSide side, XSSFColor color)

Ustawia kolor dla wybranej ramki

4

setBorderLeft(Short border)

Ustawia typ obramowania lewej krawędzi komórki

5

setBorderRight(short border)

Ustawia typ obramowania prawej krawędzi komórki

6

setBorderTop(short border)

Ustawia typ obramowania górnego obramowania komórki

7

setFillBackgroundColor(XSSFColor color)

Ustawia kolor wypełnienia tła reprezentowany jako wartość XSSFColor.

8

setFillForegroundColor(XSSFColor color)

Ustawia kolor wypełnienia pierwszego planu reprezentowany jako wartość XSSFColor.

9

setFillPattern(short fp)

Określa informacje o wypełnieniu komórek dla wypełnień komórek wzorem i jednolitym kolorem.

10

setFont(Font font)

Ustawia czcionkę dla tego stylu.

11

setRotation(short rotation)

Ustawia stopień obrotu tekstu w komórce.

12

setVerticalAlignment(short align)

Ustawia typ wyrównania pionowego komórki.

W przypadku pozostałych metod i pól w tej klasie przejdź przez następujący link: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCellStyle.html

HSSFColor

To jest klasa poniżej org.apache.poi.hssf.utilpakiet. Zapewnia różne kolory jako klasy zagnieżdżone. Zwykle te klasy zagnieżdżone są reprezentowane przy użyciu własnych indeksów. Implementuje interfejs Color.

Klasy zagnieżdżone

Wszystkie zagnieżdżone klasy tej klasy są statyczne i każda klasa ma swój indeks. Te zagnieżdżone klasy kolorów są używane do formatowania komórek, takich jak zawartość komórki, obramowanie, pierwszy plan i tło. Poniżej wymieniono niektóre z zagnieżdżonych klas.

Sr.No. Nazwy klas (kolory)
1 HSSFColor.AQUA
2 HSSFColor.AUTOMATYCZNY
3 HSSFColor.BLACK
4 HSSFColor.BLUE
5 HSSFColor.BRIGHT_GREEN
6 HSSFColor.BRIGHT_GREY
7 HSSFColor.CORAL
8 HSSFColor.DARK_BLUE
9 HSSFColor.DARK_GREEN
10 HSSFColor.SKY_BLUE
11 HSSFColor.WBIAŁY
12 HSSFColor.ŻÓŁTY

Metody klasowe

Ważna jest tylko jedna metoda tej klasy, która służy do pobierania wartości indeksu.

Sr.No. Metoda i opis
1

getIndex()

Ta metoda służy do pobierania wartości indeksu klasy zagnieżdżonej.

Aby uzyskać informacje o pozostałych metodach i klasach zagnieżdżonych, skorzystaj z następującego łącza: https://poi.apache.org/apidocs/org/apache/poi/hssf/util/HSSFColor.html

XSSFColor

To jest klasa poniżej org.apache.poi.xssf.usermodelpakiet. Służy do reprezentowania koloru w arkuszu kalkulacyjnym. Implementuje interfejs Color. Poniżej wymieniono niektóre z jego metod i konstruktorów.

Konstruktorzy klas

Sr.No. Konstruktor i opis
1

XSSFColor()

Tworzy nowe wystąpienie XSSFColor.

2

XSSFColor(byte[] rgb)

Tworzy nowe wystąpienie XSSFColor przy użyciu RGB.

3

XSSFColor(java.awt.Color clr)

Tworzy nowe wystąpienie XSSFColor przy użyciu klasy Color z pakietu awt.

Metody klasowe

Sr.No. Metoda i opis
1

setAuto(boolean auto)

Ustawia wartość logiczną wskazującą, że ctColor jest automatyczny, a ctColor systemowy jest zależny.

2

setIndexed(int indexed)

Ustawia indeksowaną wartość ctColor jako systemową wartość ctColor.

W przypadku pozostałych metod odwiedź poniższy link: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFColor.html

XSSFFont

To jest klasa poniżej org.apache.poi.xssf.usermodelpakiet. Implementuje interfejs czcionek i dlatego może obsługiwać różne czcionki w skoroszycie.

Konstruktor klas

Sr.No. Konstruktor i opis
1

XSSFFont()

Tworzy nowe wystąpienie XSSFont.

Metody klasowe

Sr.No. Metoda i opis
1

setBold(boolean bold)

Ustawia wartość logiczną dla atrybutu „pogrubienie”.

2

setColor(short color)

Ustawia indeksowany kolor czcionki.

3

setColor(XSSFColor color)

Ustawia kolor czcionki w standardowej wartości koloru Alpha RGB.

4

setFontHeight(short height)

Ustawia wysokość czcionki w punktach.

5

setFontName(java.lang.String name)

Ustawia nazwę czcionki.

6

setItalic(boolean italic)

Ustawia wartość logiczną dla właściwości „kursywa”.

W przypadku pozostałych metod przejdź przez następujący link: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFFont.html

XSSFHyperlink

To jest klasa poniżej org.apache.poi.xssf.usermodelpakiet. Implementuje interfejs Hyperlink. Służy do ustawiania hiperłącza do zawartości komórek w arkuszu kalkulacyjnym.

Pola

Pola tej klasy są następujące. Tutaj pola oznaczają rodzaje używanych hiperłączy.

Sr.No. Pole i opis
1

LINK_DOCUMENT

Służy do łączenia dowolnego innego dokumentu

2

LINK_EMAIL

Służy do łączenia wiadomości e-mail

3

LINK_FILE

Służy do łączenia dowolnego innego pliku w dowolnym formacie

4

LINK_URL

Służy do łączenia adresu internetowego

Metody klasowe

Sr.No. Metoda i opis
1

setAddress(java.lang.String address)

Adres hiperłącza.

W przypadku pozostałych metod odwiedź poniższy link: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFHyperlink.html

XSSFCreationHelper

To jest klasa poniżej org.apache.poi.xssf.usermodelpakiet. Implementuje interfejs CreationHelper. Służy jako klasa pomocnicza do oceny formuł i tworzenia hiperłączy.

Metody klasowe

Sr.No. Metoda i opis
1

createFormulaEvaluator()

Tworzy wystąpienie XSSFFormulaEvaluator, obiekt oceniający komórki formuły.

2

createHyperlink(int type)

Tworzy nowe XSSFHyperlink.

W przypadku pozostałych metod zapoznaj się z poniższym linkiem: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCreationHelper.html

XSSFPrintSetup

To jest klasa poniżej org.apache.poi.xsssf.usermodelpakiet. ImplementujePrintSetupberło. Służy do ustawiania rozmiaru, obszaru, opcji i ustawień drukowanej strony.

Metody klasowe

Sr.No. Metoda i opis
1

setLandscape(boolean ls)

Ustawia wartość logiczną, która zezwala lub blokuje drukowanie w orientacji poziomej.

2

setLeftToRight(boolean ltor)

Określa, czy podczas drukowania należy przesuwać się od lewej do prawej, czy od góry do dołu.

3

setPaperSize(short size)

Ustawia rozmiar papieru.

W przypadku pozostałych metod odwiedź poniższy link: https://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFPrintSetup.html

Tutaj termin „skoroszyt” oznacza plik Microsoft Excel. Po ukończeniu tego rozdziału będziesz mógł tworzyć nowe skoroszyty i otwierać istniejące skoroszyty za pomocą swojego programu Java.

Utwórz pusty skoroszyt

Poniższy prosty program służy do tworzenia pustego skoroszytu programu 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");
   }
}

Zapiszmy powyższy kod Java jako CreateWorkBook.java, a następnie skompiluj i wykonaj go z wiersza polecenia w następujący sposób -

$javac CreateWorkBook.java $java CreateWorkBook

Jeśli środowisko systemu jest skonfigurowane z biblioteką POI, zostanie skompilowane i uruchomione w celu wygenerowania pustego pliku Excel o nazwie createworkbook.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe w wierszu polecenia.

createworkbook.xlsx written successfully

Otwórz istniejący skoroszyt

Użyj poniższego kodu, aby otworzyć istniejący skoroszyt.

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.");
      }
   }
}

Zapisz powyższy kod Java jako OpenWorkBook.java, a następnie skompiluj i wykonaj go z wiersza polecenia w następujący sposób -

$javac OpenWorkBook.java $java OpenWorkBook

Skompiluje się i wykona, aby wygenerować następujące dane wyjściowe.

openworkbook.xlsx file open successfully.

Po otwarciu skoroszytu możesz wykonywać na nim operacje odczytu i zapisu.

W tym rozdziale wyjaśniono, jak utworzyć arkusz kalkulacyjny i manipulować nim za pomocą języka Java. Arkusz kalkulacyjny to strona w pliku Excel; zawiera wiersze i kolumny o określonych nazwach.

Po ukończeniu tego rozdziału będziesz mógł utworzyć arkusz kalkulacyjny i wykonać na nim operacje odczytu.

Utwórz arkusz kalkulacyjny

Przede wszystkim utwórzmy arkusz kalkulacyjny przy użyciu klas, do których istnieją odwołania, omówionych we wcześniejszych rozdziałach. Postępując zgodnie z poprzednim rozdziałem, najpierw utwórz skoroszyt, a następnie możemy przejść do tworzenia arkusza.

Poniższy fragment kodu służy do tworzenia arkusza kalkulacyjnego.

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

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

Wiersze w arkuszu kalkulacyjnym

Arkusze kalkulacyjne mają układ siatki. Wiersze i kolumny mają określone nazwy. Kolumny są oznaczone alfabetami, a wiersze liczbami.

Poniższy fragment kodu służy do tworzenia wiersza.

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

Napisz do arkusza kalkulacyjnego

Rozważmy przykład danych pracowników. Tutaj dane pracowników są podane w formie tabelarycznej.

Emp Id Nazwa Emp Przeznaczenie
Tp01 Gopal Menedżer techniczny
TP02 Manisha Proof Reader
Tp03 Masthan Pisarz techniczny
Tp04 Satish Pisarz techniczny
Tp05 Kryszna Pisarz techniczny

Poniższy kod służy do zapisywania powyższych danych w arkuszu kalkulacyjnym.

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");
   }
}

Zapisz powyższy kod Java jako Writesheet.java, a następnie skompiluj i uruchom go z wiersza polecenia w następujący sposób -

$javac Writesheet.java $java Writesheet

Skompiluje się i uruchomi, aby wygenerować plik Excel o nazwie Writesheet.xlsx w bieżącym katalogu, a w wierszu polecenia otrzymasz następujące dane wyjściowe.

Writesheet.xlsx written successfully

Plik Writesheet.xlsx plik wygląda następująco.

Czytaj z arkusza kalkulacyjnego

Rozważmy powyższy plik Excela o nazwie Writesheet.xslxjako dane wejściowe. Obserwuj następujący kod; służy do odczytu danych z arkusza kalkulacyjnego.

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();
   }
}

Zachowajmy powyższy kod Readsheet.java plik, a następnie skompiluj i uruchom go z wiersza polecenia w następujący sposób -

$javac Readsheet.java $java Readsheet

Jeśli środowisko systemowe jest skonfigurowane z biblioteką POI, zostanie skompilowane i uruchomione, aby wygenerować następujące dane wyjściowe w wierszu polecenia.

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

Wszelkie dane wprowadzane do arkusza kalkulacyjnego są zawsze przechowywane w komórce. Używamy etykiet wierszy i kolumn do identyfikacji komórki. W tym rozdziale opisano, jak manipulować danymi w komórkach w arkuszu kalkulacyjnym przy użyciu programowania Java.

Utwórz komórkę

Przed utworzeniem komórki musisz utworzyć wiersz. Wiersz to nic innego jak zbiór komórek.

Poniższy fragment kodu służy do tworzenia komórki.

//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);

Rodzaje komórek

Typ komórki określa, czy komórka może zawierać ciągi, wartość liczbową czy formuły. Komórka łańcuchowa nie może przechowywać wartości liczbowych, a komórka liczbowa nie może przechowywać ciągów. Poniżej podano typy komórek, ich wartości i składnię typów.

Typ wartości komórki Składnia typu
Wartość pustej komórki XSSFCell.CELL_TYPE_BLANK
Wartość komórki logicznej XSSFCell.CELL.TYPE_BOOLEAN
Wartość komórki błędu XSSFCell.CELL_TYPE_ERROR
Numeryczna wartość komórki XSSFCell.CELL_TYPE_NUMERIC
Wartość komórki ciągu XSSFCell.CELL_TYPE_STRING

Poniższy kod służy do tworzenia różnych typów komórek w arkuszu kalkulacyjnym.

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");
   }
}

Zapisz powyższy kod w pliku o nazwie TypesofCells.java, skompiluj i wykonaj go z wiersza polecenia w następujący sposób.

$javac TypesofCells.java $java TypesofCells

Jeśli twój system jest skonfigurowany z biblioteką POI, to skompiluje się i uruchomi, aby wygenerować plik Excel o nazwie typesofcells.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe.

typesofcells.xlsx written successfully

Plik typesofcells.xlsx plik wygląda następująco.

Style komórki

Tutaj możesz dowiedzieć się, jak formatować komórki i stosować różne style, takie jak scalanie sąsiednich komórek, dodawanie obramowań, ustawianie wyrównania komórek i wypełnianie kolorami.

Poniższy kod służy do stosowania różnych stylów do komórek za pomocą programowania w języku 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");
   }
}

Zapisz powyższy kod w pliku o nazwie CellStyle.java, skompiluj i wykonaj go z wiersza polecenia w następujący sposób.

$javac CellStyle.java $java CellStyle

Wygeneruje plik Excel o nazwie cellstyle.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe.

cellstyle.xlsx written successfully

Plik cellstyle.xlsx wygląda następująco.

W tym rozdziale wyjaśniono, jak ustawić różne czcionki, stosować style i wyświetlać tekst pod różnymi kątami w arkuszu kalkulacyjnym programu Excel.

Każdy system jest dostarczany z ogromną kolekcją czcionek, takich jak Arial, Impact, Times New Roman itp. W razie potrzeby kolekcję można również zaktualizować o nowe czcionki. Podobnie istnieją różne style, w których można wyświetlać czcionkę, na przykład pogrubienie, kursywa, podkreślenie, przekreślenie itp.

Czcionki i style czcionek

Poniższy kod służy do zastosowania określonej czcionki i stylu do zawartości komórki.

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");
   }
}

Zapiszmy powyższy kod w pliku o nazwie FontStyle.java. Skompiluj i uruchom go z wiersza polecenia w następujący sposób.

$javac FontStyle.java $java FontStyle

Generuje plik Excel o nazwie fontstyle.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe w wierszu polecenia.

fontstyle.xlsx written successfully

Plik fontstyle.xlsx plik wygląda następująco.

Kierunek tekstu

Tutaj możesz dowiedzieć się, jak ustawić kierunek tekstu pod różnymi kątami. Zwykle zawartość komórki jest wyświetlana poziomo, od lewej do prawej i pod kątem 00; jednak w razie potrzeby możesz użyć następującego kodu, aby obrócić kierunek tekstu.

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");
   }
}

Zachowaj powyższy kod w formacie TextDirectin.java plik, a następnie skompiluj go i uruchom z wiersza polecenia w następujący sposób.

$javac TextDirection.java $java TextDirection

Skompiluje się i uruchomi, aby wygenerować plik Excel o nazwie textdirection.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe w wierszu polecenia.

textdirection.xlsx written successfully

Plik textdirection.xlsx plik wygląda następująco.

W tym rozdziale omówiono proces stosowania różnych formuł do komórek za pomocą programowania w języku Java. Podstawowym celem programu Excel jest przechowywanie danych liczbowych poprzez stosowanie na nich formuł.

W formule przekazujemy dynamiczne wartości lub lokalizacje wartości w arkuszu Excel. Wykonując tę ​​formułę, uzyskasz pożądany wynik. W poniższej tabeli wymieniono kilka podstawowych formuł, które są często używane w programie Excel.

Operacja Składnia
Dodawanie wielu numerów = SUMA (Loc1: Locn) or = SUMA (n1; n2;)
Liczyć = LICZBA (Loc1: Locn) or = LICZBA (n1; n2;)
Potęga dwóch liczb = MOC (Loc1; Loc2) or = POTĘGA (liczba; potęga)
Maksymalna liczba wielu numerów = MAX (Loc1: Locn) or = MAX (n1, n2,)
Produkt = ILOCZYN (Loc1: Locn) or = ILOCZYN (n1; n2;)
Factorial = FACT (Locn) or = FACT (liczba)
Liczba bezwzględna = ABS (Locn) or = ABS (liczba)
Dzisiejsza data = DZIŚ ()
Konwertuje małe litery = NIŻSZE (Locn) or = LOWER (tekst)
Pierwiastek kwadratowy = SQRT (locn) or = SQRT (liczba)

Poniższy kod służy do dodawania formuł do komórki i wykonywania jej.

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");
   }
}

Zapisz powyższy kod jako Formula.java a następnie skompiluj i wykonaj go z wiersza polecenia w następujący sposób.

$javac Formula.java $java Formula

Wygeneruje plik Excel o nazwie formula.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe w wierszu polecenia.

fromula.xlsx written successfully

Plik formula.xlsx plik wygląda następująco.

W tym rozdziale wyjaśniono, jak dodawać hiperłącza do zawartości komórki. Zwykle hiperłącza służą do uzyskiwania dostępu do dowolnego adresu URL, wiadomości e-mail lub pliku zewnętrznego.

Poniższy kod pokazuje, jak tworzyć hiperłącza w komórkach.

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");
   }
}

Zapisz powyższy kod jako HyperlinkEX.java. Skompiluj i uruchom go z wiersza polecenia w następujący sposób.

$javac HyperlinkEX.java $java HyperlinkEX

Wygeneruje plik Excel o nazwie hyperlink.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe w wierszu polecenia.

hyperlink.xlsx written successfully

Plik hyperlink.xlsx plik wygląda następująco.

W tym rozdziale wyjaśniono, jak ustawić obszar drukowania w arkuszu kalkulacyjnym. Zwykle obszar drukowania w arkuszach kalkulacyjnych Excel znajduje się od lewej górnej do prawej dolnej krawędzi. Obszar drukowania można dostosować do swoich wymagań. Oznacza to, że możesz wydrukować określony zakres komórek z całego arkusza kalkulacyjnego, dostosować rozmiar papieru, wydrukować zawartość z włączonymi liniami siatki itp.

Poniższy kod służy do ustawiania obszaru drukowania w arkuszu kalkulacyjnym.

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"); 
   }
}

Zapiszmy powyższy kod jako PrintArea.java. Skompiluj i uruchom go z wiersza polecenia w następujący sposób.

$javac PrintArea.java $java PrintArea

Wygeneruje plik o nazwie printarea.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe w wierszu polecenia.

printarea.xlsx written successfully

W powyższym kodzie nie dodaliśmy żadnych wartości komórek. W związku z tymprintarea.xlsxjest pustym plikiem. Na poniższym rysunku można jednak zauważyć, że podgląd wydruku przedstawia obszar wydruku z liniami siatki.

W tym rozdziale wyjaśniono, w jaki sposób biblioteka POI współdziała z bazą danych. Za pomocą JDBC można pobierać dane z bazy danych i wstawiać je do arkusza kalkulacyjnego przy użyciu biblioteki POI. Rozważmy bazę danych MySQL dla operacji SQL.

Napisz do Excela z bazy danych

Załóżmy następującą tabelę danych pracowników o nazwie emp_tbl ma zostać pobrany z bazy danych MySQL test.

EMP ID NAZWA EMP DEG WYNAGRODZENIE DEPT
1201 Gopal Menedżer techniczny 45000 TO
1202 Manisha Czytnik dowodów 45000 Testowanie
1203 Masthanvali Pisarz techniczny 45000 TO
1204 Kiran Hr Admin 40000 HR
1205 Kranthi Op Admin 30000 Admin

Użyj poniższego kodu, aby pobrać dane z bazy danych i wstawić je do arkusza kalkulacyjnego.

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");
   }
}

Zapiszmy powyższy kod jako ExcelDatabase.java. Skompiluj i uruchom go z wiersza polecenia w następujący sposób.

$javac ExcelDatabase.java $java ExcelDatabase

Wygeneruje plik Excel o nazwie exceldatabase.xlsx w bieżącym katalogu i wyświetl następujące dane wyjściowe w wierszu polecenia.

exceldatabase.xlsx written successfully

Plik exceldatabase.xlsx plik wygląda następująco.