Библиотека для java для работы с excel

Время на прочтение
3 мин

Количество просмотров 44K

Работа с таблицей Excel из Java

Собственно возникла проблема — обработать данные из таблицы и на их основе получить другую таблицу.

Вариантов решения этой проблемы несколько:

1. Макрос — единственной проблемой является VBA, на изучение которого времени нет совершенно, да и не нравится его синтаксис
2. Приложение на C# тут вроде все хорошо, но к машине на которой будет выполняться данное приложение сразу предъявляется много дополнительных требований:
   • .NET Framework
   • Установленный офис
   • установленная основная сборка взаимодействия (PIA) для приложения Office

3. связка Java и библиотека Apache POI—на этом способе я и хочу остановиться подробнее

Apache POI — это Java API для доступа к документам формата Microsoft.

Собственно для работы с таблицами Excel предназначен проект POI-HSSF. На данный момент есть 2 варианта библиотеки:

1. POI 3.5 beta 5, and Office Open XML Support (2009-02-19)—идет работа над поддержкой формата Office 2007
2. POI 3.2-FINAL Released (2008-10-19) — последний стабильный релиз

Я расскажу о работе с версией 3.2
Основным классом для работы с таблицей Excel является класс HSSFWorkbook пакета org.apache.poi.hssf.usermodel, представляющий книгу Excel.

Для чтения книги из файла можно применить следующий код:

public static HSSFWorkbook readWorkbook(String filename) {
       try {
               POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(filename));
               HSSFWorkbook wb = new HSSFWorkbook(fs);
               return wb;
       }
       catch (Exception e) {
               return null;
       }
}

Метод возвращает объект класса HSSFWorkbook если все удачно и null в другом случае.

Для сохранения изменений можно применить следующий метод:

public static void writeWorkbook(HSSFWorkbook wb, String fileName) {
       try {
               FileOutputStream fileOut = new FileOutputStream(fileName);
               wb.write(fileOut);
               fileOut.close();
       }
       catch (Exception e) {
               //Обработка ошибки
       }
}        

Метод записывает книгу wb в файл fileName

Для работы с листами рабочей книги предназначен класс HSSFSheet.
Объект класса HSSFSheet можно получить следующими способами:

• По имени
  HSSFSheet sheet= wb.getSheet("Лист 3")
• По номеру (нумерация начинается с 0)
  HSSFSheet sheet= wb.getSheet(0)
• Создание нового листа
  HSSFSheet sheet= wb.createSheet(["имя листа"])

Следующим объектом является строка — HSSFRow.
Получить доступ к объекту строки можно также 3 способами:

• По индексу (индексация начинается с 0)
  HSSFRow row = sheet.getRow(index)
• Через итератор
  

  Iterator rowIter = sheet.rowIterator();
  while (rowIter.hasNext()) {
         HSSFRow row = (HSSFRow) rowIter.next();
  }

• Создание новой строки
  HSSFRow row=sheet.createRow(0);

Ну и последним объектом на пути доступа к данным является объект класса HSSFCell — ячейка строки.
Получить доступ к ячейке можно из объекта строки следующими способами:

• По индексу ячейки (индексация начинается с 0)
  HSSFCell cell = row.getCell(0);
• Через итератор
  

  Iterator cellIter = row.cellIterator();
  while (cellIter.hasNext()) {
         HSSFCell cell = (HSSFCell) cellIter.next();
  }
  

• Создание новой ячейки
  HSSFCell cell = row.createCell(0);

Из объекта ячейки можно уже получать и устанавливать непосредственно данные:

• Логическое значение
  boolean b = cell.getBooleanCellValue();
cell.setCellValue(b);

• Дата
  Date date = cell.getDateCellValue();
cell.setCellValue(date);

• Числовое значение
  double d = cell.getNumericCellValue();
cell.setCellValue(d);

• Строковое значение
  String str = cell.getRichStringCellValue().getString();
cell.setCellValue(new HSSFRichTextString(str));

• Формула
  String formula = cell.getCellFormula();
cell.setCellFormula(formula);


Этих знаний достаточно чтобы обрабатывать простые таблицы.
Библиотека также предоставляет богатые возможности по форматированию ячеек, по их слиянию, заморозке и т.д.
Подробное описание функций можно найти на их сайте.
Данный способ прежде всего ценен тем, что не требует установки самого офиса и пакета PIA.

Рассказывает автор блога javarevisited.blogspot.ru

