导入数据

有时，你可能需要将数据从对象集合或数据表导入到某个区域，以创建新的电子表格或报告。GcExcel 允许你使用 IRange 接口的 importData 方法，从各种数据源导入数据。通过 importData 方法，你可以导入以下类型的数据源：

元素类型

基本类型：byte、short、int、long、float、double、boolean。
可空基本类型：Byte、Short、Integer、Long、Float、Double、Boolean、String、CalcError；经典日期和时间类型：java.util.Date、java.util.Calendar；JSR310 日期和时间类型：java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime、java.time.OffsetTime、java.time.OffsetDateTime、java.time.ZonedDateTime、java.time.Instant、java.time.YearMonth、java.time.Year、java.time.MonthDay。
自定义对象：具有公共 get 方法（在 Kotlin 中为属性）的对象，这些方法将映射到单元格值。
键为 String 的 Map：它将被视为属性名称和值的集合。

集合类型

扁平（非锯齿状，总共一维）可迭代对象或数组。
锯齿状二维数组，其中内部集合的元素类型为基本类型或可空基本类型。

GcExcel 提供以下 importData 方法，用于将数据从对象集合或数据表导入到某个区域：

方法	参数	描述
DataImportResult importData(Object items)	items	要导入的项，其可以是：元素类型基本类型：byte、short、int、long、float、double 和 boolean。可空基本类型：Byte、Short、Integer、Long、Float、Double、Boolean、String、CalcError、经典日期和时间类型：java.util.Date、java.util.Calendar、JSR310 日期和时间类型：java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime、java.time.OffsetTime、java.time.OffsetDateTime、java.time.ZonedDateTime、java.time.Instant、java.time.YearMonth、java.time.Year 和 java.time.MonthDay。自定义对象：具有公共 get 方法（在 Kotlin 中为属性）的对象，这些方法将映射到单元格值。键为 String 的 Map：它将被视为属性名称和值的集合。集合类型扁平（非锯齿状，总共一维）可迭代对象或数组。锯齿状二维数组，其中内部集合的元素类型为基本类型或可空基本类型。注意：该方法通过 ResultSet 对象接受表格作为参数。
DataImportResult importData(Object items, DataImportOptions options)	items	要导入的项，其可以是：元素类型基本类型：byte、short、int、long、float、double 和 boolean。可空基本类型：Byte、Short、Integer、Long、Float、Double、Boolean、String、CalcError、经典日期和时间类型：java.util.Date、java.util.Calendar、JSR310 日期和时间类型：java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime、java.time.OffsetTime、java.time.OffsetDateTime、java.time.ZonedDateTime、java.time.Instant、java.time.YearMonth、java.time.Year 和 java.time.MonthDay。自定义对象：具有公共 get 方法（在 Kotlin 中为属性）的对象，这些方法将映射到单元格值。键为 String 的 Map：它将被视为属性名称和值的集合。集合类型扁平（非锯齿状，总共一维）可迭代对象或数组。锯齿状二维数组，其中内部集合的元素类型为基本类型或可空基本类型。
options	导入选项。

方法

参数

描述

DataImportResult importData(Object items)

items

要导入的项，其可以是：

元素类型
- 基本类型：byte、short、int、long、float、double 和 boolean。
- 可空基本类型：Byte、Short、Integer、Long、Float、Double、Boolean、String、CalcError、经典日期和时间类型：java.util.Date、java.util.Calendar、JSR310 日期和时间类型：java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime、java.time.OffsetTime、java.time.OffsetDateTime、java.time.ZonedDateTime、java.time.Instant、java.time.YearMonth、java.time.Year 和 java.time.MonthDay。
- 自定义对象：具有公共 get 方法（在 Kotlin 中为属性）的对象，这些方法将映射到单元格值。
- 键为 String 的 Map：它将被视为属性名称和值的集合。
集合类型
- 扁平（非锯齿状，总共一维）可迭代对象或数组。
- 锯齿状二维数组，其中内部集合的元素类型为基本类型或可空基本类型。

注意：该方法通过 ResultSet 对象接受表格作为参数。

DataImportResult importData(Object items, DataImportOptions options)

items

要导入的项，其可以是：

