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.