标签: java-stream

我被问到的问题是：

找到并打印（每行一个）的那些值一个是形式3×+ 1对于一些x的。每个这样的值应该只打印一次，在它第一次出现的位置。

我尝试了许多模的变体来尝试获得正确的数字，但我似乎无法解决这个问题。

这是我开始的代码：

import java.util.*;
import java.util.stream.*;

class Example {

  public static void main(String argv[]) {
    int a[] =
      Arrays.stream(argv)
      .mapToInt(s -> Integer.parseInt(s))
      .toArray();
  }
      // fill in here with expression starting Arrays.stream(a)

}

谢谢你的帮助。

我有一个 Person 类：

@Data
public class Person {
   private Integer id;
   private String status;
}

我有一个名为 personList 的人员列表：

[{ 
    "id": null,
    "status": "inactive"
 },
 { 
    "id": 2,
    "status": "inactive"
 },
 { 
    "id": null,
    "status": "active"
 }]

现在我需要找到所有状态为“非活动”的人，无论该人是否有 Id。如果某人没有 Id，但状态为“活跃”，则也包括该人。我正在使用 Java 流进行过滤：

 List<Person> inactivePersonList = 
     personList.stream()
               .filter(person -> person.getStatus().equals("inactive"))
               .filter(person -> person.getId() == null && person.getStatus().equals("active"))
               .collect(Collectors.toList());

直播后的结果是没人接听。第一个人没有被选中，因为它没有通过第二个过滤器，最后一个人没有被选中，因为它没有通过第一个过滤器。

我想我可以通过使用 将两个过滤器合二为一来修复它OR，但我试图使每个过滤器变得简单，所以在我进行更改之前，我想问一下是否有更好的方法来做到这一点。谢谢。

当以相同的顺序应用于相同的一系列条件时，||和 在Stream.of(..).anyMatch(e-> e==true)功能上是否相同？

任务：对一系列条件运行快速测试以确定是否有任何条件为真。

可能的解决方案： - 用“或”符号 ( ||)分隔每个条件 - 将每个条件包含在Stream.of(..)附加的语句中.anyMatch(e-> e==true)

anyMatch(..)状态文档“返回此流的任何元素是否与提供的谓词匹配。如果不是确定结果所必需的，则不得评估所有元素的谓词[强调]。”

基于这种说法，我的理解是，上面指出的两个解决方案在功能上是相同的，因此如果 4 组中的第二个元素是第一个元素 ，则true不会评估元素 3 和 4。

然而，在实践中，这似乎不是真的。考虑以下 where itemis null、emptyistrue和UtilMethods.isEmpty(..)is 是一个自定义库方法，用于测试给定参数是null还是空String("")：