元素类型
- 基本类型：byte、short、int、long、float、double 和 boolean。
- 可空基本类型：Byte、Short、Integer、Long、Float、Double、Boolean、String、CalcError、经典日期和时间类型：java.util.Date、java.util.Calendar、JSR310 日期和时间类型：java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime、java.time.OffsetTime、java.time.OffsetDateTime、java.time.ZonedDateTime、java.time.Instant、java.time.YearMonth、java.time.Year 和 java.time.MonthDay。
- 自定义对象：具有公共 get 方法（在 Kotlin 中为属性）的对象，这些方法将映射到单元格值。
- 键为 String 的 Map：它将被视为属性名称和值的集合。
集合类型
- 扁平（非锯齿状，总共一维）可迭代对象或数组。
- 锯齿状二维数组，其中内部集合的元素类型为基本类型或可空基本类型。

options

导入选项。

importData 方法的 options 参数接受以下导入选项，这些选项可通过 DataImportOptions 类访问，使你能够选择如何将数据从对象集合或数据表导入到某个区域：

导入选项	描述
InsufficientSpaceHandling	此选项确定在导入数据时如何处理空间不足的情况。
IncludeColumnHeader	此选项确定在导入数据时是否将列标题作为第一行包含在内。
ColumnsSelector	此选项选择要导入的列。默认行为是自动生成所有列。
ItemTypeProvider	此选项从指定的可迭代对象或数组中获取项类型。该类型用于自动生成列。默认行为是尝试从数组中获取项类型，然后尝试从第一个项中获取类型。

type=warning
注意：GcExcel 建议在将数据导入到区域时遵循以下几点：
尽可能使用泛型类型。
在 AOT 项目中，对自定义对象使用基于委托的列选择器。
尽可能使用二维数组而不是锯齿状数组。
如果 LINQ 结果不是很长，则将其缓存到列表或数组中。
尽可能使锯齿状数组的长度保持一致。
除非别无选择，否则请勿使用动态类型（duck typing）。
除非异步延续在原始线程上运行，否则请勿尝试导入异步数据源。
除非别无选择，否则请勿在数组类型中使用协变。

垂直导入简单可枚举对象

参考以下示例代码，将简单可枚举对象垂直导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
var worksheet = workbook.getWorksheets().get(0);

// 添加一维 double 数组。
double[] doubleData = {1.0, 2.0, 3.0, 4.0, 5.0};

// 垂直导入数组。
worksheet.getRange("A1:A5").importData(doubleData);

// 保存工作簿。
workbook.save("ImportSimpleEnumerableVertically.xlsx");

import-simple-enumerable-vertically

水平导入简单可枚举对象

参考以下示例代码，将简单可枚举对象水平导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加一维 double 数组。
double[] doubleData = {1.0, 2.0, 3.0, 4.0, 5.0};

// 水平导入数组。
worksheet.getRange("A1:E1").importData(doubleData);

// 保存工作簿。
workbook.save("ImportSimpleEnumerableHorizontally.xlsx");

import-simple-enumerable-horizontally

导入一维数据

参考以下示例代码，将一维数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 将工作簿区域设置为英语（美国）。
workbook.setCulture(Locale.US);
IWorksheet sheet1 = workbook.getWorksheets().get("Sheet1");
sheet1.setName("Import1DData");

// 设置区域值。
sheet1.getRange("A1").setValue("旅游预算表");

// 当区域不是垂直时水平导入一维数组。
String[] titles = {"员工 ID", "成人", "儿童", "房间", "水疗", "火锅", "预算"};
sheet1.getRange("A2:G2").importData(titles);

// 生成测试数据。你可以设置随机数生成器的种子值以获取相同的数据。
Random rnd = new Random(1234);
final int rowCount = 20;
int[] uids = rnd.ints(rowCount, 10000, 99999).toArray();
int[] adults = rnd.ints(rowCount, 1, 4).toArray();
int[] children = rnd.ints(rowCount, 0, 3).toArray();
List<Integer> rooms = IntStream.range(0, rowCount)
       .mapToObj(i -> (adults[i] + children[i]) / 2)
       .collect(Collectors.toList());
double[] spa = IntStream.range(0, rowCount)
       .mapToDouble(i -> Math.ceil((adults[i] + children[i]) * rnd.nextDouble()))
       .toArray();
int[] hotpot = IntStream.range(0, rowCount)
       .map(i -> adults[i] + children[i])
       .toArray();

final int budgetBase = 750;
List<Integer> budget = IntStream.range(0, rowCount)
       .mapToObj(i -> adults[i] * 200 + children[i] * 100 + rooms.get(i) * 400 + (int) spa[i] * 188 + hotpot[i] * 233 + budgetBase)
       .collect(Collectors.toList());

