标签: java-stream

我基本上想做的事情如下:

  assertEquals(Arrays.asList(1,2,3).stream()
                                   .noDiscardingFilter(x -> x!=1)
                                   .map(x -> x*10)
                                   .collect(Collectors.toList()),  
                Arrays.asList(1,20,30)
              )

这是一个例子,我不需要得到如何解决这个特定问题的答案,这只是一个例子来展示我正在追求的奇特东西.

我有这样的旧式代码:

        if (setContainer.getSet() == null) {
            return null;
        }
        for (SetElement setElement : setContainer.getSet()){
            if ("SomeString".equals(SetElement.getCode())) {
                return  setElement.getValue();
            }
        }
        return null;

我试过这个,但它不会检查Set是否为null:

setContainer.getSet()
                    .stream()
                    .filter(setValue ->  "SomeValue".equals(setElement.getCode()))
                    .map(SetElement::getValue)
                    .findAny()
                    .orElse(null) ;

据我所知,我应该使用,Stream.of() 但我不明白如何执行上面的代码,因为它总是返回Optional<Set<SetElement>>

我需要计算每个字符串的出现次数

ArrayList<ArrayList<String>>

我知道如何使用旧的java 7及以下方法,但是想要使用流和收集器来实现它

理想情况下,我会将结果保存在HashMap<String, Integer>,其中integer是多次出现而String是相应的字符串.

反之亦然 - 这不是什么大问题.

我找到了解决方法如何在这里做到这ArrayList 一点

Map<String, Long> counts =
    list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

但我的情况更复杂,因为它是一个ArrayList的ArrayList秒.

结构如下 String itemId = list.get(i).getProducts().get(j).getItemId();

假设我有一个名为"城市"的集合(城市类),集合中的每个项目都有一个成员"街道"(街道类),我想迭代所有城市并计算集合中街道的总数.

什么是使用Streams同时避免尽可能多的不必要操作(un\boxing,冗余计算等)的最佳方法

目前,要将a转换List<List<Foo>>为a Stream<Foo>,您必须使用以下内容:

Stream<Foo> stream = list.stream().flatMap(fs -> fs.stream());
//or
Stream<Foo> stream = list.stream().flatMap(Collection::stream);

我认为这正是方法引用的设计目标,它确实提高了可读性.现在考虑一下:

Stream<Bar> stream = list.stream().flatMap(fs -> fs.getBarList().stream());

有两个链式方法调用,没有方法参考是可能的,我已经发生了几次这种情况.虽然这不是一个大问题,但它似乎偏离了方法参考简洁性.

在使用JavaFX 8之后,我注意到它们的API常量是方便的方法.Java是一种非常冗长的语言,在我看来,简单的方法重载是JavaFX的一大卖点.

所以我的问题是,我想知道为什么没有Stream.flatMap(Collection)可以被称为的方便方法:

Stream<Bar> stream = list.stream().flatMap(Foo::getBarList);

这是甲骨文人员故意遗漏的吗？或者这会引起任何混淆吗？

注意:我知道"不基于意见的问题政策",我不是在寻找意见,我只是想知道是否有理由不采用这种方法.

我正在使用Java-8 lambda对列表进行排序.

这是列表

[(t1, tester1), (t4, tester4), (t3, tester3), (t2, tester2)]

排序后

[(t2, tester2), (t1, tester1), (t3, tester3), (t4, tester4)]

我想得到如上所述的结果

String specialId = 't2'

List<Test> list = new ArrayList<>();

Test test1 = new Test();
test1.setId = "t1"
test1.setName = "tester1"
list.add(test1)

Test test2 = new Test();
test2.setId = "t4"
test2.setName = "tester4"
list.add(test2)

Test test3 = new Test();
test3.setId = "t3"
test3.setName = "tester3"
list.add(test3)

Test test4 = new Test();
test4.setId = "t2"
test4.setName = "tester2"
list.add(test4)

Stream<Test> s1 …

我正在做一些Java 8流的"代数",也就是说,我正在尝试编写一个简单的操作Op,它将两个流作为输入并产生另一个流.

所以我有这个简单的代码,其目的是在一系列数字中打印secund最高值:

import java.util.Arrays;
import java.util.stream.IntStream;

public class SecundHighestValue {

    public static void main(String[] args) {

        //setting the input parameters
        int [] numbers = {1, 2, 3, 4, 3, 4, 2, 1};

        IntStream S1 = Arrays.stream(numbers);
        IntStream S2 = Arrays.stream(new int[] {Arrays.stream(numbers).max().getAsInt()} );

        // setting the operation
        IntStream S3 = S1.filter(x-> x != S2.toArray()[0]); // doesn't work

        /*** does work  ***
        int  maxNumber = S2.toArray()[0];
        IntStream S3 = S1.filter(x-> x != maxNumber);
        */

        // accessing the operation's result stream …

我有List<Person> persons = new ArrayList<>();,我想列出所有独特的名字.我的意思是如果有"John","Max","John","Greg"那么我只想列出"Max"和"Greg".有没有办法用Java流做到这一点？

我做了一些PoC来比较两种类型的实现交互列表的性能.

第一个是使用纯java,foreach并使用'if'检查每个元素.

第二种方法是这样使用lambda:

int max1 =  lists1.stream()
                  .mapToInt(i -> i)
                  .max()
                  .getAsInt();

long finalCount = lists1.stream()
                        .filter(p -> p.intValue() == max1)
                        .count();

显然使用lambda比使用经典java快5倍foreach.

我非常有信心强制要求lambda在我当前的项目中使用我的团队,就像规则一样,禁止使用经典java foreach.

我的问题是,如果存在一些我无法应用此规则的场景(需要lambda),我的意思是,如果存在异常,我无法使用lambda集合.

我需要通过其中一个参数对Java中的对象列表进行排序.这样可以正常工作,当有平局时,它会维持之前的顺序.

但是,我的目标是移植一些自己排序的丑陋代码,我必须保持相同的行为.在该算法中,它在平局的情况下反转先前的顺序.

例如,如果我想通过int对这些对象进行排序:

{ a, 1}
{ b, 2}
{ c, 1}

我的代码返回:a,c,b

我正在移植的代码返回:c,a,b

我现在的代码是:

final Comparator<MyObj> myComparator =
    Comparator.comparingInt(MyObj::getSortWeight)
return myObjList
    .stream()
    .sorted(myComparator)
    .map(//doing some other transformations here)
    .collect(Collectors.toList());

是否有一种非hacky方式使其工作方式与旧代码相同？我不想重新发明轮子.