Из этой статьи вы сможете узнать о записи и чтении данных из Excel файлов в Java (будет рассмотрен как XLS, так и XLSX формат). Мы будем использовать библиотеку Apache POI и сосредоточимся на работе с типами String и Date, работа с последним происходит достаточно хитро. Напомню, что работу с числами мы уже рассмотрели в другой статье.

Библиотеку poi-XX.jar вы можете использовать для всех старых (xls, doc, ppt) файлов Microsoft Office, для новых (xlsx, docx, pptx) вам понадобится poi-ooxml-XX.jar. Очень важно понимать, что к чему относится, т.к. используемые классы тоже разные — для старых расширений это HSSFWorkbook, а для новых — XSSFWorkbook.

Подготовка: загрузка библиотек и зависимостей

Конечно, существует достаточно много открытых библиотек, которые позволяют работать с Excel файлами в Java, например, JXL, но мы будем использовать имеющую самый обширный API и самую популярную — Apache POI. Чтобы её использовать, вам нужно скачать jar файлы и добавить их через Eclipse вручную, или вы можете предоставить это Maven.

Во втором случае вам нужно просто добавить следующие две зависимости:

<dependencies>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.12</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.12</version>
    </dependency>
  </dependencies>

Самое удобное в Maven — что он загрузит не только указанные poi.jar и poi-ooxml.jar, но и все jar файлы, которые используются внутри, то есть xmlbeans-2.6.0.jar, stax-api-1.0.1.jar, poi-ooxml-schemas-3.12.jar и commons-codec-1.9.jar.

Если вы будете добавлять библиотеки вручную — не забудьте о вышеназванных файлах. Скачать всё можно отсюда. Помните — если вы загрузите только poi-XX.jar, то ваш код скомпилируется без ошибок, но потом упадёт с java.lang.NoClassDefFoundError: org/apache/xmlbeans/XmlObject, так как внутри будет вызываться xmlbeans.jar.

Запись

В этом примере мы запишем в xls файл следующие данные: в первую ячейку — строку с именем, а во вторую — дату рождения. Вот пошаговая инструкция:

• Создаём объект HSSFWorkBook;
• Создаём лист, используя на объекте, созданном в предыдущем шаге, createSheet();
• Создаём на листе строку, используя createRow();
• Создаём в строке ячейку — createCell();
• Задаём значение ячейки через setCellValue();
• Записываем workbook в File через FileOutputStream;
• Закрываем workbook, вызывая close().

Для записи строк или чисел этого вполне достаточно, но чтобы записать дату, нам понадобится сделать ещё кое-что:

• Создать DateFormat;
• Создать CellStyle;
• Записать DateFormat в CellStyle;
• Записать CellStyle в ячейку;
• Теперь в эту ячейку можно записать объект Date через всё тот же setCellValue;
• Чтобы дата поместилась в ячейку, нам нужно добавить столбцу свойство автоматически менять размер: sheet.autoSizeColumn(1).

Всё вместе это будет выглядеть так:

@SuppressWarnings("deprecation")
    public static void writeIntoExcel(String file) throws FileNotFoundException, IOException{
        Workbook book = new HSSFWorkbook();
        Sheet sheet = book.createSheet("Birthdays");

        // Нумерация начинается с нуля
        Row row = sheet.createRow(0); 
        
        // Мы запишем имя и дату в два столбца
        // имя будет String, а дата рождения --- Date,
        // формата dd.mm.yyyy
        Cell name = row.createCell(0);
        name.setCellValue("John");
        
        Cell birthdate = row.createCell(1);
        
        DataFormat format = book.createDataFormat();
        CellStyle dateStyle = book.createCellStyle();
        dateStyle.setDataFormat(format.getFormat("dd.mm.yyyy"));
        birthdate.setCellStyle(dateStyle);
        
 
        // Нумерация лет начинается с 1900-го
        birthdate.setCellValue(new Date(110, 10, 10));
        
        // Меняем размер столбца
        sheet.autoSizeColumn(1);
        
        // Записываем всё в файл
        book.write(new FileOutputStream(file));
        book.close();
    }

Чтение

Теперь мы считаем из только что созданного файла то, что мы туда записали.

• Для начала создадим HSSFWorkBook, передав в конструктор FileInputStream;
• Получаем лист, передавая в getSheet() его номер или название;
• Получаем строку, используя getRow();
• Получаем ячейку, используя getCell();
• Узнаём тип ячейки, используя на ней getCellType();
• В зависимости от типа ячейки, читаем её значения, используя getStringCellValue(), getNumericCellValue() или getDateCellValue();
• Закрываем workbook используя close().

