I added some methods for ExcelRow and ExcelSheet.

MBenincasa · MBenincasa · commit 45a5c8078b4c · 2023-02-27T19:05:43.000+01:00
diff --git a/src/main/java/model/ExcelRow.java b/src/main/java/model/ExcelRow.java
@@ -35,4 +35,35 @@ public ExcelSheet getSheet() {
         String sheetName = sheet.getSheetName();
         return new ExcelSheet(sheet, excelWorkbook.getSheet(sheetName).getIndex(), sheetName);
     }
+
+    public Integer getLastColumnIndex() {
+        return this.row.getLastCellNum() - 1;
+    }
+
+    public Integer countAllColumns(Boolean alsoEmpty) {
+        Integer count = this.getLastColumnIndex() + 1;
+        if (alsoEmpty)
+            return count;
+
+        for (int i = 0; i < this.row.getPhysicalNumberOfCells(); i++) {
+            Cell cell = this.row.getCell(i);
+            if (cell == null) {
+                count--;
+                continue;
+            }
+
+            Object val;
+            switch (cell.getCellType()) {
+                case NUMERIC -> val = cell.getNumericCellValue();
+                case BOOLEAN -> val = cell.getBooleanCellValue();
+                default -> val = cell.getStringCellValue();
+            }
+
+            if (val == null) {
+                count--;
+            }
+        }
+
+        return count;
+    }
 }
diff --git a/src/main/java/model/ExcelSheet.java b/src/main/java/model/ExcelSheet.java
@@ -4,6 +4,7 @@
 import lombok.AllArgsConstructor;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.Row;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.Workbook;
@@ -49,4 +50,46 @@ public List<ExcelRow> getRows() {
         
         return excelRows;
     }
+
+    public Integer getLastRowIndex() {
+        return this.sheet.getLastRowNum();
+    }
+
+    public Integer countAllRows(Boolean alsoEmpty) {
+        Integer count = this.getLastRowIndex() + 1;
+        if (alsoEmpty)
+            return count;
+
+        for (int i = 0; i < this.sheet.getPhysicalNumberOfRows(); i++) {
+            Row row = this.sheet.getRow(i);
+            boolean isEmptyRow = true;
+
+            if (row == null) {
+                count--;
+                continue;
+            }
+
+            for (int j = 0; j < row.getLastCellNum(); j++) {
+                Cell cell = row.getCell(j);
+                if (cell != null) {
+                    Object val;
+                    switch (cell.getCellType()) {
+                        case NUMERIC -> val = cell.getNumericCellValue();
+                        case BOOLEAN -> val = cell.getBooleanCellValue();
+                        default -> val = cell.getStringCellValue();
+                    }
+                    if (val != null) {
+                        isEmptyRow = false;
+                        break;
+                    }
+                }
+            }
+
+            if (isEmptyRow) {
+                count--;
+            }
+        }
+
+        return count;
+    }
 }
diff --git a/src/main/java/samples/countAllRowsSample/Main.java b/src/main/java/samples/countAllRowsSample/Main.java
@@ -1,8 +1,10 @@
 package samples.countAllRowsSample;
 
-import tools.ExcelUtility;
+import model.ExcelSheet;
+import model.ExcelWorkbook;
 
 import java.io.File;