// 按列导入数据。
/* “rooms” 是一个列表。它也可以像一维数组一样导入。
   “budget” 是一个 LINQ 结果。它也可以像一维数组一样导入。 */
List<Object> columns = Arrays.asList(uids, adults, children, rooms, spa, hotpot, budget);
for (int i = 0; i < columns.size(); i++) {
    // 如果区域是垂直的，一维数组/列表将垂直导入。
    sheet1.getRange(2, i, 2, 1).importData(columns.get(i));
}

// 设置区域样式。
sheet1.getRange(1, 0, 1, 7).setStyle(workbook.getStyles().get("标题 3"));
sheet1.getRange(2, 0, rowCount, 7).setStyle(workbook.getStyles().get("20% - 强调文字颜色 1"));
sheet1.getRange(1, 0, 1, 7).的整个列().autoFit();
sheet1.getRange("A1").setStyle(workbook.getStyles().get("标题 1"));
sheet1.getRange("1:2").autoFit();

// 保存工作簿。
workbook.save("Import1DData.xlsx");

import-1D-data

导入二维数据

参考以下示例代码，将二维数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 将工作簿区域设置为英语（美国）。
workbook.setCulture(Locale.US);
IWorksheet sheet1 = workbook.getWorksheets().get("Sheet1");
sheet1.setName("Import2DData");
sheet1.getRange("A1").setValue("旅游预算表");

// 使用二维数组导入标题。
String[][] titles = {{"员工 ID", "成人", "儿童", "房间", "水疗", "火锅", "预算"}};
sheet1.getRange("A2").importData(titles);

// 生成测试数据。你可以设置随机数生成器的种子值以获取相同的数据。
Random rnd = new Random(1234);
final int rowCount = 20;

// 从二维数组导入数据。此代码类似于使用 Range.Value。
double[][] numbers = new double[rowCount][7];
for (int i = 0; i < rowCount; i++) {
    int employeeId = rnd.nextInt(90000) + 10000;
    int adults = rnd.nextInt(3) + 1;
    int children = rnd.nextInt(3);
    int rooms = (adults + children) / 2;
    double spa = Math.ceil((adults + children) * rnd.nextDouble());
    int hotpot = adults + children;
    double budget = adults * 200 + children * 100 + rooms * 400 + spa * 188 + hotpot * 233 + 750;

    numbers[i][0] = employeeId;
    numbers[i][1] = adults;
    numbers[i][2] = children;
    numbers[i][3] = rooms;
    numbers[i][4] = spa;
    numbers[i][5] = hotpot;
    numbers[i][6] = budget;
}

DataImportResult result = sheet1.getRange("A3").importData(numbers);
int columnsImported = result.getColumnsImported();
int rowsImported = result.getRowsImported();

// 设置区域样式。
sheet1.getRange(1, 0, 1, columnsImported).setStyle(workbook.getStyles().get("标题 3"));
sheet1.getRange(2, 0, rowsImported, columnsImported).setStyle(workbook.getStyles().get("20% - 强调文字颜色 1"));
sheet1.getRange(1, 0, 1, columnsImported).的整个列().autoFit();
sheet1.getRange("A1").setStyle(workbook.getStyles().get("标题 1"));
sheet1.getRange("1:2").autoFit();
sheet1.getRange(2, 6, rowsImported, 1).setNumberFormat("$#,##0.00");
sheet1.getRange(2, 6, rowsImported, 1).的整个列().setColumnWidth(10);

// 保存工作簿。
workbook.save("Import2DData.xlsx");

import-2D-data

导入多维数组

参考以下示例代码，将多维数组导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加多维数组。
double[][][] doubleDataMt = {
        {
                {1.0, 2.0, 3.0},
                {4.0, 5.0, 6.0},
                {7.0, 8.0, 9.0}
        },
        {
                {10.0, 11.0, 12.0},
                {13.0, 14.0, 15.0},
                {16.0, 17.0, 18.0}
        },
        {
                {19.0, 20.0, 21.0},
                {22.0, 23.0, 24.0},
                {25.0, 26.0, 27.0}
        }
};

