标签: java-8

我想在我的机器上安装JDK 9,访问JDK官方下载页面,很惊讶地看到,

Java SE 9已经到了支持终点.Java SE 9的用户应切换到Java SE 10.请访问我们的Java SE下载页面以获取当前版本的Java SE.您将在......秒内重定向到Java SE下载页面.请将书签更新到Java SE下载页面.

我做了一些谷歌搜索和Java发布历史等.但找不到任何具体的原因.

我有几个问题 -

1. Oracle仍在支持JDK 1.8,但是停止向JDK 9发布更新,为什么？
2. 我应该继续使用JDK 1.8一段时间,然后直接切换到JDK 10吗？

规范是否保证顺序 Java Streams 上的所有操作都在当前线程中执行？("forEach"和"forEachOrdered"除外)

我明确要求规范,而不是当前的实现.我可以自己查看当前的实现,不需要打扰你.但实现可能会改变,还有其他实现.

我问因为ThreadLocals:我使用的是一个内部使用ThreadLocals的Framework.即使像company.getName()这样的简单调用最终也会使用ThreadLocal.我无法改变该框架的设计方式.至少不在理智的时间内.

这里的规范似乎令人困惑.包"java.util.stream"的文档说明:

如果行为参数确实有副作用,除非明确说明,否则不能保证这些副作用对其他线程的可见性,也不保证同一流管道中"相同"元素的不同操作在同一个线程中执行.

...

即使当管道被约束以产生结果,其与流源的遭遇顺序一致(例如,IntStream.range(0,5).parallel()地图(X - > X*2).toArray( )必须产生[0,2,4,6,8]),不能保证制成,以作为对于所述映射器函数被应用到各个元件,或为了在什么螺纹任何行为参数被执行对于给定的元件.

我将其解释为:流上的每个操作都可以在不同的线程中发生.但是"forEach"和"forEachOrdered"的文档明确指出:

对于任何给定元素,可以在任何时间以及库选择的任何线程中执行该动作.

如果每个流操作都可能发生在未指定的线程中,那么该语句将是多余的.因此恰恰相反:串行流上的所有操作都保证在当前线程中执行,除了"forEach"和"forEachOrdered"？

我搜索了关于"Java","Stream"和"ThreadLocal"组合的权威答案,但没有发现任何内容.该关闭的事情是由一个答案作者Brian Goetz在这里对堆栈溢出一个相关的问题,但它是有关订单,而不是线程,它只是对"的forEach",而不是其他流的方法:是否Stream.forEach尊重遇到顺序流的顺序？

我需要log/sysoutJava Streams中的过滤值.我能够log/sysout使用非过滤值的peek()方法.但是,有人可以让我知道如何记录过滤值？

例如,假设我有一个Person像这样的对象列表:

List<Person> persons = Arrays.asList(new Person("John"), new Person("Paul"));

我想过滤掉那些不是"约翰"的人如下:

persons.stream().filter(p -> !"John".equals(p.getName())).collect(Collectors.toList());

但是,我必须记录被过滤的"约翰"人的详细信息.有人可以帮助我实现这个目标吗？

我替换了以下代码:

if (status.getPlace() == null) {
    row.set("CountryCode", "Unknown");
    row.set("Country", "Unknown");
} else {
    if (status.getPlace().getCountryCode() == null) {
        row.set("CountryCode", "Unknown");
    } else {
        row.set("CountryCode", status.getPlace().getCountryCode());
    }
    if (status.getPlace().getCountry() == null) {
        row.set("Country", "Unknown");
    } else {
        row.set("Country", status.getPlace().getCountry());
    }
}

有了这个:

String countryCode = Optional.ofNullable(status.getPlace())
        .filter(p -> p.getCountryCode() != null)
        .map(Place::getCountryCode)
        .orElse("Unknown");
row.set("CountryCode", countryCode);

String country = Optional.ofNullable(status.getPlace())
        .filter(p -> p.getCountry() != null)
        .map(Place::getCountry)
        .orElse("Unknown");
row.set("Country", country);

它按预期工作,但不知怎的,我认为我可以做得更好.那里我还有一个'空'支票.

.filter(p -> p.getCountryCode() != null)

有没有办法避免上述空检查？

背景

我有一个看起来像这样的地图列表:

