小编Tag*_*eev的帖子

如果我有一个带整数的列表,有没有办法构建另一个列表,如果新列表的头部差异低于threashold,则整数总和？我想用Java 8流来解决这个问题.它应该类似于RxJava 的Scan运算符.

Example: 5, 2, 2, 5, 13    
Threashold: 2    
Result: 5, 9, 13

Intermediate results:    
5
5, 2
5, 4 (2 and 2 summed)
5, 9 (4 and 5 summed)
5, 9, 13

这是我在Java 7中所做的:

public class Sample {

    private List<String> list = Lists.newArrayList("helloworld", "foobar", "newyork");

    public void performOperation(String input) {

        boolean found = false;

        for (String each : list) {
            if (input.contains(each)) {
                found = true;
            }
        }

        if (!found) {
            magicMethod(input);
        }
    }

    public void magicMethod(String input) {
        // do the real magic here
    }
}

我希望沿着这条线走路(这显然是错误的)

list.forEach(each -> input.contains(each) ? magicMethod(input) : return );

给定int [] A.尝试使用数组中的所有元素大于或等于-1000且不大于1000(包括).怎么做得好？

我的尝试:

boolean validIntegers = (Arrays.asList(A)).stream().allMatch(i -> (i >= -1000 && i <= 1000) );

错误:

我有一个Stream字符串,并将每个字符串映射到Optional<String>.由于我Optionals之后过滤了空,因此返回的流应该只包含非空的Optionals非空字符串.

为什么findFirst()扔一个NullPointerException呢？

Optional<String> cookie = 
  Stream.of(headers.get(HttpHeaders.SET_COOKIE), headers.get(HttpHeaders.COOKIE))
                        .flatMap(Collection::stream)
                        .filter(s -> s.contains("identifier"))
                        .map(this::parseCookieValue) //returns an Optional<String> from Optional.ofNullable(), null-values should result in empty Optionals
                        .filter(Optional::isPresent) // filters out non-present values
                        .map(Optional::get) // all Optionals here should have values
                        .findFirst(); // so why is this still throwing a NullPointerException?

堆栈跟踪:

Caused by: java.lang.NullPointerException
    at com.example.services.impl.RestServiceImpl$$Lambda$11/873175411.apply(Unknown Source)
    at java.util.stream.ReferencePipeline$7$1.accept(ReferencePipeline.java:267)
    at java.util.Spliterators$ArraySpliterator.tryAdvance(Spliterators.java:958)
    at java.util.stream.ReferencePipeline.forEachWithCancel(ReferencePipeline.java:126)
    at java.util.stream.AbstractPipeline.copyIntoWithCancel(AbstractPipeline.java:529)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:516)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:502)
    at java.util.stream.FindOps$FindOp.evaluateSequential(FindOps.java:152) …

我想使用Java 8流过滤器集合,但我发现所有示例都是一个集合,Java 6是:

public class User {
public Long id;
public String name;

public User(Long id, String name) {
    this.id = id;
    this.name = name;
}

   List<User> usersA = new ArrayList<>();

    usersA.add(new User(1l,"A"));
    usersA.add(new User(2l,"B"));
    usersA.add(new User(3l,"C"));

    List<User> usersB = new ArrayList<>();
    usersB.add(new User(33l,"A"));
    usersB.add(new User(34l,"B"));
    usersB.add(new User(35l,"D"));
    usersB.add(new User(36l,"C"));

    List<User> tempUser = new ArrayList<>();
    tempUser.addAll(usersB);

    for (User user : usersA) {
        for (User user1 : tempUser) {
            System.out.println(user1.getName().equalsIgnoreCase(user.getName()));
            if (user1.getName().equalsIgnoreCase(user.getName())){
                System.out.println("remove:"+user1.getName());
                tempUser.remove(user1);
                break;
            }
        }

    }

    System.out.println("last:"+tempUser);

而Java 8我想使用stream …

我需要更多关于lambda表达式的说明.怎么'p'代表List<Person> people？你能解释清楚吗？

List<Person> people = new ArrayList<>();
people.add(new Person("Mohamed", 69));
people.add(new Person("Doaa", 25));
people.add(new Person("Malik", 6));
Predicate<Person> pred = (p) -> p.getAge() > 65;

我在另一篇文章中读到,调查后发现anyMatch终端操作的工作方式是每个线程(在子流上操作)定期检查其他线程是否找到了结果,如果是,则所有其他线程都停止.

我想,但不知道是否有人能验证是否noneMatch和allMatch也以这种方式操作的,因此运行时noneMatch,一个线程发现一个实际的匹配,则操作可以返回false.那么所有其他线程是否会按照描述的相同方式定期检查anyMatch？相似,反向适用allMatch吗？

此外,我想知道是否有在运行时为任何区别filter,并map为它们是否在有序或无序的数据流并行运行操作.在有序流上,我假设最合乎逻辑的好处是,不同的线程可以处理创建的每个子流,然后以相同的顺序将它们全部合并在一起.对于无序流,这对于我正在努力想到的操作有什么好处吗？

所以我花了 2 个小时试图找到一个对我来说真正有意义的 Java 8 构造函数引用的实际示例。并不是我不理解构造函数引用的语法或语义。但我无法想出一个可以/将使用它们的用例。我发现的示例基本上只是引入了一个相当无意义的函数接口和一个匹配的类/构造函数，只是为了能够使用构造函数引用。但归根结底只是以一种new...()非常复杂的方式做简单的事情。除了通过构造函数引用之外，函数式接口从未以任何其他方式使用过，那么有什么意义呢？

有人可以给我一个实际的例子，您可以使用构造函数引用来实现函数式接口，但是函数式接口不仅仅用于传递此构造函数引用，而且实际上有一个存在的理由，因为它与其他实现一起使用还有？

java.util.function.Predicate有一些有用的方法等and,or等,其比创建具有多个逻辑运算符的托架狂欢更简洁.不幸的是,似乎没有办法使用这些函数而没有实际上首先明确地使用谓词...

Predicate<String> predicate = String::isEmpty;
Predicate<String> predicateWithAnd = predicate.and( MyClass::testSomething ); 

有没有办法只在一个语句中创建第二谓词(因此"保存"变量),如...

Predicate<String> predicateWithAnd = (String::isEmpty).and( MyClass::testSomething );  // That doesn't seem to work ;-)

只是好奇...

根据我在互联网上阅读的一些文档，Atomic 类的变量如AtomicInteger, AtomicLong,... 只允许 1 个线程同时访问它们。但是当我尝试使用 进行测试时AtomicBoolean，出了点问题。例如

public class TestAtomicBoolean {
    public static void main(String[] args) {
        final AtomicBoolean atomicBoolean = new AtomicBoolean(false);

        new Thread("T1") {
            @Override
            public void run() {
                while (true) {
                    System.out.println(Thread.currentThread().getName() + " is waiting for T3 set Atomic to true. Current is " + atomicBoolean.get());
                    if (atomicBoolean.compareAndSet(true, false)) {                        
                        System.out.println("Done. Atomic now is " + atomicBoolean.get());
                        break;
                    }                    
                }
            }
        }.start();

        new Thread("T2") {
            @Override
            public void run() {
                while(true) …