// 导入多维数组。
int startRow = 0;
for (double[][] item : doubleDataMt) {
    // 工作表不支持多维数组。
    // 但你可以使用导入结果逐个导入内部数组以进行布局。
    DataImportResult imported = worksheet.getRange(startRow, 0).importData(item);
    startRow += imported.getRowsImported();
}

// 保存工作簿。
workbook.save("ImportMultidimensionalArray.xlsx");

import-multidimensional-array

导入锯齿状数组

参考以下示例代码，将锯齿状数组导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加锯齿状数组。
double[][] doubleDataJagged = {
        {1.0, 2.0, 3.0},
        {4.0, 5.0},
        {7.0, 8.0, 9.0}
};

// 内部数组可以有不同的长度。
// 但建议保持长度一致并使用二维数组以获得更好的性能。
worksheet.getRange("A1").importData(doubleDataJagged);

// 保存工作簿。
workbook.save("ImportJaggedArrays.xlsx");

import-jagged-array

导入实体数据

参考以下示例代码，将实体数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 将工作簿的区域设置为英语（美国）。
workbook.setCulture(Locale.US);
IWorksheet sheet1 = workbook.getWorksheets().get("Sheet1");
sheet1.setName("ImportEntities");
sheet1.getRange("A1").setValue("旅游预算表");

// 生成测试数据。你可以设置随机数生成器的种子值以获得相同的数据。
Random rnd = new Random(1234);
final int rowCount = 20;

// 创建一个 TourBudget 实体列表。
List<TourBudget> tourBudgets = new ArrayList<>();

for (int i = 0; i < rowCount; i++) {
    int employeeId = rnd.nextInt(89999) + 10000;
    int adults = rnd.nextInt(3) + 1;
    int children = rnd.nextInt(3);
    int rooms = (adults + children) / 2;
    double spa = Math.ceil((adults + children) * rnd.nextDouble());
    int hotpot = adults + children;
    double budget = adults * 200 + children * 100 + rooms * 400 + spa * 188 + hotpot * 233 + 750;

    // 将实体添加到列表中。
    tourBudgets.add(new TourBudget(employeeId, adults, children, rooms, spa, hotpot, budget));
}

// 将列表导入到工作表中。
DataImportResult result = sheet1.getRange("A2").importData(tourBudgets);

// 设置区域样式。
sheet1.getRange(1, 0, 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("标题 3"));
sheet1.getRange(2, 0, result.getRowsImported() - 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("20% - 强调文字颜色 1"));
sheet1.getRange(1, 0, result.getRowsImported(), result.getColumnsImported()).getEntireColumn().autoFit();
sheet1.getRange("A1").setStyle(workbook.getStyles().get("标题 1"));
sheet1.getRange("1:2").autoFit();

// 查找预算列的索引，因为列的顺序未指定。
Object[][] titles = (Object[][]) sheet1.getRange("A2:G2").getValue();
int budgetIndex = -1;
for (int i = 0; i < titles[0].length; i++) {
    if (titles[0][i].equals("Budget")) {
        budgetIndex = i;
        break;
    }
}

// 将预算列格式设置为货币格式。
sheet1.getRange(2, budgetIndex, result.getRowsImported(), 1).setNumberFormat("$#,##0.00");
sheet1.getRange(2, budgetIndex, result.getRowsImported(), 1).getEntireColumn().setColumnWidth(10);

// 保存工作簿。
workbook.save("ImportDataFromEntities.xlsx");

import-data-from-entities

type=warning
注意：要执行此示例代码，请下载：
TourBudget.java

导入带筛选条件的实体数据

参考以下示例代码，将经过行和列筛选的实体数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 将工作簿的区域设置为英语（美国）。
workbook.setCulture(new Locale("en", "US"));
IWorksheet sheet1 = workbook.getWorksheets().get("Sheet1");
sheet1.setName("ImportEntities");
sheet1.getRange("A1").setValue("旅游预算表");

// 生成测试数据。你可以设置随机数生成器的种子值以获得相同的数据。
Random rnd = new Random(1234);
final int rowCount = 20;

// 创建一个 TourBudget 实体列表。
List<TourBudget> tourBudgets = new ArrayList<>();

for (int i = 0; i < rowCount; i++) {
    int employeeId = rnd.nextInt(90000) + 10000;
    int adults = rnd.nextInt(3) + 1;
    int children = rnd.nextInt(3);
    int rooms = (adults + children) / 2;
    double spa = Math.ceil((adults + children) * rnd.nextDouble());
    int hotpot = adults + children;
    double budget = adults * 200 + children * 100 + rooms * 400 + spa * 188 + hotpot * 233 + 750;

    // 将实体添加到列表中。
    tourBudgets.add(new TourBudget(employeeId, adults, children, rooms, spa, hotpot, budget));
}

