小编Hol*_*ger的帖子

如果我执行以下代码"连接"两个流

• 首先通过flatMapping a Stream<Stream<Integer>>
• 然后通过减少Stream<Stream<Integer>>使用Stream.concat()

在两种情况下我都获得了相同的正确结果,但过滤操作的数量是不同的.

public class FlatMapVsReduce {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        Predicate<Integer> predicate1 = i -> {
            System.out.println("testing first condition with " + i);
            return i == 3;
        };

        Predicate<Integer> predicate2 = i -> {
            System.out.println("testing second condition with " + i);
            return i == 7;
        };

        System.out.println("Testing with flatMap");
        Integer result1 =
            Stream.of(list.stream().filter(predicate1),
                      list.stream().filter(predicate2))
                  .flatMap(Function.identity())
                  .peek(i -> System.out.println("peeking " …

class Person {
    public String name;
    public String getName() { return name; }
}

是否有通过lambda访问流API中的字段的特殊语法糖？我知道了:

List<Person> persons;
persons.stream().map(Person::getName).collect(Collectors.toList());
persons.stream().map(p -> p.name).collect(Collectors.toList());

怎么样的东西(哪些不起作用,我知道):

persons.stream().map(Person::name).collect(Collectors.toList());

我正在尝试迁移到java 8并在我的dao类中有许多方法,它们执行以下操作

@Override
@SuppressWarnings("unchecked")
public List<Group> getGroups()
{
    Session session = sessionFactory.openSession();
    List<Group> allGroups = (List<Group>)session.createQuery("from Group").list();
    session.close();
    return allGroups;
}

这里使用相同的锅炉板sessionFactory.open并对session.close所有方法重复.

在Java 8中是否有可能有一个方法来执行打开和关闭并获取一个函数,这是我的代码的其余部分并在中间执行它？

如果是这样 - 这个过程的名称是什么,或者任何人都可以提供一些如何实现这一目标的帮助

我有以下无法编译的程序:

只是块1编译正常并按预期工作 - 我可以有条件地选择一个对象并在其上内联调用一个方法.

只是块2也编译好并按预期工作 - 我可以有条件地为Supplier<String>变量分配方法引用并调用.get()该变量.

但是块3无法编译:

Lambda.java:31: error: method reference not expected here
    String res = ((Supplier<String>) (args.length > 0 ? Lambda::foo : Lambda::bar)).get();
                                                        ^
Lambda.java:31: error: method reference not expected here
    String res = ((Supplier<String>) (args.length > 0 ? Lambda::foo : Lambda::bar)).get();

我认为该想法在块1组合和2 I将能够为一体的类型执行块3 ((Supplier<String>) (args.length > 0 ? Lambda::foo : Lambda::bar))是Supplier<String>.

import java.util.function.Supplier;

class Lambda {

  private final String s;

  private Lambda(String s) {
    this.s = s;
  }

  private …

我有一个父抽象类和采用泛型的子类。

public abstract sealed class Parent<T> permits ChildA, ChildB {}

public non-sealed class ChildA<T extends FileTypeA> extends Parent{}

public non-sealed class ChildB<T extends FileTypeB> extends Parent{}

在父类中，我收到警告：

ChildA is a raw type. References to generic type ChildA<T> 
       should be parameterized

ChildB is a raw type. References to generic type ChildB<T> 
       should be parameterized

在儿童课程中，我收到警告：

Parent is a raw type. References to generic type Parent<T> 
       should be parameterized

让它们像这样参数化：

public abstract sealed class Parent<T> 
    permits ChildA<T extends FileTypeA>, ChildB<T extends FileTypeB> …

我已经定义了一个静态assertThat方法来扩展AssertJ.此方法接受类型的lambda表达式:

@FunctionalInterface
public interface Action {
  void execute() throws Exception;
}

签名如下所示:

public static ExceptionAssert assertThat(Action action)

我想将此方法与静态导入一起使用.但它含糊不清.编译器不知道是否应该使用assertThat(Iterable)或我的方法.我不明白void方法如何与返回的方法冲突Iterator<T>.

知道如何解决这个冲突(没有在前面写过类名assertThat)？

我在Windows中的Eclipse Luna中开发了一个Java应用程序,它在Amazon EC2(c3.large,Amazon Linux)中运行.此应用程序处理以非常一致的传入速率工作.当我针对JDK 8u31构建应用程序时,EC2 CPU负载远高于针对JDK 7u75构建的相同应用程序.

该应用程序最初使用EC2上的默认JRE运行,我添加了OpenJDK 1.8.0.31以利用Java 8 Process waitFor(长超时,TimeUnit单元).此应用程序的主要工作涉及使用Runtime.exec调用应用程序.

$ sudo alternatives --config java

There are 2 programs which provide 'java'.

  Selection    Command
-----------------------------------------------
*  1           /usr/lib/jvm/jre-1.7.0-openjdk.x86_64/bin/java
 + 2           /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.31-2.b13.5.amzn1.x86_64/jre/bin/java

应用程序针对1.7构建时的示例负载平均值:

top - 00:20:28 up 4 days, 10:41,  4 users,  load average: 0.37, 0.26, 0.52

应用程序构建为1.8时的平均负载示例:

top - 23:45:52 up 4 days, 10:06,  4 users,  load average: 2.28, 2.60, 2.01

看起来它可能与Open JDK 1.8.0.31有关,但我不知道如何调试它.没有代码更改,我只是在Eclipse Luna中更改合规性级别并在1.7和1.8之间构建.知道为什么负载会如此不同？

更新:

当我在EC2上使用Oracle JDK时,我看到类似的高CPU负载.

$ sudo alternatives --config java

There are 3 programs which …

我在循环语句中有以下代码.
在循环中,字符串被附加到sb(StringBuilder)并检查sb的大小是否已达到5MB.

if (sb.toString().getBytes("UTF-8").length >= 5242880) {
    // Do something
}

这工作正常,但它很慢(在检查大小方面)
最快的方法是什么？

最近我在使用嵌套集合(List中的Maps值)时遇到了一个问题:

List<Map<String, Object>> items

在我的案例中,此列表包含10-20个地图.在某些时候我不得不将Calculationkey的值替换description为Rating.所以我想出了这个解决方案:

items.forEach(e -> e.replace("description","Calculation","Rating"));

如果此列表中的所有映射都包含键值对,那将是非常精细和有效的解决方案["description", "Calculation"].不幸的是,我知道整体上只有一对List<Map<String, Object>>.

问题是:

是否有更好(更有效)的解决方案来查找和替换这一个值,而不是使用Java-8流迭代所有List元素？

完美将是在一个流中完成它而不对其进行任何复杂/混淆操作.

假设我有不同类型的吸气剂和固定剂POJO.我想写一些通用算法,只需通过lambdas定义getter和setter,就可以将数据从一个更新到另一个.我试图以这种方式创建它

private static final Map<Function<Entity, Object>, BiConsumer<Entity, Object>> ACCESSORS = new HashMap
        <Function<Entity, Object>, BiConsumer<Entity, Object>>() {{
    put(Entity::getAreaCode, Entity::setAreaCode);
}});

然后我遍历所有应用目标实体的条目,如果getter的结果不为null,那么我想为其他实体应用相应的setter.

但它不起作用,因为Object不能转换为String.而且我想将它用于不同的类型,不仅是字符串,还有整数等...

是否可以通过一些简单的方法解决而无需创建特殊转换器并将其与每个条目相关联？