[
  {
    "name": "A",
    "old": 0.25,
    "new": 0.3
  },
  {
    "name": "B",
    "old": 0.3,
    "new": 0.35
  },
  {
    "name": "A",
    "old": 0.75,
    "new": 0.7
  },
  {
    "name": "B",
    "old": 0.7,
    "new": 0.60
  }
]

我希望输出看起来像这样:

{
  "A": {
    "old": 1,
    "new": 1
  },
  "B": {
    "old": 1,
    "new": 0.95
  }
}

...其中每个相关条目的值old和new的总和.

映射列表的数据类型是List<Map<String, Object>>,因此输出应该是a Map<String, Map<String, Double>>.

我试过的

通过一些图表绘图,文档阅读和反复试验,我能够想出这个:

data.stream()
    .collect(
        Collectors.groupingBy(entry -> entry.get("name"),
            Collectors.summingDouble(entry ->
                Double.parseDouble(entry.get("old").toString())))
    );

生成类型的对象Map<String, Double> …

我有以下3个文件,

A.java:

class A {

    private float b;    

    public A(float b) {
        this.b = b;
    }

    public float getB() {
        return b;
    }

}

C.java:

import java.util.Arrays;

class C {

    private A[] d;
    private int i = 0;

    public C() {
        d = new A[2];
    }

    public float totalB() {
        return Arrays.stream(d).reduce((e, f) -> e.getB() + f.getB()).get();
    }

    public void addB(A b) {
        d[i++] = b;
    }

}

D.java:

class D {

    public static void main(String[] args) {
        C c …

我有这个代码,但它给了我一个错误:

类型不匹配:无法从int转换为Character

Stream.iterate('a', i -> i + 1).limit(26).forEach(System.out::println);

虽然写得很好 int i = 'a';

我知道我可以像这样写它,但对于一个简单的任务来说,这似乎太多了.

Stream.iterate('a', i -> (char)(i + 1)).limit(26).forEach(System.out::println);

为什么Java类型推断失败？

为什么会出错？我以为map可以回报任何价值.

var s = IntStream.rangeClosed(1, 5).map(String::valueOf).collect(Collectors.toList());

| 错误:| 不兼容的类型:方法引用中的错误返回类型| java.lang.String无法转换为int | var s = IntStream.rangeClosed(1,5).map(String :: valueOf).collect(Collectors.toList()); |
^ ^ -------------

假设我有一组碰碰车,它们两侧有尺寸,颜色和标识符("汽车代码").

class BumperCar {
    int size;
    String color;
    String carCode;
}

现在我需要的碰碰车映射到List的DistGroup对象,每个包含属性size,color以及List汽车代码.

class DistGroup {
    int size;
    Color color;
    List<String> carCodes;

    void addCarCodes(List<String> carCodes) {
        this.carCodes.addAll(carCodes);
    }
}

例如,

[
    BumperCar(size=3, color=yellow, carCode=Q4M),
    BumperCar(size=3, color=yellow, carCode=T5A),
    BumperCar(size=3, color=red, carCode=6NR)
]

应该导致:

[
    DistGroup(size=3, color=yellow, carCodes=[ Q4M, T5A ]),
    DistGroup(size=3, color=red, carCodes=[ 6NR ])
]

我尝试了以下,实际上做了我想要它做的事情.但问题是,它物化的直接结果(成Map),我认为,也可以在做一次(可能使用mapping或collectingAndThen或reducing或东西),导致更优雅的代码.

List<BumperCar> bumperCars = ...
Map<SizeColorCombination, List<BumperCar>> map …

我有一个对象列表，我想按属性的字母顺序对其进行排序。但是，如果此属性匹配特定的字符串，我想添加一个例外规则。例如：

public class Car {
  String name;
}

List<Car> cars = asList(
    new Car("Unassigned"), 
    new Car("Nissan"), 
    new Car("Yamaha"), 
    new Car("Honda"));

List<Car> sortedCars = cars
  .stream
  .sorted(Comparator.comparing(Car::getName))
  .collect(Collectors.toList());

如果那样的cars.name == "Unassigned"话，这辆车应该保持在列表的末端，其结果将是：

[Car<Honda>, Car<Nissan>, Car<Yamaha>, Car<Unassigned>]