// 按预算从高到低排序，并取前五行。
List<TourBudget> top10 = tourBudgets.stream()
        .sorted(Comparator.comparingDouble(TourBudget::getBudget).reversed())
        .limit(5)
        .collect(Collectors.toList());

// 将查询结果导入到工作表中。
// 仅显示员工 ID、成人数量、儿童数量和预算，并使用自定义列标题。
DataImportOptions options = new DataImportOptions();
options.setColumnsSelector(items -> {
    if (!(items instanceof List<?>)) return null;
    return new AbstractMap.SimpleEntry[]{
            new AbstractMap.SimpleEntry<>("员工 ID", (Function<TourBudget, Integer>) TourBudget::getEmployeeID),
            new AbstractMap.SimpleEntry<>("成人", (Function<TourBudget, Integer>) TourBudget::getAdults),
            new AbstractMap.SimpleEntry<>("儿童", (Function<TourBudget, Integer>) TourBudget::getChildren),
            new AbstractMap.SimpleEntry<>("预算", (Function<TourBudget, Double>) TourBudget::getBudget)
    };
});
DataImportResult result = sheet1.getRange("A2").importData(top10, options);

// 设置区域样式。
sheet1.getRange(1, 0, 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("标题 3"));
sheet1.getRange(2, 0, result.getRowsImported() - 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("20% - 强调文字颜色 1"));
sheet1.getRange(1, 0, result.getRowsImported(), result.getColumnsImported()).getEntireColumn().autoFit();
sheet1.getRange("A1").setStyle(workbook.getStyles().get("标题 1"));
sheet1.getRange("1:2").autoFit();
sheet1.getRange(2, 3, result.getRowsImported(), 3).setNumberFormat("$#,##0.00");
sheet1.getRange(2, 3, result.getRowsImported(), 3).getEntireColumn().setColumnWidth(10);

// 保存工作簿。
workbook.save("ImportDataFromEntitiesSelectRowsColumns.xlsx");

import-data-from-entities-rows-columns-selected

type=warning
注意：要执行此示例代码，请下载：
TourBudget.java

使用选项构建器导入实体数据

参考以下示例代码，使用“构建器”设计模式将经过行和列筛选的实体数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 将工作簿的区域设置为英语（美国）。
workbook.setCulture(Locale.US);
IWorksheet sheet1 = workbook.getWorksheets().get("Sheet1");
sheet1.setName("DataImportOptionsBuilder");
sheet1.getRange("A1").setValue("GPU 性能测试结果");
sheet1.getRange("A1:B1").merge();
sheet1.getRange("A1:B1").setStyle(workbook.getStyles().get("标题 1"));

// 设置测试数据。
FrameRateTestResult[] frameRateResults = new FrameRateTestResult[]{
        new FrameRateTestResult("GeForce RTX 4090", 154.1, "1080p 极致画质"),
        new FrameRateTestResult("Radeon RX 7900 XTX", 149.0, "1080p 极致画质"),
        new FrameRateTestResult("GeForce RTX 4080 Super", 148.3, "1080p 极致画质"),
        new FrameRateTestResult("Radeon RX 7900 XT", 143.9, "1080p 极致画质"),
        new FrameRateTestResult("GeForce RTX 4090", 146.1, "1440p 极致画质"),
        new FrameRateTestResult("Radeon RX 7900 XTX", 135.3, "1440p 极致画质"),
        new FrameRateTestResult("GeForce RTX 4080 Super", 133.0, "1440p 极致画质"),
        new FrameRateTestResult("Radeon RX 7900 XT", 125.9, "1440p 极致画质"),
        new FrameRateTestResult("GeForce RTX 4090", 114.5, "4K 极致画质"),
        new FrameRateTestResult("Radeon RX 7900 XTX", 95.1, "4K 极致画质"),
        new FrameRateTestResult("GeForce RTX 4080 Super", 91.9, "4K 极致画质"),
        new FrameRateTestResult("Radeon RX 7900 XT", 81.2, "4K 极致画质")
};

