标签: java-stream

public class ActivityInventoryMem<Activity> extends TreeSet<Activity> implements ActivityInventory<Activity> {

  @Override
  public ToDo toDo( LocalDate date ) {
    Stream<Activity> s = this.parallelStream();

    s.filter( a ->  a.completed() );
    return new ToDo();
  }
}

这是例外

java.lang.RuntimeException: Uncompilable source code - Erroneous sym type: java.util.stream.Stream.filter
at com.lm.infrastructure.memory.ActivityInventoryMem.toDo(ActivityInventoryMem.java:16)
at com.lm.infrastructure.memory.ActivityInventoryMemNGTest.testToDo(ActivityInventoryMemNGTest.java:46)

我在jdk 8中运行它,我把以下内容放入我的内容中pom.xml,它现在似乎认出了lambda的

    <!-- maven-compiler-plugin -->
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.source>1.8</maven.compiler.source>

问题(从我从netbeans收集到的)是它a只是一个Object不是Activity因为它无法看到.completed(),我怎么能解决这个问题呢？

我有一个Person用这些属性定义的类:

private String name;
private String surname;
private Date birthday;

我希望得到一个生日的最大值Collection<Person>.

在Java 7中,没有外部库,我会这样做:

public Date maxAgeJava7(Collection<Person> persons) {
  Date max = null;
  for (Person person : persons) {
    if (max == null || person.getBirthday().after(max)) {
      max = person.getBirthday();
    }
  }
  return max;
}

现在,在Java 8中,可以像这样编写它:

public Date maxAgeJava8(Collection<Person> persons) {
  return persons.stream().map(Person::getBirthday).max((Date d1, Date d2)-> d1.compareTo(d2)).get();
}

这要好得多但我不喜欢这部分:

(Date d1, Date d2)-> d1.compareTo(d2)

作为Date implements Comparable,有没有办法告诉Java使用该compareTo()方法,而不必明确地编写它？

假设我有两个double数组.我一直在尝试使用Java 8中的Stream.我想我已经理解了主要的想法,但后来我意识到我不确定如何同时操作两个Streams.

例如,我想计算两个数组的协方差.

public class foo {

    public static double mean(double[] xs) {
        return Arrays.stream(xs).average().getAsDouble();
}

    public static void main(String[] args) {
        double[] xs = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        double[] ys = {1517.93, 1757.78, 1981.1, 2215.73, 2942.66, 3558.32, 4063.91, 4521.16, 5101.76, 5234.12};

        System.out.println("Mean of xs: " + mean(xs));
        double xs_sumDeviation = Arrays.stream(xs)
            .boxed()
            .mapToDouble(d -> d.doubleValue() - mean(xs))
            .sum();
       // Covariance
        double covXY = Arrays.stream(xs, ys)
            .mapToDouble(x,y -> {
                  double numerator = (x-mean(xs)* (y-mean(ys);
                  double …

考虑我想使用Java 8流API打印文件列表的行.我该怎么写呢？

这不是我的真实情况,只是一种非常简化的形式.

File[] files;
Arrays.stream(files). // what now?

我想过把它映射File到Stream<String>但是后来我卡住了.

我有以下方法:

static IntStream streamedDivisors(final int n) {
    return IntStream.range(2, n).parallel().filter(input -> n % input == 0);
}

static int streamedPhi(final int n) {
    return streamedDivisors(n).reduce(0, x -> x * x);
}

我在streamedPhi中遇到编译错误,表明我的lambda表达式中有不兼容的参数类型.有人能帮助我理解这个吗？我基本上试图取一个给定数字n的除数,并在我定义的某个函数上聚合一个数字(在这种情况下,对数字进行平方).

我有地图列表List<Map<String,String>>并想转换成Map<String, List String>>

下面是示例代码

List<Map<String,String>> recordListMap = new ArrayList<>();

Map<String,String> recordMap_1 = new HashMap<>();
recordMap_1.put("inputA", "ValueA_1");
recordMap_1.put("inputB", "ValueB_1");
recordListMap.add(recordMap_1);

Map<String,String> recordMap_2 = new HashMap<>();
recordMap_2.put("inputA", "ValueA_2");
recordMap_2.put("inputB", "ValueB_2");
recordListMap.add(recordMap_2);

我尝试了以下方法，但没有得到所需的结果：

Map<String, List<String>> myMaps = new HashMap<>();
for (Map<String, String> recordMap : recordListMap) {
    for (Map.Entry<String, String> map : recordMap.entrySet()) {
        myMaps.put(map.getKey(), List.of(map.getValue()));
    }
}
OutPut: {inputB=[ValueB_2], inputA=[ValueA_2]}

预期结果：

{inputB=[ValueB_1, ValueB_2], inputA=[ValueA_1, ValueA_2]}

我是 Java 流和函数式编程的新手，我想知道我的问题是否有一个有效的用例，或者它只是没有意义。我有以下代码，它从数组中提供了一个集合

    public static void main(String[] args) {
        String []arr = {"a","abc","b","cd"};
        Set<String> dict = new HashSet<>();
        Arrays.stream(arr).map(item->{
            System.out.println(item);
            dict.add(item);
            return dict;
        });

//        dict = Arrays.stream(arr).collect(Collectors.toSet());
        System.out.println(dict);
    }

这给了我一个空的字典。如果我按照倒数第二行的方式去做，它就会起作用。有没有一种方法可以改变已经实例化的dict流外部实例化的数据，使其填充到函数中map？

我很了解collect() 方法和Collectors 对象。然而，我真的不明白为什么使用reduce来填充集合是不好的。

` 用户 u1 = 新用户（“汤姆”）；
用户 u2 = 新用户（“安娜”）；
用户 u3 = 新用户（“爱丽丝”）；

    BiFunction<Set<String>, User, Set<String>> accumulator = (acc, u) -> {
        acc.add(u.getLogin());
        return acc;
    };
    BinaryOperator<Set<String>> combiner = (s1, s2) -> {
        s1.addAll(s2);
        return s2;
    };

    Stream<User> stream = Stream.of(u1, u2, u3);
    Set<String> logins = new HashSet<>();
    stream.reduce(logins, accumulator, combiner);
    System.out.println(logins);// [Tom, Alice, Anna]`

这是糟糕的代码设计，还是幕后的其他原因？

累积应该在不可变对象上进行吗？

我无法使用流和 flatMap 使我的方法空安全。

我的输入是List<RequestSlot>

对象是这样嵌套的：

        Request
                OuterItem
                        List<InnerItem>

这正在努力展平列表并创建一个列表，但我不确定如何在此处添加选项以使此 null 对于每个映射/流步骤都是安全的。

  final List<InnerItem> innerItem = request.stream()
          .map(RequestSlot::getOuterItem)
          .flatMap(outerItem -> outerItem.getInnerItem().stream()).collect(Collectors.toList());

我尝试过使用 Stream.ofNullable 但最终创建了一个我不确定如何收集的流。有什么指点吗？

Boolean我有一个看起来像这样的字段列表：

var lst = List.of(true, false, false, false);

有一个这样的对象：

public class GetBatchStatusResponse {
  String batchCompleted;
  Integer totalCount;
  Integer processed;
  Integer pending;
}

上面的对象当前填充有如下内容：

var resp = new GetBatchStatusResponse();

resp.setBatchCompleted(String.valueOf( !lst.contains(false));
resp.setTotalCount(lst.size());
resp.setProcessed((int)(lst.stream().filter(p ->p!=null && p == true).count()));
resp.setPending((int)(lst.stream().filter(p ->p==null || p == false).count()));

如何在单个循环中使用流 API 实现同样的效果？