标签: java-stream

我有这个代码:

List<Application> applications = this.applicationDao.findAll();
Collection<Pair<Application, FileObject>> files = applications.stream()
    .flatMap(app -> streamOfFiles.map(file -> Pair.of(app, file)));

这里streamOfFiles是一个Stream<FileObject>

目前,我收到此编译消息:

类型不匹配:无法转换Stream<Object>为Collection<Pair<Application,FileObject>>

有任何想法吗？

我试图将一个对象数组映射到具有不同类型对象的另一个数组，我曾经在Java 8中使用流来做到这一点，这很简单，实例化一个对象设置其值并返回该对象。我刚切换到Kotlin，实际上有时候做这种操作更令人困惑。我发现的所有示例都非常简单，找不到我想要的东西。

我有这个BalanceMap类：

data class BalanceMap @JsonCreator constructor( var balType: String, var value: Any )

我正在从Web服务获取数据。

val balances: List<AcctBal> = res.getAcctBals();

AcctBal类如下所示

public class AcctBal {

  @SerializedName("CurAmt")
  @Expose
  private CurAmt curAmt;

  @SerializedName("Desc")
  @Expose
  private String desc;

  @SerializedName("ExpDt")
  @Expose
  private LocalDateTime expDt;
}

并尝试将该响应映射到 var balanceList: List<BalanceMap>

balances.map {}

-> var balanceList: List<BalanceMap> = balances.map { t -> fun AcctBal.toBalanceMap() = BalanceMap( balType = "", value = "" )}

我想做这样的事情：