// 使用 DataImportOptionsBuilder 构建选项。代码更易于阅读和维护。
// 注意，DataImportOptionsBuilder 是此示例代码中的自定义类，并非公共 API 的一部分。
final double[] maxFrameRateOfGroup = new double[1];
DataImportOptions importOptions = new DataImportOptionsBuilder()
        .hasColumnsSelector(FrameRateTestResult.class, it -> {
            it.bind("显卡", FrameRateTestResult::getGpuName)
                    .bind("帧率", item -> String.format("%s(%sfps)",
                            NumberFormat.getPercentInstance().format(item.getFrameRate() / maxFrameRateOfGroup[0]),
                            new DecimalFormat("#.0", DecimalFormatSymbols.getInstance(Locale.US)).format(item.getFrameRate()))
                    );
        })
        .build();

// 导入分组数据并应用样式。
int curRow = 2;

// 按工作负载对帧率结果进行分组。
Map<String, List<FrameRateTestResult>> groupedResults = Arrays.stream(frameRateResults)
        .collect(Collectors.groupingBy(FrameRateTestResult::getWorkload));

for (Map.Entry<String, List<FrameRateTestResult>> group : groupedResults.entrySet()) {
    // 设置组标题。
    sheet1.getRange(curRow, 0).setValue(group.getKey());
    sheet1.getRange(curRow, 0).setStyle(workbook.getStyles().get("标题 2"));
    curRow++;

    // 按帧率从高到低对数据进行排序，并更新最大帧率。
    List<FrameRateTestResult> sortedData = group.getValue().stream()
            .sorted(Comparator.comparingDouble(FrameRateTestResult::getFrameRate).reversed())
            .collect(Collectors.toList());
    maxFrameRateOfGroup[0] = group.getValue().stream().mapToDouble(FrameRateTestResult::getFrameRate).max().orElse(0);

    // 按选项导入数据。
    DataImportResult result = sheet1.getRange(curRow, 0).importData(sortedData, importOptions);

    // 使用导入结果应用样式。
    sheet1.getRange(curRow, 0, 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("强调文字颜色 1"));
    curRow += result.getRowsImported() + 1;
}

// 设置区域布局。
IRange usedRange = sheet1.getUsedRange();
usedRange.getEntireRow().autoFit();
usedRange.getEntireColumn().autoFit();

// 保存工作簿。
workbook.save("ImportDataFromEntitiesSelectRowsColumnsBuilder.xlsx");

import-data-from-entities-rows-columns-selected-builder

type=warning
注意：要执行此示例代码，请下载：
ObjectColumnSelectorBuilder.java
ItemTypeProviderBuilder.java
FrameRateTestResult.java
DataImportOptionsBuilder.java

从自定义对象导入数据

参考以下示例代码，将弱类型集合中的自定义对象数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加猫和狗的数据。
Cat cat1 = new Cat("克里斯托弗", 3, true, "羽毛鞭");
Cat cat2 = new Cat("里希特", 2, false, "激光笔");
Dog dog1 = new Dog("朱利叶斯", 5, true);
Dog dog2 = new Dog("莱昂", 4, false);

// 创建一个数组列表。
List<Animal> animals = Arrays.asList(cat1, cat2, dog1, dog2);

// 从集合中导入数据。
DataImportOptions options = new DataImportOptions();
options.setItemTypeProvider(items -> {
    if (items instanceof Iterable<?> &&
            ((Iterable<?>) items).iterator().hasNext() &&
            ((Iterable<?>) items).iterator().next() instanceof Animal) {
        return Animal.class;
    } else {
        return null;
    }
});
worksheet.getRange("A1").importData(animals, options);

// 保存工作簿。
workbook.save("ImportCustomObjectsfromWeaklyTypedCollection.xlsx");

import-custom-objects-from-weakly-typed-collection

type=warning
注意：要执行此示例代码，请下载：
Dog.java
Cat.java
Animal.java

从未知类型的自定义对象导入数据

参考以下示例代码，将未知类型的自定义对象（鸭子类型）中的数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加猫和狗的数据。
Cat cat1 = new Cat("Christopher", 3, true, "Feather Whip");
Cat cat2 = new Cat("Richter", 2, false, "Laser Pointer");
Dog dog1 = new Dog("Julius", 5, true);
Dog dog2 = new Dog("Leon", 4, false);

// 创建一个数组列表。
ArrayList<Object> animals = new ArrayList<>();
animals.add(cat1);
animals.add(cat2);
animals.add(dog1);
animals.add(dog2);