Напомню, что дату Excel хранит как числа, т.е. тип ячейки всё равно будет CELL_TYPE_NUMERIC.

В виде кода это будет выглядеть следующим образом:

public static void readFromExcel(String file) throws IOException{
        HSSFWorkbook myExcelBook = new HSSFWorkbook(new FileInputStream(file));
        HSSFSheet myExcelSheet = myExcelBook.getSheet("Birthdays");
        HSSFRow row = myExcelSheet.getRow(0);
        
        if(row.getCell(0).getCellType() == HSSFCell.CELL_TYPE_STRING){
            String name = row.getCell(0).getStringCellValue();
            System.out.println("name : " + name);
        }
        
        if(row.getCell(1).getCellType() == HSSFCell.CELL_TYPE_NUMERIC){
            Date birthdate = row.getCell(1).getDateCellValue();
            System.out.println("birthdate :" + birthdate);
        }
        
        myExcelBook.close();
        
    }

В заключение

Как уже упомналось выше, чтение из xlsx файлов ничем принципиально не отличается — нужно только вместо HSSFWorkBook, HSSFSheet, HSSFRow (и прочих) из poi-XX.jar использовать XSSFWorkBook, XSSFSheet, XSSFRow из poi-ooxml-XX.jar. Это всё, что вам нужно знать для чтения и записи в файлы Excel. Разумеется, с помощью библиотеки Apache POI вы можете сделать гораздо больше, но эта статья должна помочь вам быстрее в ней освоиться.

_{Перевод статьи «How to Read Write Excel file in Java — POI Example»}

Learn to read excel, write excel, evaluate formula cells and apply custom formatting to the generated excel files using Apache POI library with examples.

If we are building software for the HR or Finance domain, there is usually a requirement for generating excel reports across management levels. Apart from reports, we can also expect some input data for the applications coming in the form of excel sheets and the application is expected to support this requirement.

Apache POI is a well-trusted library among many other open-source libraries to handle such usecases involving excel files. Please note that, in addition, we can read and write MS Word and MS PowerPoint files also using the Apache POI library.

This Apache POI tutorial will discuss some everyday excel operations in real-life applications.

1. Maven Dependency

If we are working on a maven project, we can include the Apache POI dependencies in pom.xml file using this:

<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi</artifactId>
  <version>5.2.2</version>
</dependency>

<dependency>
  <groupId>org.apache.poi</groupId>
  <artifactId>poi-ooxml</artifactId>
  <version>5.2.2</version>
</dependency>

2. Important Classes in POI Library

1. HSSF, XSSF and XSSF classes

   Apache POI main classes usually start with either HSSF, XSSF or SXSSF.

   • HSSF – is the POI Project’s pure Java implementation of the Excel 97(-2007) file format. e.g., HSSFWorkbook, HSSFSheet.
   • XSSF – is the POI Project’s pure Java implementation of the Excel 2007 OOXML (.xlsx) file format. e.g., XSSFWorkbook, XSSFSheet.
   • SXSSF (since 3.8-beta3) – is an API-compatible streaming extension of XSSF to be used when huge spreadsheets have to be produced and heap space is limited. e.g., SXSSFWorkbook, SXSSFSheet. SXSSF achieves its low memory footprint by limiting access to the rows within a sliding window, while XSSF gives access to all rows in the document.

2. Row and Cell

   Apart from the above classes, Row and Cell interact with a particular row and a particular cell in an excel sheet.

3. Styling Related Classes

   A wide range of classes like CellStyle, BuiltinFormats, ComparisonOperator, ConditionalFormattingRule, FontFormatting, IndexedColors, PatternFormatting, SheetConditionalFormatting etc. are used when you have to add formatting to a sheet, primarily based on some rules.

4. FormulaEvaluator

   Another helpful class FormulaEvaluator is used to evaluate the formula cells in an excel sheet.

3. Writing an Excel File

I am taking this example first so we can reuse the excel sheet created by this code in further examples.

Writing excel using POI is very simple and involves the following steps:

1. Create a workbook
2. Create a sheet in workbook
3. Create a row in sheet
4. Add cells to sheet
5. Repeat steps 3 and 4 to write more data

It seems very simple, right? Let’s have a look at the code doing these steps.

Java program to write an excel file using Apache POI library.