List<ProductDetail> details = acctBal.stream().filter(f -> f.getBalType() != null).map(e -> {
                String …

我喜欢上课

public class RoleAccess {

    private String roleId;

    private List<String> apiIdList;

    public String getRoleId() {
        return roleId;
    }

    public void setRoleId(String roleId) {
        this.roleId = roleId;
    }

    public List<String> getApiIdList() {
        return apiIdList;
    }

    public void setApiIdList(List<String> apiIdList) {
        this.apiIdList = apiIdList;
    }

}

我想创建一个新列表,它将添加来自roleaccess的所有apiIdlist

List<String> apiIdList = new ArrayList<>();
for (RoleAccess roleAccess : roleAccessList) {
            if (roleAccess.getApiIdList() != null) {
                apiIdList.addAll(roleAccess.getApiIdList());
            }
        }

我们如何处理流api或哪个是最佳解决方案呢？

我检查了正常的对象列表列表,但我想要列出的对象和内部列表列表我试过这个

  List<String> apiIdList = roleAccessList.stream()
                          .map(RoleAccess::getApiIdList)
                          .collect(ArrayList::new, List::addAll, List::addAll);

我正在尝试在名为的ArrayList上执行以下流操作parts:

parts
    .stream()
    .map(t -> t.toLowerCase())
    .distinct()
    .sorted()
    .collect(Collectors.toList());

其中parts包含这样的字符串:

Adventures
in
Disneyland
Two
blondes
were
going
to
Disneyland
....

除了查看调试器之外,parts根本没有改变.不确定我是否错过了这个过程的一些步骤？

给定字母到数字的映射，我想返回一个字符串列表，其中每个字符串都是以逗号分隔的列表，这些列表按字母的关联编号分组。

对于这张地图

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("A", 1);
    map.put("B", 2);
    map.put("C", 4);
    map.put("D", 1);
    map.put("E", 1);
    map.put("F", 2);

我想返回一个包含以下内容的列表：

"A,D,E" "B,F", "C"

有什么建议可以使用1.8流功能实现吗？

我想将流收集到Map中，其中的键已排序，所以我尝试了：

TreeMap<LocalDate, MenuChart2.Statistics> last3MPerDay =    

                menuPriceByDayService.findAllOrderByUpdateDate(menu, DateUtils.quarterlyDate(), 92)
                .stream()
                .sorted(comparing(MenuPriceByDay::getUpdateDate))
                .collect(Collectors
                        .toMap(MenuPriceByDay::getUpdateLocalDate, p -> new MenuChart2().new Statistics( p.getMinPrice().doubleValue(), 

但是我遇到了编译错误

Type mismatch: cannot convert from Map<LocalDate,Object> to 
 TreeMap<LocalDate,MenuChart2.Statistics>

假设我有一个字符串列表，我想将这些字符串用作流利的构建器的输入。

List<String> scripts;

//initialize list

ScriptRunnerBuilder scriptRunnerBuilder = new ScriptRunnerBuilder();

BiFunction<String,ScriptRunnerBuilder,ScriptRunnerBuilder> addScript = 
(script,builder) -> builer.addScript(script);

scriptRunnerBuilder = scripts.stream.map(script -> 
addScript.apply(script,scriptRunnerBuilder)).......

scriptRunnerBuilder.build();

我可以使用哪个终端操作，以便对列表中的所有元素调用addScript函数？

问题在于ScriptRunnerBuilder是不可变的，因此ScriptRunnerBuilder.addScript（）返回新的ScriptRunnerBuilder对象，而不是修改现有对象-因此，我不能只是一个foreach。

我的意图是携带addScript（）调用的结果，并将其用作流中下一个元素的输入

我有两个地图，我需要检查两者是否具有相同的键和相同的键数，并返回一个布尔值。我想为此使用流，我得到的是通过创建另一个列表

mapA
.entrySet()
.stream()
.filter(entry -> mapB.containsKey(entry.getKey()))
.collect(
    Collectors.toMap(Entry::getKey, Entry::getValue));

但是我的问题是，我可以在一行中执行此操作吗？它不会创建另一个列表，但是会返回一个布尔值，无论它们是否相同。

我有一系列的Java方法，所有的外观，除了不同的类象一样Class1Number，Class2Number，Class3Number等如下实施。有什么方法可以编写一个将类作为参数的方法？

Set<String> trimClass1NumberList(Set<String> criteria){
    Set<String> validData = new HashSet<>();
    Set<Class1Number> numberList = criteria.stream().map(String::trim).map(Class1Number::valueOf)
        .filter(Class1Number::isWellformed).collect(Collectors.toSet());
    for (Class1Number num : numberList) {
        // Do somehing with validData
    }
    return validData;
}

Set<String> trimClass2NumberList(Set<String> criteria){
    Set<String> validData = new HashSet<>();
    Set<Class2Number> numberList = criteria.stream().map(String::trim).map(Class2Number::valueOf)
        .filter(Class2Number::isWellformed).collect(Collectors.toSet());
    for (Class2Number num : numberList) {
        // Do somehing with validData
    }
    return validData;
}

我有一个Terminal对象：

class Terminal{

    List<TerminalPeriodApplicability> periods= new ArrayList<>();
    //few other attributes

    //getters & setters

}

TerminalPeriodApplicability 宾语：

class TerminalPeriodApplicability{

    String name;
    boolean isRequired;
    //getters & setters
}

我想根据的值TerminalPeriodApplicability将optional＆mandatory Set的名称分为两类isRequired。

我尝试了两种方法。一个与两个forEach，另一个与flatMap。

List<Terminal> terminals= getTerminals();
Set<String> mandatoryPeriods = new HashSet<>();
Set<String> optionalPeriods = new HashSet<>();

方法1：

terminals.forEach(terminal -> terminal.getApplicablePeriods().forEach(period->{
    if(period.getIsRequired())
        mandatoryPeriods.add(period.name());
    else
        optionalPeriods.add(period.name());
}));

方法二：

List<TerminalPeriodApplicability> applicablePeriods = terminals
                .stream()
                .flatMap(terminal -> terminal.getApplicablePeriods().stream())
                .collect(Collectors.toList());

applicablePeriods.forEach(period->{
    if(period.getIsRequired())
        mandatoryPeriods.add(period.name());
    else …