// 从集合中导入数据。
DataImportOptions options = new DataImportOptions();
options.setItemTypeProvider(s -> Object.class);
options.setColumnsSelector(s -> new String[] {"Name", "Age", "IsIndoor", "FavoriteToy", "IsTrained"});
worksheet.getRange("A1").importData(animals, options);

// 保存工作簿。
workbook.save("ImportDatafromUnknownTypeofCustomObjectsDuckTyping.xlsx");

import-data-from-unknown-type-of-custom-objects-duck-typing

type=warning
注意： 要执行此示例代码，请下载：
Dog.java
Cat.java
Animal.java

导入动态对象

参考以下示例代码，将动态对象中的数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加一个字典。
Map<String, Object>[] customers = new Map[]{
        new HashMap<String, Object>() {{
            put("CustomerID", 1);
            put("Name", "John");
            put("CompanyName", "Arasaka");
            put("Contact", "john240891@arasaka.co.jp");
        }},
        new HashMap<String, Object>() {{
            put("CustomerID", 2);
            put("Name", "Mary");
            put("CompanyName", "Militech");
            put("Contact", "mary327670@militech.com");
        }}
};

// 从字典中导入数据。
DataImportOptions options = new DataImportOptions();
options.setColumnsSelector(items -> {
    if (items instanceof Map[]) {
        return new String[]{"CustomerID", "Name", "CompanyName", "Contact"};
    } else {
        return null;
    }
});
worksheet.getRange("A1").importData(customers, options);

// 保存工作簿。
workbook.save("ImportDynamicObjects.xlsx");

import-dynamic-objects

导入表格数据

参考以下示例代码，将 DataTable 中的数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 将工作簿区域设置为美式英语。
workbook.setCulture(Locale.US);
IWorksheet sheet1 = workbook.getWorksheets().get("Sheet1");
sheet1.setName("ImportDataTable");
sheet1.getRange("A1").setValue("Tour Budget Table");

// 创建一个 DataTable 并定义其列。
ResultSetDataTable dataTable = new ResultSetDataTable();
dataTable.getColumns().add("EmployeeID", Integer.class);
dataTable.getColumns().add("Adults", Integer.class);
dataTable.getColumns().add("Children", Integer.class);
dataTable.getColumns().add("Rooms", Integer.class);
dataTable.getColumns().add("Spa", Double.class);
dataTable.getColumns().add("Hotpot", Integer.class);
dataTable.getColumns().add("Budget", Double.class);

// 生成测试数据。你可以设置随机数生成器的种子值以获取相同的数据。
Random rnd = new Random(1234);
final int rowCount = 20;

for (int i = 0; i < rowCount; i++) {
    int employeeId = rnd.nextInt(89999) + 10000;
    int adults = rnd.nextInt(3) + 1;
    int children = rnd.nextInt(3);
    int rooms = (int) Math.floor((adults + children) / 2.0);
    double spa = Math.ceil((adults + children) * rnd.nextDouble());
    int hotpot = adults + children;
    double budget = adults * 200 + children * 100 + rooms * 400 + spa * 188 + hotpot * 233 + 750;

    // 向 DataTable 中添加行。
    dataTable.getRows().add(employeeId, adults, children, rooms, spa, hotpot, budget);
}

// 将 DataTable 导入到工作表中。
DataImportResult result = sheet1.getRange("A2").importData(dataTable);

// 设置区域样式。
sheet1.getRange(1, 0, 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("Heading 3"));
sheet1.getRange(2, 0, result.getRowsImported() - 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("20% - Accent1"));
sheet1.getRange(1, 0, result.getRowsImported(), result.getColumnsImported()).getEntireColumn().autoFit();
sheet1.getRange("A1").setStyle(workbook.getStyles().get("Heading 1"));
sheet1.getRange("1:2").autoFit();
sheet1.getRange(2, 6, result.getRowsImported(), 1).setNumberFormat("$#,##0.00");
sheet1.getRange(2, 6, result.getRowsImported(), 1).getEntireColumn().setColumnWidth(10);

// 保存工作簿。
workbook.save("ImportDataTable.xlsx");

import-data-table

选择导入表格数据

参考以下示例代码，通过 DataView 选择行和列，将 DataTable 中的数据导入到工作表中：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 将工作簿区域设置为美式英语。
workbook.setCulture(Locale.US);
IWorksheet sheet1 = workbook.getWorksheets().get("Sheet1");
sheet1.setName("ImportDataTable");
sheet1.getRange("A1").setValue("Tour Budget Table");