package com.howtodoinjava.demo.poi;
//import statements
public class WriteExcelDemo 
{
    public static void main(String[] args) 
    {
        //Blank workbook
        XSSFWorkbook workbook = new XSSFWorkbook(); 
         
        //Create a blank sheet
        XSSFSheet sheet = workbook.createSheet("Employee Data");
          
        //This data needs to be written (Object[])
        Map<String, Object[]> data = new TreeMap<String, Object[]>();
        data.put("1", new Object[] {"ID", "NAME", "LASTNAME"});
        data.put("2", new Object[] {1, "Amit", "Shukla"});
        data.put("3", new Object[] {2, "Lokesh", "Gupta"});
        data.put("4", new Object[] {3, "John", "Adwards"});
        data.put("5", new Object[] {4, "Brian", "Schultz"});
          
        //Iterate over data and write to sheet
        Set<String> keyset = data.keySet();
        int rownum = 0;
        for (String key : keyset)
        {
            Row row = sheet.createRow(rownum++);
            Object [] objArr = data.get(key);
            int cellnum = 0;
            for (Object obj : objArr)
            {
               Cell cell = row.createCell(cellnum++);
               if(obj instanceof String)
                    cell.setCellValue((String)obj);
                else if(obj instanceof Integer)
                    cell.setCellValue((Integer)obj);
            }
        }
        try
        {
            //Write the workbook in file system
            FileOutputStream out = new FileOutputStream(new File("howtodoinjava_demo.xlsx"));
            workbook.write(out);
            out.close();
            System.out.println("howtodoinjava_demo.xlsx written successfully on disk.");
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        }
    }
}

See Also: Appending Rows to Excel

4. Reading an Excel File

Reading an excel file using POI is also very simple if we divide this into steps.

1. Create workbook instance from an excel sheet
2. Get to the desired sheet
3. Increment row number
4. iterate over all cells in a row
5. repeat steps 3 and 4 until all data is read

Let’s see all the above steps in code. I am writing the code to read the excel file created in the above example. It will read all the column names and the values in it – cell by cell.

Java program to read an excel file using Apache POI library.

package com.howtodoinjava.demo.poi;
//import statements
public class ReadExcelDemo 
{
    public static void main(String[] args) 
    {
        try
        {
            FileInputStream file = new FileInputStream(new File("howtodoinjava_demo.xlsx"));
 
            //Create Workbook instance holding reference to .xlsx file
            XSSFWorkbook workbook = new XSSFWorkbook(file);
 
            //Get first/desired sheet from the workbook
            XSSFSheet sheet = workbook.getSheetAt(0);
 
            //Iterate through each rows one by one
            Iterator<Row> rowIterator = sheet.iterator();
            while (rowIterator.hasNext()) 
            {
                Row row = rowIterator.next();
                //For each row, iterate through all the columns
                Iterator<Cell> cellIterator = row.cellIterator();
                 
                while (cellIterator.hasNext()) 
                {
                    Cell cell = cellIterator.next();
                    //Check the cell type and format accordingly
                    switch (cell.getCellType()) 
                    {
                        case Cell.CELL_TYPE_NUMERIC:
                            System.out.print(cell.getNumericCellValue() + "t");
                            break;
                        case Cell.CELL_TYPE_STRING:
                            System.out.print(cell.getStringCellValue() + "t");
                            break;
                    }
                }
                System.out.println("");
            }
            file.close();
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        }
    }
}

Program Output:

ID      NAME        LASTNAME
1.0     Amit        Shukla  
2.0     Lokesh      Gupta   
3.0     John        Adwards 
4.0     Brian       Schultz 

See Also: Apache POI – Read an Excel File using SAX Parser

5. Add and Evaluate Formula Cells

When working on complex excel sheets, we encounter many cells with formulas to calculate their values. These are formula cells. Apache POI also has excellent support for adding formula cells and evaluating already present formula cells.

Let’s see one example of how to add formula cells in excel?

The sheet has four cells in a row and the fourth one in the multiplication of all the previous 3 rows. So the formula will be: A2*B2*C2 (in the second row)

Java program to add formula in an excel file using Apache POI library.

