Set<String> set = new HashSet<>(); for (SeriousProdChangeBO seriousProdChangeBO : dataList) { set.add(seriousProdChangeBO.getChangePeopleEmail()); set.add(seriousProdChangeBO.getRiskLeaderFirstEmail()); } 这个能改成 lamda表达式么

当然可以将这段代码改写成Lambda表达式。Lambda表达式是Java 8引入的一种简洁的语法，用于编写函数式接口的实现。

你可以使用`forEach`方法来遍历`dataList`，然后使用Lambda表达式将元素添加到集合中。以下是修改后的代码示例：

Set<String> set = new HashSet<>();
dataList.forEach(seriousProdChangeBO -> {
    set.add(seriousProdChangeBO.getChangePeopleEmail());
    set.add(seriousProdChangeBO.getRiskLeaderFirstEmail());
});

在Lambda表达式中，箭头`->`前面是参数列表，后面是方法体。在这个示例中，参数`seriousProdChangeBO`代表`dataList`中的每个元素，然后将其添加到集合中。

请注意，Lambda表达式只能用于函数式接口，即只有一个抽象方法的接口。在这个示例中，`forEach`方法接受一个函数式接口作为参数，因此可以使用Lambda表达式来实现接口的抽象方法。

相关问题

当ADto中有sId字段，写一个共通方法，参数为List<ADto>、ADto.class、filePath，将List<ADto>出力到csv文件中，且sId只出力一次

可以使用Java中的CSVWriter类来实现将List<ADto>输出到CSV文件中，同时只输出sId字段一次的需求。

以下是可能的实现方法：

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import com.opencsv.CSVWriter;

public class CsvUtils {

    public static <T> void writeCsvFile(List<T> dataList, Class<T> clazz, String filePath) throws IOException {
        File file = new File(filePath);
        FileWriter outputfile = new FileWriter(file);

        CSVWriter writer = new CSVWriter(outputfile);

        // 获取 sId 字段名
        Field sIdField = null;
        try {
            sIdField = clazz.getDeclaredField("sId");
        } catch (NoSuchFieldException | SecurityException e) {
            e.printStackTrace();
        }

        // 使用 Set 存储已经输出过的 sId 值
        Set<Object> sIdSet = new HashSet<>();

        // 输出表头
        String[] header = clazz.getDeclaredFields().stream().map(Field::getName).toArray(String[]::new);
        writer.writeNext(header);

        // 输出每一行数据
        for (T data : dataList) {
            String[] row = new String[header.length];
            for (int i = 0; i < header.length; i++) {
                Field field = null;
                try {
                    field = clazz.getDeclaredField(header[i]);
                    field.setAccessible(true);
                    Object value = field.get(data);
                    // 如果当前字段是 sId，且该值已经输出过，就将其设为 null
                    if (field.equals(sIdField) && !sIdSet.add(value)) {
                        value = null;
                    }
                    row[i] = value == null ? "" : value.toString();
                } catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            writer.writeNext(row);
        }

        writer.close();
    }
}

这个方法接收三个参数：

- dataList：要输出的数据列表
- clazz：数据类型的 Class 对象
- filePath：输出文件的路径

方法中首先使用反射获取 sId 字段名和所有表头，然后使用 Set 存储已经输出过的 sId 值。在输出每一行数据时，如果当前字段是 sId 且该值已经输出过，则将其设为 null。最后使用 CSVWriter 将数据输出到文件中。

为了使用上述方法，需要在 ADto 类中增加 sId 的 getter 方法，例如：

public class ADto {
    private int sId;
    // 其他字段

    public int getsId() {
        return sId;
    }

    // 其他 getter 和 setter 方法
}

使用示例：

List<ADto> dataList = new ArrayList<>();
// 添加数据到 dataList

String filePath = "path/to/output.csv";
CsvUtils.writeCsvFile(dataList, ADto.class, filePath);

这将会将 dataList 中的数据输出到 filePath 对应的文件中。

当ADto中有次位为大写字母的字段，写一个共通方法，参数为List<ADto>、ADto.class、filePath，将List<ADto>出力到csv文件中，且次位为大写字母的字段只出力一次

可以尝试使用反射和Set集合来实现该需求。具体的步骤如下：

1. 定义一个方法，接收参数为List<ADto>、Class<T>、String，其中List<ADto>表示需要导出的数据，Class<T>表示数据类型，String表示文件路径。

public static <T> void exportToCsv(List<T> dataList, Class<T> clazz, String filePath) {
   // TODO
}

2. 使用反射获取所有字段，并找到次位为大写字母的字段。

Field[] fields = clazz.getDeclaredFields(); // 获取所有字段
Set<String> upperCaseFields = new HashSet<>(); // 存储次位为大写字母的字段
for (Field field : fields) {
    String fieldName = field.getName();
    if (fieldName.length() >= 2 && Character.isUpperCase(fieldName.charAt(1))) {
        upperCaseFields.add(fieldName);
    }
}

3. 将数据写入csv文件中。在写入每一行数据之前，先判断该行是否已经输出过次位为大写字母的字段，如果已经输出，则不再输出，否则输出该字段并将其标记为已输出。

try (CSVPrinter printer = new CSVPrinter(new FileWriter(filePath), CSVFormat.DEFAULT)) {
    // 输出表头
    List<String> headerList = new ArrayList<>();
    for (Field field : fields) {
        headerList.add(field.getName());
    }
    printer.printRecord(headerList);

    // 输出数据
    Set<String> printedFields = new HashSet<>(); // 存储已经输出过的字段
    for (T data : dataList) {
        List<String> recordList = new ArrayList<>();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(data);
            if (value == null) {
                recordList.add("");
            } else {
                recordList.add(value.toString());
            }
            if (printedFields.contains(field.getName()) || !upperCaseFields.contains(field.getName())) {
                continue; // 已经输出过或者不是次位为大写字母的字段，则不需要再输出
            }
            printer.print(field.getName()); // 输出次位为大写字母的字段
            printedFields.add(field.getName()); // 标记为已输出
        }
        printer.printRecord(recordList);
    }
} catch (IOException e) {
    e.printStackTrace();
}

完整代码如下：

public static <T> void exportToCsv(List<T> dataList, Class<T> clazz, String filePath) {
    Field[] fields = clazz.getDeclaredFields(); // 获取所有字段
    Set<String> upperCaseFields = new HashSet<>(); // 存储次位为大写字母的字段
    for (Field field : fields) {
        String fieldName = field.getName();
        if (fieldName.length() >= 2 && Character.isUpperCase(fieldName.charAt(1))) {
            upperCaseFields.add(fieldName);
        }
    }
    try (CSVPrinter printer = new CSVPrinter(new FileWriter(filePath), CSVFormat.DEFAULT)) {
        // 输出表头
        List<String> headerList = new ArrayList<>();
        for (Field field : fields) {
            headerList.add(field.getName());
        }
        printer.printRecord(headerList);

        // 输出数据
        Set<String> printedFields = new HashSet<>(); // 存储已经输出过的字段
        for (T data : dataList) {
            List<String> recordList = new ArrayList<>();
            for (Field field : fields) {
                field.setAccessible(true);
                Object value = field.get(data);
                if (value == null) {
                    recordList.add("");
                } else {
                    recordList.add(value.toString());
                }
                if (printedFields.contains(field.getName()) || !upperCaseFields.contains(field.getName())) {
                    continue; // 已经输出过或者不是次位为大写字母的字段，则不需要再输出
                }
                printer.print(field.getName()); // 输出次位为大写字母的字段
                printedFields.add(field.getName()); // 标记为已输出
            }
            printer.printRecord(recordList);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}