标签: java-stream

我无法理解为什么BinaryOperator<Integer>可以A在下面的代码中放置在的位置，而不是BiFunction<Integer, Integer>？

A foo = (a, b) -> { return a * a + b * b; };
int bar = foo.apply(2, 3);
System.out.println(bar);

有人可以帮助我理解它。

public static int amountKurse (List<Studie> lstd) {
    int result = (int) lstd.stream().map(Studie::getKurse).count();
    return result;
}

private Map<Kurs,Integer> kurse = new HashMap<>();

public Set<Kurs> getKurse(){
    return kurse.keySet();
}

我想计算Kurse我所有Studie对象中的数量。我目前的结果是20，什么时候应该是132 我猜我的功能只是计算数量Studie 将不胜感激这方面的一些帮助。

如何连接整数列表

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Optional<Integer> result = numbers.stream().reduce((subtotal, element)-> Integer.valueOf(subtotal + ", " + element));

但我有一个例外：

线程“main”中的异常java.lang.NumberFormatException：对于输入字符串：java.lang.NumberFormatException.forInputString（Unknown Source）处的“1, 2”

lambda表达式可以替代吗？使用当前的代码，我无法访问变量maxCnt，对其进行修改并发送回使用。

int maxCnt = 0;

incoming.stream().forEach(a -> {
    Integer cnt = wordFrequency.get(a);
    if (cnt != null) {
        if (cnt > maxCnt) {
            maxCnt = cnt;
        }
    }

});

我目前正在尝试使用 Java 学习流，但是我偶然发现了一个我无法自己解决的问题。给定具有Person年龄、高度和名称属性的对象列表。我想编写一个方法toString()，按高度对 List 进行排序，以防高度按年龄相等（所有内容均按降序排列）。有没有可能用流来解决这个问题？我知道如何按高度对 List 进行排序，但是我不明白如何获得相等的元素（具有相同高度的人）并按年龄对它们进行排序。

班级Person：

public class Person {
    private int age;
    private double height;
    private String name;

    public Person(int age, double height, String name){
        this.age = age;
        this.height = height;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public double getHeight() {
        return height;
    }

    public String getName() {
        return name;
    }
}

Data 类（在其中创建 toString 方法）：

public class Data {
    private List<Person> persons;

    public Data(List<Person> persons){ …

我写了一行代码来制作 if else 语句。我发现它冗长。我怎样才能使这条线更短更高效？isLocked 在这里是一个布尔值。

Stream.of( isLocked ).filter( x -> !x ).findFirst().orElseThrow( LimitLockException::new );

目标

final List<T> listOfThings = ...;

listOfThings.stream()
    .filter(...) // returns a Stream<T>
    .then(filteredListOfThings -> {
        // How do I get here so I can work on the newly filtered collection
        // in a fluent way w/out collecting the result to a variable?
        // For example, if I need to process the elements but don't 
        // care about them in their current form outside this chain.
    });

问题

在英语中，给定一个列表，我想流式传输列表，过滤它，然后对整个过滤结果进行操作。我可以用 optional 来完成这个，但它不是干净的 IMO：

final List<T> listOfThings = ...;

Optional
    .of(listOfThings.stream() …

我需要将那些与 Address1 匹配的员工密钥存储到一个新的List<EmpData>，代码如下，我可以通过正常迭代来完成。

我可以使用java8模式匹配做的collect和filter等？

public static void main(String[] args) {
    List<EmpData> lst1 = new ArrayList<EmpData>();
    List<EmpData> lst2 = new ArrayList<EmpData>();
    EmpData obj1=new EmpData("100", "Name1", "25/05/1979");
    EmpData obj2=new EmpData("101", "Name2", "25/05/1975");
    EmpData obj3=new EmpData("103", "Name3", "25/05/1976");
    lst1.add(obj1);
    lst1.add(obj2);
    lst2.add(obj3);

    HashMap<String, List<EmpData>> map = new HashMap<>();

    map.put("Address1Emp1", lst1);
    map.put("Address2Emp2", lst2);

    List<EmpData> listEmp = new ArrayList<>();
    //Need to store those employees key matching Address1 to a List<EmpData>

}

我在导入时java.util.stream.*;
遇到问题编译我的代码给了我一个流（）

“找不到符号错误”。

这是我的进口清单

import java.util.stream.*;
import java.util.*;
import java.lang.String;
import java.util.Arrays;
import java.nio.file.*;
import java.io.IOException;  

这是我正在编译的代码

List<Beverage> l = cantine.stream()
                                .filter(p -> p.name.equals(nam))
                                .collect(Collectors.toList());

重要提示：我知道什么是“找不到符号错误”，所以请不要盲目关闭这个问题。

完整代码供参考

import java.util.stream.*;
import java.util.*;
import java.lang.String;
import java.util.Arrays;
import java.nio.file.*;
import java.io.IOException;

public class Enoteca{

    Map<String,Beverage> cantine;

    public Enoteca(){
        this.cantine = new HashMap<String,Beverage>();
    }


    public List<Beverage> byName(String nam){

        List<Beverage> l = cantine.stream()
                                .filter(p -> p.name.equals(nam))
                                .collect(Collectors.toList());
    }

    public static void main(String[] args){

        Enoteca e = new Enoteca();

        for(String s: args){
            Beverage b …

我在 Eclipse 中运行了以下代码：

Stream.generate(() -> "Elsa")
      .filter(n -> n.length() ==4)
      .sorted()
      .limit(2)
      .forEach(System.out::println);

输出是：

线程“main”中的异常 java.lang.OutOfMemoryError: Java heap space

由于限制是两个，我期待的是：

Elsa
Elsa

有人可以解释为什么这是一个无限流吗？