public static void main(String[] args) 
{
    XSSFWorkbook workbook = new XSSFWorkbook();
    XSSFSheet sheet = workbook.createSheet("Calculate Simple Interest");
  
    Row header = sheet.createRow(0);
    header.createCell(0).setCellValue("Pricipal");
    header.createCell(1).setCellValue("RoI");
    header.createCell(2).setCellValue("T");
    header.createCell(3).setCellValue("Interest (P r t)");
      
    Row dataRow = sheet.createRow(1);
    dataRow.createCell(0).setCellValue(14500d);
    dataRow.createCell(1).setCellValue(9.25);
    dataRow.createCell(2).setCellValue(3d);
    dataRow.createCell(3).setCellFormula("A2*B2*C2");
      
    try {
        FileOutputStream out =  new FileOutputStream(new File("formulaDemo.xlsx"));
        workbook.write(out);
        out.close();
        System.out.println("Excel with foumula cells written successfully");
          
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Similarly, we want to read a file with formula cells and use the following logic to evaluate formula cells.

Java program to evaluate formula in an excel file using Apache POI library.

public static void readSheetWithFormula()
{
    try
    {
        FileInputStream file = new FileInputStream(new File("formulaDemo.xlsx"));
 
        //Create Workbook instance holding reference to .xlsx file
        XSSFWorkbook workbook = new XSSFWorkbook(file);
 
        FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
         
        //Get first/desired sheet from the workbook
        XSSFSheet sheet = workbook.getSheetAt(0);
 
        //Iterate through each rows one by one
        Iterator<Row> rowIterator = sheet.iterator();
        while (rowIterator.hasNext()) 
        {
            Row row = rowIterator.next();
            //For each row, iterate through all the columns
            Iterator<Cell> cellIterator = row.cellIterator();
             
            while (cellIterator.hasNext()) 
            {
                Cell cell = cellIterator.next();
                //Check the cell type after eveluating formulae
                //If it is formula cell, it will be evaluated otherwise no change will happen
                switch (evaluator.evaluateInCell(cell).getCellType()) 
                {
                    case Cell.CELL_TYPE_NUMERIC:
                        System.out.print(cell.getNumericCellValue() + "tt");
                        break;
                    case Cell.CELL_TYPE_STRING:
                        System.out.print(cell.getStringCellValue() + "tt");
                        break;
                    case Cell.CELL_TYPE_FORMULA:
                        //Not again
                        break;
                }
            }
            System.out.println("");
        }
        file.close();
    } 
    catch (Exception e) 
    {
        e.printStackTrace();
    }
}

Program Output:

Pricipal        RoI         T       Interest (P r t)        
14500.0         9.25        3.0     402375.0  

6. Formatting the Cells

So far we have seen examples of reading/writing and excel files using Apache POI. But, when creating a report in an excel file, it is essential to add formatting on cells that fit into any pre-determined criteria.

This formatting can be a different coloring based on a specific value range, expiry date limit etc.

In the below examples, we are taking a couple of such cell formatting examples for various purposes.

6.1. Cell value in a specific range

This code will color any cell in a range whose value is between a configured range. [e.g., between 50 and 70]

static void basedOnValue(Sheet sheet) 
{
    //Creating some random values
    sheet.createRow(0).createCell(0).setCellValue(84);
    sheet.createRow(1).createCell(0).setCellValue(74);
    sheet.createRow(2).createCell(0).setCellValue(50);
    sheet.createRow(3).createCell(0).setCellValue(51);
    sheet.createRow(4).createCell(0).setCellValue(49);
    sheet.createRow(5).createCell(0).setCellValue(41);
 
    SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
 
    //Condition 1: Cell Value Is   greater than  70   (Blue Fill)
    ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(ComparisonOperator.GT, "70");
    PatternFormatting fill1 = rule1.createPatternFormatting();
    fill1.setFillBackgroundColor(IndexedColors.BLUE.index);
    fill1.setFillPattern(PatternFormatting.SOLID_FOREGROUND);
 
    //Condition 2: Cell Value Is  less than      50   (Green Fill)
    ConditionalFormattingRule rule2 = sheetCF.createConditionalFormattingRule(ComparisonOperator.LT, "50");
    PatternFormatting fill2 = rule2.createPatternFormatting();
    fill2.setFillBackgroundColor(IndexedColors.GREEN.index);
    fill2.setFillPattern(PatternFormatting.SOLID_FOREGROUND);
 
    CellRangeAddress[] regions = {
            CellRangeAddress.valueOf("A1:A6")
    };
 
    sheetCF.addConditionalFormatting(regions, rule1, rule2);
}

6.2. Highlight Duplicate Values

Highlight all cells which have duplicate values in observed cells.

static void formatDuplicates(Sheet sheet) {
    sheet.createRow(0).createCell(0).setCellValue("Code");
    sheet.createRow(1).createCell(0).setCellValue(4);
    sheet.createRow(2).createCell(0).setCellValue(3);
    sheet.createRow(3).createCell(0).setCellValue(6);
    sheet.createRow(4).createCell(0).setCellValue(3);
    sheet.createRow(5).createCell(0).setCellValue(5);
    sheet.createRow(6).createCell(0).setCellValue(8);
    sheet.createRow(7).createCell(0).setCellValue(0);
    sheet.createRow(8).createCell(0).setCellValue(2);
    sheet.createRow(9).createCell(0).setCellValue(8);
    sheet.createRow(10).createCell(0).setCellValue(6);
 
    SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
 
    // Condition 1: Formula Is   =A2=A1   (White Font)
    ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule("COUNTIF($A$2:$A$11,A2)>1");
    FontFormatting font = rule1.createFontFormatting();
    font.setFontStyle(false, true);
    font.setFontColorIndex(IndexedColors.BLUE.index);
 
    CellRangeAddress[] regions = {
            CellRangeAddress.valueOf("A2:A11")
    };
 
    sheetCF.addConditionalFormatting(regions, rule1);
 
    sheet.getRow(2).createCell(1).setCellValue("<== Duplicates numbers in the column are highlighted.  " +
            "Condition: Formula Is =COUNTIF($A$2:$A$11,A2)>1   (Blue Font)");
}

6.3. Alternate Color Rows in Different Colors

A simple code to color each alternate row in a different color.

static void shadeAlt(Sheet sheet) {
    SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
 
    // Condition 1: Formula Is   =A2=A1   (White Font)
    ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule("MOD(ROW(),2)");
    PatternFormatting fill1 = rule1.createPatternFormatting();
    fill1.setFillBackgroundColor(IndexedColors.LIGHT_GREEN.index);
    fill1.setFillPattern(PatternFormatting.SOLID_FOREGROUND);
 
    CellRangeAddress[] regions = {
            CellRangeAddress.valueOf("A1:Z100")
    };
 
    sheetCF.addConditionalFormatting(regions, rule1);
 
    sheet.createRow(0).createCell(1).setCellValue("Shade Alternating Rows");
    sheet.createRow(1).createCell(1).setCellValue("Condition: Formula Is  =MOD(ROW(),2)   (Light Green Fill)");
}

6.4. Color amounts that are going to expire in the next 30 days

A handy code for financial projects which keeps track of deadlines.

static void expiryInNext30Days(Sheet sheet) 
{
    CellStyle style = sheet.getWorkbook().createCellStyle();
    style.setDataFormat((short)BuiltinFormats.getBuiltinFormat("d-mmm"));
 
    sheet.createRow(0).createCell(0).setCellValue("Date");
    sheet.createRow(1).createCell(0).setCellFormula("TODAY()+29");
    sheet.createRow(2).createCell(0).setCellFormula("A2+1");
    sheet.createRow(3).createCell(0).setCellFormula("A3+1");
 
    for(int rownum = 1; rownum <= 3; rownum++) sheet.getRow(rownum).getCell(0).setCellStyle(style);
 
    SheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
 
    // Condition 1: Formula Is   =A2=A1   (White Font)
    ConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule("AND(A2-TODAY()>=0,A2-TODAY()<=30)");
    FontFormatting font = rule1.createFontFormatting();
    font.setFontStyle(false, true);
    font.setFontColorIndex(IndexedColors.BLUE.index);
 
    CellRangeAddress[] regions = {
            CellRangeAddress.valueOf("A2:A4")
    };
 
    sheetCF.addConditionalFormatting(regions, rule1);
 
    sheet.getRow(0).createCell(1).setCellValue("Dates within the next 30 days are highlighted");
}

I am ending this apache poi tutorial here to keep the post within a limit.

7. Conclusion

In this tutorial, we learned to read excel, write excel, set and evaluate formula cells, and format the cells with color codings using the Apache POI library.

Happy Learning !!

Source Code on Github

Apache POI, взаимодействие с Excel

Apache POI представляет собой API, который позволяет использовать файлы MS Office в Java приложениях.
Данная библиотека разрабатывается и распространяется Apache Software Foundation и носит открытый характер.
Apache POI включает классы и методы для чтения и записи информации в документы MS Office.

Описание компонентов

Список компонентов

Подключение Apache POI к проекту

Для подключения Apache POI к проекту необходимо скачать соответствующие библиотеки с официального сайта
https://poi.apache.org/download.html.

Если в проекте используется фреймворк maven, то необходимо установить одну из
следующих зависимостей (версия может быть более новой) :

<!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>3.16</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.16</version>
</dependency>

На странице описания примера чтения файлов Excel приведен проект, включающий
необходимый набор файлов библиотеки Apache POI (poi-3.16.jar, poi-ooxml-3.16.jar, poi-ooxml-schemas-3.16.jar) и
сопутствующих библиотек.

На странице рассматриваются следующие классы, используемые для работы с файлами Excel из приложений Java.

• рабочая книга — HSSFWorkbook, XSSFWorkbook
• лист книги — HSSFSheet, XSSFSheet
• строка — HSSFRow, XSSFRow
• ячейка — HSSFCell, XSSFCell
• стиль — стили ячеек HSSFCellStyle, XSSFCellStyle
• шрифт — шрифт ячеек HSSFFont, XSSFFont

Поскольку описание всех классов и методов не разместить на одной
странице, то ниже по тексту приводятся ссылки для перехода к исходной документации.

Классы и методы Apache POI для работы с файлами Excel

Рабочая книга HSSFWorkbook, XSSFWorkbook

• HSSFWorkbook
  • org.apache.poi.hssf.usermodel
  • класс чтения и записи файлов Microsoft Excel в формате .xls, совместим
    с версиями MS-Office 97-2003;
• XSSFWorkbook
  • org.apache.poi.xssf.usermodel
  • класс чтения и записи файлов Microsoft Excel в формате .xlsx, совместим
    с MS-Office 2007 или более поздней версии.

Конструкторы класса HSSFWorkbook

HSSFWorkbook ();
HSSFWorkbook (InternalWorkbook book);
HSSFWorkbook (POIFSFileSystem  fs);
HSSFWorkbook (NPOIFSFileSystem fs);
HSSFWorkbook (POIFSFileSystem  fs, 
              boolean preserveNodes);
HSSFWorkbook (DirectoryNode directory, 
              POIFSFileSystem fs, 
              boolean preserveNodes);
HSSFWorkbook (DirectoryNode directory,
              boolean preserveNodes);
HSSFWorkbook (InputStream s);
HSSFWorkbook (InputStream s, 
              boolean preserveNodes);

preservenodes является необязательным параметром, который определяет необходимость сохранения
узлов типа макросы.

Конструкторы класса XSSFWorkbook

XSSFWorkbook ();
// workbookType  создать .xlsx или .xlsm
XSSFWorkbook (XSSFWorkbookType workbookType);
XSSFWorkbook (OPCPackage   pkg );
XSSFWorkbook (InputStream  is  );
XSSFWorkbook (File         file);
XSSFWorkbook (String       path);

Основные методы HSSFWorkbook, XSSFWorkbook

С полным перечнем всех методов класса XSSFWorkbook можно познакомиться на странице
http://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFWorkbook.html.

Классы листов книги, HSSFSheet, XSSFSheet

• org.apache.poi.hssf.usermodel.HSSFSheet
• org.apache.poi.xssf.usermodel.XSSFSheet

Классы HSSFSheet, XSSFSheet включают свойства и методы создания строк, определения размера колонок,
слияния ячеек в одну область и т.д.

Основные методы классов работы с листами

С полным перечнем всех методов класса XSSFSheet можно познакомиться на странице
https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFSheet.html

Классы строк HSSFRow, XSSFRow

• org.apache.poi.hssf.usermodel.HSSFRow
• org.apache.poi.xssf.usermodel.XSSFRow

Классы HSSFRow, XSSFRow включают свойства и методы работы со строками, создания ячеек в строке и т.д.

Основные методы классов HSSFRow, XSSFRow

С полным перечнем всех методов класса XSSFRow можно познакомиться на странице
http://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFRow.html

Классы ячеек HSSFCell, XSSFCell

Ячейки электронной таблицы используются для размещения информации. В ячейке может быть представлено
числовое значение, текст или формула. Также ячейка может содержать комментарий.

Классы HSSFCell, XSSFCell включают свойства и методы работы с ячейками таблицы.

• org.apache.poi.hssf.usermodel.HSSFCell
• org.apache.poi.xssf.usermodel.XSSFCell

Основные методы классов HSSFCell, XSSFCell

С полным перечнем всех методов класса XSSFCell можно познакомиться на странице
http://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCell.html

Классы стилей ячеек HSSFCellStyle, XSSFCellStyle

С полным перечнем всех свойств и методов класса XSSFCellStyle можно познакомиться на странице
http://poi.apache.org/apidocs/org/apache/poi/ss/usermodel/CellStyle.html

Ниже в качестве примера представлен метод, формирующий стиль ячейки, в которой :

• текст центрируется по вертикали и горизонтали;
• обрамление ячейки представляет тонкую черную линию по периметру;
• текст переносится на следующую строку (не ячейку), если не вмещается в размер ячейки.

private XSSFCellStyle createCellStyle(XSSFWorkbook book)
{
    BorderStyle thin  = BorderStyle.THIN;
    short       black = IndexedColors.BLACK.getIndex();

    XSSFCellStyle style = book.createCellStyle();

    style.setWrapText(true);
    style.setAlignment        (HorizontalAlignment.CENTER);
    style.setVerticalAlignment(VerticalAlignment  .CENTER);

    style.setBorderTop        (thin);
    style.setBorderBottom     (thin);
    style.setBorderRight      (thin);
    style.setBorderLeft       (thin);

    style.setTopBorderColor   (black);
    style.setRightBorderColor (black);
    style.setBottomBorderColor(black);
    style.setLeftBorderColor  (black);

    return style;
}

Метод setWrapText позволяет определить флаг переноса текста в ячейке согласно ее размеру (ширине). Чтобы перенести
текст принудительно, можно в текстовой строке установить символы CRCL, например «Разделительrnтекста».

Классы шрифтов HSSFFont, XSSFFont

С полным перечнем всех свойств и методов класса XSSFFont можно познакомиться на странице
http://poi.apache.org/apidocs/org/apache/poi/ss/usermodel/Font.html

Ниже в качестве примера представлен метод, формирующий шрифт типа «Times New Roman» :

private XSSFFont createCellFont(XSSFWorkbook book)
{
    XSSFFont font = workBook.createFont();
    font.setFontHeightInPoints((short) 12);
    font.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
    font.setFontName("Times New Roman");
           
    return(font);
}
. . .
HSSFCellStyle style = book.createCellStyle();
style.setFont(createCellFont(book));

Примеры создания файлов Excel и определение стилей ячеек рассмотрены
здесь.

Все знакомы с табличным процессором Excel, который входит в стандартный пакет Microsoft Office. Напрямую в Excel очень удобно и приятно работать, но мало кто знает, что в Java этот процесс не менее приятный и увлекательный.

Последнее время мне приходилось программно парсить файлы формата .xls и .xlsx. Чтобы осуществить парсинг Excel-файла, понадобилась библиотека Apache POI. С помощью этой библиотеки можно парсить не только файлы в формате .xls, но и DOC, PPT, а также форматы, которые появились в версии Microsoft Office 2007.

В этой статье мы познакомимся с чтением данных из xls или xlsx файла в Java с помощью библиотеки Apache POI. Как всегда, немного теории по основам и практика на примере чтения простого xls файла. Пример создания нового Excel файла представлен здесь.

 Подключаем библиотеку для работы с Excel в Java

Для начала нужно создать Maven-проект и в файле pom.xml прописать следующий код зависимостей

Чтение Excel файла на Java

Библиотека Apache POI предоставляет простой в использовании API для чтения любого xls файла. Ниже мы рассмотрим наиболее используемые классы для чтения содержимого Excel таблиц:

Код для чтения Excel документов в формате xls

В листинге ниже приведен типичный пример инициализации HSSFWorkbook и HSSFSheet для считывания данных из .xls файлов.

Код для чтения Excel документов в формате .xlsx

Ниже приведен фрагмент кода для инициализации работы с Excel файлами в формате .xlsx:

Практика. Создаем простой Excel для работы

Пишем парсер на Java

Назовем класс ExcelParser.java с методом parse, который принимает текстовый параметр fileName

Создаем главный класс-ранер, где и запустим парсер:

Результат выполнения парсера Excel

Работа с запароленным Excel файлом

В Apache POI с каждой новой версией добавляются новые возможности по работе с закрытыми/запароленными файлами. Например, мы может работать с защищенными файлами XLS (используя org.apache.poi.hssf.record.crypt) и защищенными файлами XLSX (с помощью org.apache.poi.poifs.crypt).

Если вы используете HSSF (для файла XLS), то проверить является ли он запаролленым нам поможет метод isWriteProtected(). А для работы с ним необходимо указать пароль перед самым открытием файла:

После этого можем работать с файлом.

Для XSSF нам понадобится что-то вроде такого:

При работе с более новыми версиями Apache POI, можно просто указать пароль при создании Workbook:

Этот код будет работать как для HSSF, так и для XSSF.

Также смотрите примеры чтения Word документа и создания нового документа Word с помощью Apache POI.

Подписывайтесь на обновления!