// 创建一个 DataTable 并定义其列。
ResultSetDataTable dataTable = new ResultSetDataTable();
dataTable.getColumns().add("EmployeeID", Integer.class);
dataTable.getColumns().add("Adults", Integer.class);
dataTable.getColumns().add("Children", Integer.class);
dataTable.getColumns().add("Rooms", Integer.class);
dataTable.getColumns().add("Spa", Double.class);
dataTable.getColumns().add("Hotpot", Integer.class);
dataTable.getColumns().add("Budget", Double.class);

// 生成测试数据。你可以设置随机数生成器的种子值以获取相同的数据。
Random rnd = new Random(1234);
final int rowCount = 20;

for (int i = 0; i < rowCount; i++) {
    int employeeId = rnd.nextInt(89999) + 10000;
    int adults = rnd.nextInt(3) + 1;
    int children = rnd.nextInt(3);
    int rooms = (int) Math.floor((adults + children) / 2.0);
    double spa = Math.ceil((adults + children) * rnd.nextDouble());
    int hotpot = adults + children;
    double budget = adults * 200 + children * 100 + rooms * 400 + spa * 188 + hotpot * 233 + 750;

    // 向 DataTable 中添加行。
    dataTable.getRows().add(employeeId, adults, children, rooms, spa, hotpot, budget);
}

// 将 DataTable 导入到工作表中。
/* 按预算从高到低排序并取前五行。
   只显示员工 ID、成人数量、儿童数量和预算。 */
DataImportOptions options = new DataImportOptions();
options.setColumnsSelector(it -> {
    if (it instanceof ResultSetDataTable) {
        return new int[]{1, 2, 3, 7};
    }
    return null;
});
DataImportResult result = sheet1.getRange("A2").importData(dataTable, options);

// 设置区域样式。
sheet1.getRange(1, 0, 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("Heading 3"));
sheet1.getRange(2, 0, result.getRowsImported() - 1, result.getColumnsImported()).setStyle(workbook.getStyles().get("20% - Accent1"));
sheet1.getRange(1, 0, result.getRowsImported(), result.getColumnsImported()).getEntireColumn().autoFit();
sheet1.getRange("A1").setStyle(workbook.getStyles().get("Heading 1"));
sheet1.getRange("1:2").autoFit();
sheet1.getRange(2, 6, result.getRowsImported(), 1).setNumberFormat("$#,##0.00");
sheet1.getRange(2, 6, result.getRowsImported(), 1).getEntireColumn().setColumnWidth(10);

// 保存工作簿。
workbook.save("ImportDataTableSelectRowsColumns.xlsx");

import-data-table-rows-columns-selected

空间不足时插入单元格

参考以下示例代码，导入数据并在空间不足时插入单元格：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加一维双精度数组。
double[] doubleData = {1.0, 2.0, 3.0, 4.0, 5.0};

// 在 A5 单元格添加值以指示向下移动。
worksheet.getRange("A5").setValue("Shift down");

// 导入数组时添加新单元格以适应数据。
DataImportOptions options = new DataImportOptions();
options.setInsufficientSpaceHandling(InsufficientSpaceHandling.InsertCells);
worksheet.getRange("A1:A4").importData(doubleData, options);

// 保存工作簿。
workbook.save("InsertCellsIfInsufficientSpace.xlsx");

insert-cells-if-insufficient-space

限制数据填充范围

参考以下示例代码，在有限的填充范围内导入数据：

// 创建一个新的工作簿。
var workbook = new Workbook();

// 访问第一个工作表。
IWorksheet worksheet = workbook.getWorksheets().get(0);

// 添加一维双精度数组。
double[] doubleData = {1.0, 2.0, 3.0, 4.0, 5.0};

// 在 A5 单元格添加值以指示现有数据。
worksheet.getRange("A5").setValue("Existing Data");

// 导入数组时截断数据以适应范围。
DataImportOptions options = new DataImportOptions();
options.setInsufficientSpaceHandling(InsufficientSpaceHandling.Truncate);
worksheet.getRange("A1:A4").importData(doubleData, options);

// 保存工作簿。
workbook.save("LimitFillRangeofData.xlsx");

limit-fill-range-of-data

限制条件

GcExcel Java 不支持 java.time.Duration 和 java.time.Period。