标签: java-stream

所以我知道我可以用两.stream行来做到这一点,但不确定我是否只能用一行来做到这一点.这就是我所拥有的:

List<Long> abcIds= abcController.findByUserIds(userIds)
      .stream()
      .map(Abc::getAbcId)
      .collect(Collectors.toList());

但我希望abcIds成为一个整数列表,因为稍后我会使用它的其他函数.我知道我可以写这样的另一行来将List of Long转换为整数列表:

List<Integer> abcIntIds= abcIds.stream()
           .map(Long::intValue)
           .collec?t(Collectors.toList(??));

但有没有办法把它写得更优雅？

我想用优雅的java 8流或lambda解决方案替换以下for循环.有什么简洁有效的吗？

    public static void main(String[] args) {
        ArrayList<Integer> myList = new ArrayList<>( Arrays.asList( 10,-3,5));

        // add 1/2 of previous element to each element
        for(int i =1 ;i < myList.size();  ++i )
            myList.set(i, myList.get(i)+myList.get(i-1)/2);

        // myList.skip(1).forEach( e -> e + prevE/2 );  // looking for something in this spirit
    }

我写了这段代码:

private double[] myArray = {1.0, 2.4, 9.3};

public void testMet(double value){
    if(Arrays.asList(myArray).stream().noneMatch(a -> a==value)){
       ...
    }
}

我收到了错误Operator '==' cannot be applied to 'double[]', 'double.这是什么问题,我该如何解决？

我想使用java 8流方法从列表中获取最大值.

结构如下:

• 我读了一个csv文件,并将每行的数据存储在一个单独的类型对象中Round.
• 所有这些Round对象都存储在一个ArrayList被调用的中arrRound
• 所有Round对象都有一个字段:List<Hit> hits
• a Hit由2个字段组成:int numberOfGames和int prizeAmount

public class Round{
    private List<Hits> hits; 
}
public class Hits{
    private int numberOfGames;
    private int prizeAmount;
}

我想要做的是迭代所有元素arrRound,获取他们的命中字段的getPrizeAmount()方法并获得最大值.我开始如下,但似乎无法做到:

public class Main(){
    public void main(String[]args){
        List<Round> arrRound = getRoundFromCSV();
        int maxPrize = arrRound.stream()
                               .forEach(round -> {
                                 round.getHits()
                                      .forEach(hit -> hit.getPrizeAmount());
                                });
    }
}

而且我无法在声明的末尾调用max().

提前谢谢你的帮助!

我有ArrayList一个类对象,如下所示:

ArrayList<Score> scoreboard = new ArrayList<>();

该Score班有一个字段points:

class Score {
    private int points; 
    //constructor and methods
}

我将如何使用Java流来比较points每个Score对象并返回具有最高/最低值的对象？

我试过这样的东西,但它不起作用:

scoreboard
    .stream()
    .max(Comparator.comparing(Score::getPoints)
    .get()
    .forEach(System::println);

从java 8开始迭代通过列表我可以使用两者:

List list = new ArrayList();
1. list.forEach(...)
2. list.stream().forEach(...)

使用第二种情况有什么好处吗？要将列表转换为流？

我有一个大十进制值列表,也有一个特定输入也是一个BigDecimal.我想将特定输入与List中的值进行比较,并选择最接近特定输入的值.有什么建议吗？

    private static BigDecimal getWageMultiplier(List<BigDecimal> values, BigDecimal valueAmount) {

    values.sort(BigDecimal::compareTo);

    int index = values.indexOf(valueAmount);

    // Check for an exact match and if not get the index of the previous value
    if (index == -1) {

        // start with the highest index, in case there is no higher value than the previous
        index = values.size() - 1;

        for (int i = 0; i < values.size(); i++) {
            //work out the value from the List<BigDecimal> values that is closest to BigDecimal valueAmount …

我有一个ArrayList,其中包含以下内容 - CHENNAI,MUMBAI,DELHI,CHENNAI,DELHI,CHENNAI.此外,假设这3个城市名称被定义为具有针对每个城市的值的ENUM.(CHENNAI = 1,MUMBAI = 2和DELHI = 3)

我的Java 8 Streams,我能够计算城市值的总和,在这种情况下,它将是1 + 2 + 3 + 1 + 3 + 1 = 11.

问题是,如果有一个额外的标准,我怎么能计算相同ArrayList的城市值之和,

如果城市名称出现两次,则必须仅添加一次.即在这种情况下,CHENNAI存在3次.因此,当添加其值时,我们应该只考虑1(对于前2次出现)+ 1 = 2而不是3.同样,DELHI出现2次.因此,德里的价值应该只采取一次.因此,如前所述,最终结果将是2 + 2 + 3 = 7而不是11.

请帮助如何在Java 8中实现这一点

我正在研究Java 8中的Stream API,我遇到了一个问题.问题是我试图理解 以下代码之间()->new StringBuilder和 之间的差异StringBuilder::new:

Stream<String> stream = Stream.of(new String[]{"b", "a", "s", "i", "l",});
StringBuilder basil = stream.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append);
System.out.println("basil");

和

Stream<String> stream = Stream.of(new String[]{"b", "a", "s", "i", "l",});
    StringBuilder basil = stream.collect(()->new StringBuilder(), StringBuilder::append, StringBuilder::append);
    System.out.println("basil");

我何时应该使用第一种语法,何时应该选择第二种语法？

为什么上面的代码接受StringBuilder::append并且不接受StringBuilder::reverse

我有两个清单。

List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 2));
List<Integer> list2 = new ArrayList<>(Arrays.asList(2, 3, 4));

我想删除的元素包含在list2从list1，正是多次，因为它们包含在list2。在上面的示例中：当我们删除列表1中存在于列表2中的元素时，我们应该得到结果[1, 2]（由于仅包含的一个实例，因此2应该从中删除一次出现）。list1list22

我尝试过，list1.removeAll(list2);但得到的结果列表仅包含[1]。

实现此目标的最佳方法是什么？同时浏览两个列表对我来说似乎有点麻烦。