@Override
protected void updateItem(Pair<K, V> item, boolean empty) {
    super.updateItem(item, empty);

    boolean test1 = empty
             || Objects.isNull(item)
             || UtilMethods.isEmpty(item.toString())
             || Objects.isNull(item.getValue());

    boolean test2 = Stream.of(
        empty,
        isNull(item),
        UtilMethods.isEmpty(item.toString()),
        isNull(item.getValue()))
    .anyMatch(e …

我创建了一个 Java 流：

List<Student> getStudentWithSameGrade(List<Student> students, Grade grade) {
    return students.stream().filter(s -> s.getGradeId().equals(grade.getGid())).collect(Collectors.toList());
}

上面的代码返回一个List<Student>满足filter检查但我想为不满足此检查的学生/学生列表抛出异常。我尝试做这样的事情，

return students.stream().filter(s -> s.getGradeId().equals(grade.getGid())).findAny()
                .orElseThrow(() -> new EntityNotFoundException(ENTITY_NOT_FOUND));

但是，上面的代码片段返回的是单个学生对象而不是列表。我对这个Stream概念比较陌生，所以非常感谢这方面的帮助。

我有一个对象列表，我必须从中创建一个HashMap<String,String>或ConcurrentHashMap<String,String>在对列表中的每个对象应用某些逻辑之后。这是在不使用 java 8 的情况下完美运行的代码。

 for (Model model : parser.getList()) {
       String name = model.getName();
       String val = parser.getValue(arr, name);
       map.putIfAbsent(name, val);
 }

我能够将其翻译为

Map<String, String> map = new HashMap<>();
parser.getList().forEach(model -> map.putIfAbsent(model.getName(),parser.getValue(arr,model.getName())));

但是，我想探索 的用法，Collectors.toMap看看我是否可以在这个用例中利用它。我试图做类似下面的事情，但这不是正确的用法，因为我无法使用 params调用方法parser.getValuetoMap()。

 Map<String,String> valMap = parser.getFieldList().stream().collect(Collectors.toMap(Model::getName,parser.getValue(arr,Model::getName),(left,right)->right),HashMap::new); 

Collectors.toMap()当我创建一个 POJO ValHolder 来保存如下值时，我能够使用它。

Map<String,String> tranMap = parser.getFieldList().stream().map(model -> {
        return new ValHolder(model.getName(),parser.Value(dataArray,model.getName()));
}).collect(Collectors.toMap(ValHolder::getName,ValHolder::getValue,(x,y)->y,HashMap::new));

为保存值而创建的 POJO 如下

class ValHolder {

    String name;
    String value;

    public String getName() {
        return name;
    } …

我有以下方法将单行转换为地图

并想使用 java8 将其转换为单行语句

输入管道分隔的字符串，例如：status:MYSTATUS|data1:value1

public Map<String, String> getMap(String attributeUpdate){
    Map<String, String> attr = new HashMap<>();
    if(StringUtils.isNotEmpty(attributeUpdate)){
        List<String> a = Arrays.asList(attributeUpdate.split("\\|"));
        for (String s : a) {
            String[] key_val = s.split(":");
            if(key_val.length == 2) {
                attr.put(key_val[0], key_val[1]);
            }
        }
    }
    return attr;
}

所以，我有一个 int[] arr 并且想在过滤掉最小 int 的同时使用流对其进行求和。我有一个使用两个流的解决方案，它有效但似乎无效。有没有办法只用一个流来做到这一点？

代码：

int min = Arrays.stream(arr)
                    .min()
                    .getAsInt();
int sum = Arrays.stream(arr)
                       .filter(i -> i != min)
                       .sum();

我正在学习 lambda 表达式。我正在尝试计算值。

这是示例：

double sendersCount = 0.0;
double reciversCount = 0.0;
for(RecordDTO record : records){
   if("1".equals(record.getSendersId())) {
     sendersCount += record.getCount().doubleValue();
   } else {
     reciversCount +=  record.getCount().doubleValue();
   }
}

class Record{

private String id;
private BigDecimal count;
private String senderId;

//setters
//getters
}

我们如何使用Streams和maps来实现？

想象一个具有 3 个属性的简单对象：

public class Obj {

    boolean toBeAdded;
    String type;
    int order;

    public Obj(boolean toBeAdded, String type, int order) {
        this.toBeAdded = toBeAdded;
        this.type = type;
        this.order = order;
    }

    public boolean isToBeAdded() {
        return toBeAdded;
    }

    public String getType() {
        return type;
    }

    public int getOrder() {
        return order;
    }

}

想象一下，我有一个包含多个Obj不同类型的列表：

import java.util.Arrays;
import java.util.List;

public class Utils {

    static List<Obj> createA(){
        List<Obj> list = Arrays.asList(
                new Obj(true, "A", 1),
                new Obj(false, "A", 2),
                new …

public class Result {
  ...
  private Integer averageRating;
}

我有一个结果列表List<Result>。我想对它们进行排序averageRating，然后想要将特定索引形成为特定索引，例如 10 到 20。

我可以使用Collection.sort()using Comparator.comparing()then take sublist from list来做到这一点。但问题是更高的索引可能大于列表大小，这就是我必须手动处理的原因。像 10 到 20，但列表大小为 15，则将输出 5 个项目。

但是我如何使用 Java Stream API 做到这一点？

我尝试了一些但没有奏效：

List<Result> result = list.stream().sorted(e -> e.getAverageRating()).collect(Collectors.toList());