+import java.util.LinkedList;
 import java.util.List;
 
 public class Main {
@@ -12,14 +14,16 @@ public static void main(String[] args) {
         File file = new File("./src/main/resources/car.xlsx");
 
         try {
-            int totalRows = ExcelUtility.countAllRows(file, "car");
-            System.out.println("Total: " + totalRows);
-            int totalRowsWithoutEmpty = ExcelUtility.countAllRows(file, "car", false);
-            System.out.println("Total without empty rows: " + totalRowsWithoutEmpty);
-            List<Integer> totalRowsOfSheets = ExcelUtility.countAllRowsOfAllSheets(file);
-            System.out.println("Total of all sheets: " + totalRowsOfSheets);
-            List<Integer> totalRowsOfSheetsWithoutEmpty = ExcelUtility.countAllRowsOfAllSheets(file, false);
-            System.out.println("Total of all sheets without empty rows : " + totalRowsOfSheetsWithoutEmpty);
+            ExcelWorkbook excelWorkbook = ExcelWorkbook.open(file);
+            List<ExcelSheet> excelSheets = excelWorkbook.getSheets();
+            int totalRows = excelWorkbook.getSheet("car").countAllRows(true);
+            System.out.println("Total rows: " + totalRows);
+            List<Integer> totalRowsWithoutEmptyOfSheets = new LinkedList<>();
+            for (ExcelSheet excelSheet : excelSheets) {
+                totalRowsWithoutEmptyOfSheets.add(excelSheet.countAllRows(false));
+            }
+
+            System.out.println("Total of all sheets without empty rows: " + totalRowsWithoutEmptyOfSheets);
         } catch (Exception e) {
             System.err.println("There was an error. Check the console");
             throw new RuntimeException(e);
diff --git a/src/main/java/tools/ExcelUtility.java b/src/main/java/tools/ExcelUtility.java
@@ -26,25 +26,29 @@ public class ExcelUtility {
     /**
      * Counts all rows in all sheets<p>
      * If not specified, empty lines will also be included
+     * @deprecated since version 0.3.0
      * @param file an Excel file
      * @return A list with the number of rows present for each sheet
      * @throws ExtensionNotValidException If the input file extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      * @throws OpenWorkbookException If an error occurred while opening the workbook
      */
+    @Deprecated
     public static List<Integer> countAllRowsOfAllSheets(File file) throws ExtensionNotValidException, IOException, OpenWorkbookException {
         return countAllRowsOfAllSheets(file, true);
     }
 
     /**
      * * Counts all rows in all sheets
+     * @deprecated since version 0.3.0
      * @param file an Excel file
      * @param alsoEmptyRows if {@code true} then it will also count rows with all empty cells
      * @return A list with the number of rows present for each sheet
      * @throws ExtensionNotValidException If the input file extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      * @throws OpenWorkbookException If an error occurred while opening the workbook
      */
+    @Deprecated
     public static List<Integer> countAllRowsOfAllSheets(File file, Boolean alsoEmptyRows) throws ExtensionNotValidException, IOException, OpenWorkbookException {
         /* Open file excel */
         ExcelWorkbook excelWorkbook = ExcelWorkbook.open(file);
@@ -69,6 +73,7 @@ public static List<Integer> countAllRowsOfAllSheets(File file, Boolean alsoEmpty
     /**
      * Counts all rows in a sheet<p>
      * If not specified, empty lines will also be included
+     * @deprecated since version 0.3.0
      * @param file An Excel file
      * @param sheetName The name of the sheet to open
      * @return A number that corresponds to all rows in the sheet
@@ -77,12 +82,14 @@ public static List<Integer> countAllRowsOfAllSheets(File file, Boolean alsoEmpty
      * @throws ExtensionNotValidException If the input file extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer countAllRows(File file, String sheetName) throws OpenWorkbookException, SheetNotFoundException, ExtensionNotValidException, IOException {
         return countAllRows(file, sheetName, true);
     }
 
     /**
      * Counts all rows in a sheet
+     * @deprecated since version 0.3.0
      * @param file An Excel file
      * @param sheetName The name of the sheet to open
      * @param alsoEmptyRows if {@code true} then it will also count rows with all empty cells
@@ -92,6 +99,7 @@ public static Integer countAllRows(File file, String sheetName) throws OpenWorkb
      * @throws ExtensionNotValidException If the input file extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer countAllRows(File file, String sheetName, Boolean alsoEmptyRows) throws ExtensionNotValidException, IOException, OpenWorkbookException, SheetNotFoundException {
         /* Open file excel */
         ExcelWorkbook excelWorkbook = ExcelWorkbook.open(file);
@@ -136,19 +144,22 @@ public static Boolean isValidExcelExtension(String extension) {
     /**
      * This method is used to recover the position of the last row of the Sheet. Note the count starts at 1<p>
      * By default, the first Sheet is chosen
+     * @deprecated since version 0.3.0
      * @param file file An Excel file
      * @return The position of the last row of the Sheet
      * @throws OpenWorkbookException If an error occurred while opening the workbook
      * @throws SheetNotFoundException If the sheet to open is not found
      * @throws ExtensionNotValidException If the filename extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer getIndexLastRow(File file) throws OpenWorkbookException, SheetNotFoundException, ExtensionNotValidException, IOException {
         return getIndexLastRow(file, null);
     }
 
     /**
      * This method is used to recover the position of the last row of the Sheet. Note the count starts at 1
+     * @deprecated since version 0.3.0
      * @param file file An Excel file
      * @param sheetName The name of the sheet to open
      * @return The position of the last row of the Sheet
@@ -157,6 +168,7 @@ public static Integer getIndexLastRow(File file) throws OpenWorkbookException, S
      * @throws ExtensionNotValidException If the filename extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer getIndexLastRow(File file, String sheetName) throws OpenWorkbookException, ExtensionNotValidException, IOException, SheetNotFoundException {
         /* Open file excel */
         ExcelWorkbook excelWorkbook = ExcelWorkbook.open(file);
@@ -169,20 +181,23 @@ public static Integer getIndexLastRow(File file, String sheetName) throws OpenWo
     /**
      * This method is used to recover the position of the last column of the chosen row. Note that the count starts at 1<p>
      * By default, the first sheet and the first row are chosen
+     * @deprecated since version 0.3.0
      * @param file file An Excel file
      * @return The position of the last column of the chosen row
      * @throws OpenWorkbookException If an error occurred while opening the workbook
      * @throws SheetNotFoundException If the sheet to open is not found
      * @throws ExtensionNotValidException If the filename extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer getIndexLastColumn(File file) throws OpenWorkbookException, SheetNotFoundException, ExtensionNotValidException, IOException {
         return getIndexLastColumn(file, null, 0);
     }
 
     /**
      * This method is used to recover the position of the last column of the chosen row. Note that the count starts at 1<p>
      * By default, the first row is chosen
+     * @deprecated since version 0.3.0
      * @param file file An Excel file
      * @param sheetName The name of the sheet to open
      * @return The position of the last column of the chosen row
@@ -191,13 +206,15 @@ public static Integer getIndexLastColumn(File file) throws OpenWorkbookException
      * @throws ExtensionNotValidException If the filename extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer getIndexLastColumn(File file, String sheetName) throws OpenWorkbookException, SheetNotFoundException, ExtensionNotValidException, IOException {
         return getIndexLastColumn(file, sheetName, 0);
     }
 
     /**
      * This method is used to recover the position of the last column of the chosen row. Note that the count starts at 1<p>
      * By default, the first sheet is chosen
+     * @deprecated since version 0.3.0
      * @param file file An Excel file
      * @param indexRow the row index
      * @return The position of the last column of the chosen row
@@ -206,12 +223,14 @@ public static Integer getIndexLastColumn(File file, String sheetName) throws Ope
      * @throws ExtensionNotValidException If the filename extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer getIndexLastColumn(File file, Integer indexRow) throws OpenWorkbookException, SheetNotFoundException, ExtensionNotValidException, IOException {
         return getIndexLastColumn(file, null, indexRow);
     }
 
     /**
      * This method is used to recover the position of the last column of the chosen row. Note that the count starts at 1
+     * @deprecated since version 0.3.0
      * @param file file An Excel file
      * @param sheetName The name of the sheet to open
      * @param indexRow the row index
@@ -221,6 +240,7 @@ public static Integer getIndexLastColumn(File file, Integer indexRow) throws Ope
      * @throws ExtensionNotValidException If the filename extension does not belong to an Excel file
      * @throws IOException If an I/O error occurs
      */
+    @Deprecated
     public static Integer getIndexLastColumn(File file, String sheetName, Integer indexRow) throws OpenWorkbookException, SheetNotFoundException, ExtensionNotValidException, IOException {
         /* Open file excel */
         ExcelWorkbook excelWorkbook = ExcelWorkbook.open(file);
diff --git a/src/test/java/model/ExcelRowTest.java b/src/test/java/model/ExcelRowTest.java
@@ -34,4 +34,22 @@ void getSheet() throws OpenWorkbookException, ExtensionNotValidException, IOExce
         ExcelSheet excelSheet1 = excelRow.getSheet();
         Assertions.assertEquals(excelSheet, excelSheet1);
     }
+
+    @Test
+    void getLastColumnIndex() throws OpenWorkbookException, ExtensionNotValidException, IOException, SheetNotFoundException {
+        ExcelWorkbook excelWorkbook = ExcelWorkbook.open(excelFile);
+        ExcelSheet excelSheet = excelWorkbook.getSheet(1);
+        List<ExcelRow> excelRows = excelSheet.getRows();
+        Assertions.assertEquals(4, excelRows.get(0).getLastColumnIndex());
+        Assertions.assertEquals(2, excelRows.get(1).getLastColumnIndex());
+    }
+
+    @Test
+    void countAllColumns() throws OpenWorkbookException, ExtensionNotValidException, IOException, SheetNotFoundException {
+        ExcelWorkbook excelWorkbook = ExcelWorkbook.open(excelFile);
+        ExcelSheet excelSheet = excelWorkbook.getSheet(1);
+        List<ExcelRow> excelRows = excelSheet.getRows();
+        Assertions.assertEquals(4, excelRows.get(0).countAllColumns(false));
+        Assertions.assertEquals(3, excelRows.get(1).countAllColumns(true));
+    }
 }
diff --git a/src/test/java/model/ExcelSheetTest.java b/src/test/java/model/ExcelSheetTest.java
@@ -9,6 +9,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.util.List;
 
 public class ExcelSheetTest {
 
@@ -39,6 +40,24 @@ void getWorkbook() throws OpenWorkbookException, ExtensionNotValidException, IOE
     }
 
     @Test
-    void getRows() {
+    void getRows() throws OpenWorkbookException, ExtensionNotValidException, IOException, SheetNotFoundException {
+        ExcelWorkbook excelWorkbook = ExcelWorkbook.open(excelFile);
+        ExcelSheet excelSheet = excelWorkbook.getSheet(0);
+        List<ExcelRow> excelRows = excelSheet.getRows();
+        Assertions.assertEquals(3, excelRows.size());
+    }
+
+    @Test
+    void getLastRowIndex() throws OpenWorkbookException, ExtensionNotValidException, IOException, SheetNotFoundException {
+        ExcelWorkbook excelWorkbook = ExcelWorkbook.open(excelFile);
+        ExcelSheet excelSheet = excelWorkbook.getSheet(0);
+        Assertions.assertEquals(2, excelSheet.getLastRowIndex());
+    }
+
+    @Test
+    void countAllRows() throws OpenWorkbookException, ExtensionNotValidException, IOException, SheetNotFoundException {
+        ExcelWorkbook excelWorkbook = ExcelWorkbook.open(excelFile);
+        ExcelSheet excelSheet = excelWorkbook.getSheet(1);
+        Assertions.assertEquals(4, excelSheet.countAllRows(false));
     }
 }
