Java 8-Lambda表达式转换列表<；字符串>；列出<；DTO>；

我有一个这样的清单。要对

String

的

List

执行一些过滤，并将其转换为

DTO的
List
：

    public static void main(String[] args) {

        String[] te = {"a","B_1","c","d","e"};      
        String[] con = {"a","b","ca"};

        List<String> S  = Arrays.asList(te).parallelStream()
                .map(x -> x.replace(ISConstants.domainName, ""))
                .filter(x -> (!x.contains("_"))? ArrayUtils.contains(con, x.toLowerCase()): ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
                .filter(x -> !x.equalsIgnoreCase("b"))
                .collect(Collectors.toList());

//          List<UserDTO> ls = l.forEach;
//          System.out.println(l);

    }

publicstaticvoidmain（字符串[]args）{
字符串[]te={“a”、“B_1”、“c”、“d”、“e”}；
字符串[]con={“a”，“b”，“ca”}；
List S=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->（！x.contains（“”）？ArrayUtils.contains（con，x.toLowerCase（））：ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.collect（Collectors.toList（））；
//列表ls=l.forEach；
//系统输出打印LN（l）；
}

在这里你可以看到，我得到了一个列表S，现在我想把这个列表S转换成UserDTO列表，在这里我有一个方法
setUserName
，我想把字符串从S到userName设置成ls

任何人都知道如何使用现有lambda表达式或新表达式执行此操作。
使用另一个
map
操作，例如：

List<UserDTO> users  = Arrays.asList(te).parallelStream()
        .map(x -> x.replace(ISConstants.domainName, ""))
        .filter(x -> (!x.contains("_"))? ArrayUtils.contains(con, x.toLowerCase()): ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
        .filter(x -> !x.equalsIgnoreCase("b"))
        .map(s -> new UserDTO(s)) // or 'UserDTO::new' by using a constructor with 'name' being set
        .collect(Collectors.toList());

List users=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->（！x.contains（“”）？ArrayUtils.contains（con，x.toLowerCase（））：ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.map->new UserDTO（）//或“UserDTO:：new”，方法是使用设置了“name”的构造函数
.collect（Collectors.toList（））；

（基于）并通过使用正则表达式对其进行进一步改进，例如：

List<UserDTO> users = Arrays.asList(te).parallelStream()
        .map(x -> x.replace(ISConstants.domainName, ""))
        .filter(x -> !x.equalsIgnoreCase("b")) // filter in using simpler condition first
        .filter(x -> ArrayUtils.contains(con, x.replaceFirst("_.*", "").toLowerCase())) // simplified using regex
        .map(s -> new UserDTO(s)) // or 'UserDTO::new' by using a constructor with 'name' being set
        .collect(Collectors.toList());

List users=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->！x.equalsIgnoreCase（“b”）//首先使用更简单的条件进行筛选
.filter（x->ArrayUtils.contains（con，x.replaceFirst（“.*”，”“）.toLowerCase（））//使用正则表达式简化
.map->new UserDTO（）//或“UserDTO:：new”，方法是使用设置了“name”的构造函数
.collect（Collectors.toList（））；
使用另一个
map
操作，例如：

List<UserDTO> users  = Arrays.asList(te).parallelStream()
        .map(x -> x.replace(ISConstants.domainName, ""))
        .filter(x -> (!x.contains("_"))? ArrayUtils.contains(con, x.toLowerCase()): ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
        .filter(x -> !x.equalsIgnoreCase("b"))
        .map(s -> new UserDTO(s)) // or 'UserDTO::new' by using a constructor with 'name' being set
        .collect(Collectors.toList());

List users=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->（！x.contains（“”）？ArrayUtils.contains（con，x.toLowerCase（））：ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.map->new UserDTO（）//或“UserDTO:：new”，方法是使用设置了“name”的构造函数
.collect（Collectors.toList（））；

（基于）并通过使用正则表达式对其进行进一步改进，例如：

List<UserDTO> users = Arrays.asList(te).parallelStream()
        .map(x -> x.replace(ISConstants.domainName, ""))
        .filter(x -> !x.equalsIgnoreCase("b")) // filter in using simpler condition first
        .filter(x -> ArrayUtils.contains(con, x.replaceFirst("_.*", "").toLowerCase())) // simplified using regex
        .map(s -> new UserDTO(s)) // or 'UserDTO::new' by using a constructor with 'name' being set
        .collect(Collectors.toList());

List users=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->！x.equalsIgnoreCase（“b”）//首先使用更简单的条件进行筛选
.filter（x->ArrayUtils.contains（con，x.replaceFirst（“.*”，”“）.toLowerCase（））//使用正则表达式简化
.map->new UserDTO（）//或“UserDTO:：new”，方法是使用设置了“name”的构造函数
.collect（Collectors.toList（））；
假设
DTO
有一个构造函数，它接受一个
字符串
，您可以映射它：

List<DTO> S  = Arrays.asList(te).parallelStream()
            .map(x -> x.replace(ISConstants.domainName, ""))
            .filter(x -> (!x.contains("_"))? ArrayUtils.contains(con, x.toLowerCase()): ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
            .filter(x -> !x.equalsIgnoreCase("b"))
            .map(x -> new DTO(x))
            .collect(Collectors.toList());

List S=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->（！x.contains（“”）？ArrayUtils.contains（con，x.toLowerCase（））：ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.map（x->新DTO（x））
.collect（Collectors.toList（））；

或更容易使用方法参考：

List<DTO> S  = Arrays.asList(te).parallelStream()
            .map(x -> x.replace(ISConstants.domainName, ""))
            .filter(x -> (!x.contains("_"))? ArrayUtils.contains(con, x.toLowerCase()): ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
            .filter(x -> !x.equalsIgnoreCase("b"))
            .map(DTO::new)
            .collect(Collectors.toList());

List S=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->（！x.contains（“”）？ArrayUtils.contains（con，x.toLowerCase（））：ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.map（DTO:：新建）
.collect（Collectors.toList（））；
假设
DTO
有一个构造函数，它接受一个
字符串
，您可以映射它：

List<DTO> S  = Arrays.asList(te).parallelStream()
            .map(x -> x.replace(ISConstants.domainName, ""))
            .filter(x -> (!x.contains("_"))? ArrayUtils.contains(con, x.toLowerCase()): ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
            .filter(x -> !x.equalsIgnoreCase("b"))
            .map(x -> new DTO(x))
            .collect(Collectors.toList());

List S=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->（！x.contains（“”）？ArrayUtils.contains（con，x.toLowerCase（））：ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.map（x->新DTO（x））
.collect（Collectors.toList（））；

或更容易使用方法参考：

List<DTO> S  = Arrays.asList(te).parallelStream()
            .map(x -> x.replace(ISConstants.domainName, ""))
            .filter(x -> (!x.contains("_"))? ArrayUtils.contains(con, x.toLowerCase()): ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
            .filter(x -> !x.equalsIgnoreCase("b"))
            .map(DTO::new)
            .collect(Collectors.toList());

List S=Arrays.asList（te）.parallelStream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->（！x.contains（“”）？ArrayUtils.contains（con，x.toLowerCase（））：ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.map（DTO:：新建）
.collect（Collectors.toList（））；
正如其他答案所示，您可以使用一个构造函数来接收
字符串并将用户名设置为DTO

或者，如果您无法添加此类构造函数，则可以执行以下操作：

List<UserDTO> result = Arrays.asList(te).stream()
        .map(x -> x.replace(ISConstants.domainName, ""))
        .filter(x -> !x.contains("_") ? 
                     ArrayUtils.contains(con, x.toLowerCase()) : 
                     ArrayUtils.contains(con, x.split("_")[0].toLowerCase()))
        .filter(x -> !x.equalsIgnoreCase("b"))
        .map(x -> {
                     UserDTO u = new UserDTO();
                     u.setUserName(x);
                     return u;
         })
        .collect(Collectors.toList());

List result=Arrays.asList（te）.stream（）
.map（x->x.replace（ISConstants.domainName，“”）
.filter（x->！x.contains（“”）？
ArrayUtils.contains（con，x.toLowerCase（））：
ArrayUtils.contains（con，x.split（“”）[0].toLowerCase（））
.过滤器（x->！x.EqualSignalCase（“b”））
.map（x->{
UserDTO u=新的UserDTO（）；
u、 setUserName（x）；
返回u；
})
.collect（Collectors.toList（））；

在这里，我使用
Stream.map
将字符串转换为
UserDTO
，并将该字符串设置为用户名。
正如其他答案所示，您可以使用接收
字符串的构造函数