标签: java-8

我有以下表达式:

scheduleIntervalContainers.stream()
        .filter(sic -> ((ScheduleIntervalContainer) sic).getStartTime() != ((ScheduleIntervalContainer)sic).getEndTime())
        .collect(Collectors.toList());

... scheduleIntervalContainers元素类型在哪里ScheduleContainer:

final List<ScheduleContainer> scheduleIntervalContainers

是否可以在过滤器之前检查类型？

在Android Studio 3.1.2中,我突然在编辑器顶部的黄色磁带框中收到以下消息:

没有IDEA注释附加到JDK 1.8(C:\ Program Files\Android\Android Studio\jre),将找不到一些问题

我在编辑配置中也有一个警告:

找不到默认活动

我该如何解决这些问题？

我正在阅读Lambda:Libraries Edition的状态,我对一个声明感到惊讶:

在Streams部分下,有以下内容:

List<Shape> blue = shapes.stream()
                         .filter(s -> s.getColor() == BLUE)
                         .collect(Collectors.toList());

该文件没有说明shapes实际是什么,我不知道它是否重要.

令我困惑的是:List这段代码返回了什么样的具体内容？

• 它将变量赋值给a List<Shape>,这是完全正常的.
• stream()也filter()决定使用哪种列表.
• Collectors.toList()既没有指定具体的类型List.

那么,这里使用的具体类型(子类)List是什么？有保证吗？

假设有一个Obj类

class Obj{

  int field;
}

并且你有一个Obj实例列表,即List<Obj> lst.

现在,我如何在Java8中找到流中过滤标准下field列表中对象的int字段值的总和lst(例如,对象o,标准是o.field > 10)？

谈论Streams,当我执行这段代码时

public class Main {
    public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6,7,8,9)
        .peek(x->System.out.print("\nA"+x))
        .limit(3)
        .peek(x->System.out.print("B"+x))
        .forEach(x->System.out.print("C"+x));
    }
}

我得到了这个输出

A1B1C1
A2B2C2
A3B3C3

因为将我的流限制为前三个组件会强制执行动作A,B和C三次.

尝试使用skip()方法对最后三个元素执行类似的计算,显示了不同的行为:这

public class Main {
    public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6,7,8,9)
        .peek(x->System.out.print("\nA"+x))
        .skip(6)
        .peek(x->System.out.print("B"+x))
        .forEach(x->System.out.print("C"+x));
    }
}

输出这个

A1
A2
A3
A4
A5
A6
A7B7C7
A8B8C8
A9B9C9

在这种情况下,为什么执行A1到A6的操作？它必须与limit是一个短路状态中间操作这一事实有关,而skip不是,但我不明白这个属性的实际含义.是不是"在跳过之前的所有动作都被执行而不是每个人都在限制之前"？

以下代码令人惊讶地成功编译:

Consumer<String> p = ""::equals;

这个也是:

p = s -> "".equals(s);

但是这会因boolean cannot be converted to void预期错误而失败:

p = s -> true;

使用括号修改第二个示例也会失败:

p = s -> ("".equals(s));

它是Java编译器中的错误还是我不知道的类型推断规则？

为什么以下第一个示例不起作用？

• run(R::new);方法R.run未被调用.
• run(new R());方法R.run 被调用.

这两个例子都是可编译的.

public class ConstructorRefVsNew {

  public static void main(String[] args) {
      new ConstructorRefVsNew().run(R::new);
      System.out.println("-----------------------");
      new ConstructorRefVsNew().run(new R());
  }

  void run(Runnable r) {
      r.run();
  }

  static class R implements Runnable {

      R() {
          System.out.println("R constructor runs");
      }

      @Override
      public void run() {
          System.out.println("R.run runs");
      }
  }
}

输出是:

  R constructor runs
  -----------------------
  R constructor runs
  R.run runs

在第一个示例中,R调用构造函数,它返回lambda(不是对象):

但是,如何成功编译示例怎么可能呢？

可选用于表示可为空的对象,此类的一些用途包括

1. 作为方法返回类型,作为返回null的替代方法,
   表示没有可用的值
2. 区分"未知"(例如,不存在于地图中)和"已知没有值"(存在于地图中,值为
   Optional.absent())
3. 在不支持null的集合中包装可存储的引用以进行存储(尽管还有其他几种方法应该首先考虑)

对于第一种情况,我是否需要在所有可空的返回方法中返回Optional？

引入了Java 8 java.time.Clock,它可以用作许多其他java.time对象的参数,允许您向它们注入真实或假的时钟.例如,我知道您可以创建一个Clock.fixed()然后调用Instant.now(clock)它将返回Instant您提供的固定.这听起来非常适合单元测试!

但是,我无法弄清楚如何最好地使用它.我有一个类,类似于以下内容:

public class MyClass {
    private Clock clock = Clock.systemUTC();

    public void method1() {
        Instant now = Instant.now(clock);
        // Do something with 'now'
    }
}

现在,我想对这段代码进行单元测试.我需要能够设置clock生成固定时间,以便我可以method()在不同时间进行测试.显然,我可以使用反射将clock成员设置为特定值,但如果我不必诉诸于反射,那将会很好.我可以创建一个公共setClock()方法,但这感觉不对.我不想Clock在方法中添加一个参数,因为真正的代码不应该关注传入时钟.

处理此问题的最佳方法是什么？这是新代码,所以我可以重新组织这个类.

编辑:为了澄清,我需要能够构造一个MyClass对象,但能够让一个对象看到两个不同的时钟值(就好像它是一个常规的系统时钟一样).因此,我无法将固定时钟传递给构造函数.

我想在一个带有Optional的前缀中添加一个流.既然Stream.concat只能连接Streams我有这个问题:

如何将Optional <T>转换为Stream <T>？

例:

Optional<String> optional = Optional.of("Hello");
Stream<String> texts = optional.stream(); // not working