小编Tag*_*eev的帖子

我有以下课程(有getter):

public class AlgorithmPrediction {
    private final String algorithmName;
    private final Map<BaseDatabaseProduct, Double> productsToAccuracy;
}

现在我想从一个由AlgorithmPrediction对象填充的集合中创建一个映射,其中algorithmName (唯一)作为键和productsToAccuracy值.我想不出比这更复杂的东西:

algorithmPredictions.stream()
.collect(
        groupingBy(
                AlgorithmPrediction::getAlgorithmName,
                Collectors.collectingAndThen(
                        toSet(),
                        s -> s.stream().map(AlgorithmPrediction::getProductsToAccuracy).collect(toSet())
                )
        )
);

这不可能是对的.我错过了什么？谢谢!

假设我有一个名为 的类Server，我想让其他Plugins人为它编写代码。SayPlugin是一个接口，它扩展Runnable并添加了一个方法：void init(...). 插件的工作是收集数据并将其发送到服务器。然而，当需要向服务器发送数据时，它是如何做到的呢？来自 C 和 C++ 我正在寻找沿着函数指针的思路。尽管我没有在 Java 标准类库之外找到示例，但在 Java 中似乎是可能的。

我如何将方法引用传递给init方法，以便它可以由 存储Plugin，然后我如何在插件想要发送数据时调用该方法？现在说所需的 Server 方法是：void sendData(Integer data)。

例如：

// Inside Server
Plugin p = new PluginImplementation();
p.init(this::sendData);    

// Plugin init
public void init(?? sendMethod) {
    storedSendMethod = sendMethod;
    // ...
}

// Plugin run
public void run() {
    // ...
    storedSendMethod(x) // Sends data to server
    // ...
}

我对Guava API相当新,并试图按MultiMap顺序或降序值对a的键进行排序.我是Map按照以下方式发起的:

ListMultimap<Date, Map<String, String>> listMultimap = MultimapBuilder.treeKeys().arrayListValues().build();

这会按升序对键进行排序.例如:

List multi map iteration: key -->Fri Jan 01 00:00:00 PST 2016   values -->[{test2=testval2}, {test3=testval3}]
List multi map iteration: key -->Sun Jan 01 00:00:00 PST 2017   values -->[{test1=testval1}]
List multi map iteration: key -->Mon Jan 01 00:00:00 PST 2018   values -->[{test0=testval0}]
List multi map iteration: key -->Tue Jan 01 00:00:00 PST 2019   values -->[{test4=testval4}]

我试图创建一个自定义日期Comparator有TreeMultiMap,但还没有一个数字的方式来做到这一点.这在语法上并不正确,只是试图证明这个想法.

static final Comparator<Date> DESC_ORDER = new Comparator<Date>() {
    public …

我刚开始使用Java 8和流,并且无法找到如何在Java 8中编写此代码:

Map<Integer, CarShop> result = new HashMap<>();     
for (Car car : someListOfCars) {
    List<CarProduct> listOfCarProducts = car.getCarProducts();
    for (CarProduct product : listOfCarProducts) {
        result.put(product.getId(), car.getCarShop());
    }
}

有帮助吗？

我正在尝试生成整数对-我有一个Pair类，其构造函数采用2个整数。以下代码有效，但看起来很笨拙-特别是使用mapToObj（Integer :: new）从intStream到对象流的转换。

private static List<Pair> success() {
    return IntStream.range(0, 10).
            mapToObj(Integer::new).flatMap(i -> IntStream.range(12, 15).
                mapToObj(j -> new Pair(i, j))).
            collect(Collectors.toList());
}

首先，有人能做到这一点吗？

其次，当我重构为将某些流提取为变量时，出现错误：IllegalStateException：流已被操作或关闭。这是重构的方法-有人知道这是否是代码问题吗？

static List<Pair> fail() {
    Stream<Integer> outer = IntStream.range(0, 10).mapToObj(Integer::new);
    IntStream inner = IntStream.range(12, 15);
    Stream<Pair> pairStream = outer.flatMap(i -> 
            inner.mapToObj(j -> new Pair(i, j)));
    return pairStream.collect(Collectors.toList());
}

我有我想要的问题,需要摆脱一些if else案例.我在我的项目中得到以下代码:

if (ar[4].equals("week")) {

    WeekThreshold wt = new WeekThreshold();
    firstTime = unparsedDate.format(wt.getStartDate().getTime());
    secondTime = unparsedDate.format(wt.getEndDate().getTime());

} else if (ar[4].equals("month")) {

    MonthThreshold mt = new MonthThreshold();
    firstTime = unparsedDate.format(mt.getStartDate().getTime());
    secondTime = unparsedDate.format(mt.getEndDate().getTime());

} else if (ar[4].equals("quarter")) {

    quarterThreshold();

} else if (ar[4].equals("year")) {

    YearThreshold yt = new YearThreshold();
    firstTime = unparsedDate.format(yt.getStartDate().getTime());
    secondTime = unparsedDate.format(yt.getEndDate().getTime());
}

这三个类WeekThreshold,MonthThreshold并YearThreshold从AbstractThreshold他们从日历中获取日期的类延伸,但这并不重要.方法quarterThreshold()很特别,可以留在那里.但是,我怎样才能摆脱那个if else块并有一个语句来调用不同的类？

编辑:忘记提及,需要调用的类来自各种数组ar[].如果数组ar[4]是月份,则MonthThreshold必须调用等.

在包的javaodoc 中stream，在本节的末尾Parallelism，我读到：

大多数流操作接受描述用户指定行为的参数，这些参数通常是 lambda 表达式。为了保持正确的行为，这些行为参数必须是无干扰的，并且在大多数情况下必须是无状态的。

我很难理解这个“在大多数情况下”。在哪些情况下可以接受/需要有状态的流操作？

我的意思是，我知道这是可能的，特别是在使用顺序流时，但同一个 javadoc 明确指出：

除了明确标识findAny()为非确定性的操作，例如，流是顺序执行还是并行执行不应改变计算结果。

并且：

另请注意，尝试从行为参数访问可变状态会给您带来安全和性能方面的错误选择；[...] 最好的方法是避免有状态的行为参数完全流式传输操作；通常有一种方法可以重构流管道以避免有状态。

所以，我的问题是：在哪种情况下使用有状态的流操作是一个好习惯（而不是用于副作用工作的方法，例如forEach）？

一个相关的问题可能是：为什么有副作用的操作，例如forEach？我总是最终做一个很好的旧for循环，以避免在我的 lambda 表达式中产生副作用。

我正在尝试编写一个方法来获取Collection使用a 的模式Comparator.

有人可以告诉我为了编译这个我需要做些什么改变吗？我不想改变签名.

static <T> T mode(Collection<? extends T> collection, Comparator<? super T> comparator) {
    return collection.stream()
                     .collect(Collectors.groupingBy(t -> t, () -> new TreeMap<>(comparator), Collectors.counting()))
                     .entrySet()
                     .stream()
                     .reduce(BinaryOperator.maxBy(Comparator.comparingLong(Map.Entry::getValue)))
                     .map(Map.Entry::getKey)
                     .orElseThrow(IllegalArgumentException::new);
}

编辑

事实证明我只是使用了错误的版本.这不能使用编译javac 1.8.0_25.确切的三条错误消息是:

Error:(40, 47) java: incompatible types: inferred type does not conform to upper bound(s)
inferred: java.lang.Object
upper bound(s): T,java.lang.Object

Error:(43, 45) java: incompatible types: cannot infer type-variable(s) T
(argument mismatch; invalid method reference
  method getValue in interface java.util.Map.Entry<K,V> cannot be applied …

我有以下代码尝试通过Java Stream API以并行方式从List填充Map:

class NameId {...}

public class TestStream
{
    static public void main(String[] args)
    {
        List<NameId > niList = new ArrayList<>();
        niList.add(new NameId ("Alice", "123456"));
        niList.add(new NameId ("Bob", "223456"));
        niList.add(new NameId ("Carl", "323456"));

        Stream<NameId> niStream = niList.parallelStream();
        Map<String, String> niMap = niStream.collect(Collectors.toMap(NameId::getName, NameId::getId));
    }
}

我如何知道是否使用多个线程填充地图,即并行？我是否需要调用Collectors.toConcurrentMap而不是Collectors.toMap？这是一种合理的方式来并行化地图的人口吗？我怎么知道具体的地图支持新的niMap(例如它是HashMap)？

我有一个 Java 包，其中包含外部客户端使用的注释。该包出现在 Java 8 之前，所以历史上这些注解都有目标ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE。现在该包至少需要 Java 8 版本。从语义上讲，包中的注释适用于类型，例如，当方法被注释时，注释有效地适用于方法返回类型。现在客户也想注释泛型类型参数（例如List<@MyAnnotation String>）。由于我们放弃了对 Java 7 及以下版本的支持，因此将注释目标设置为ElementType.TYPE_USE并删除现有目标似乎很自然，以减少歧义。

问题是：将ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE目标替换为TYPE_USE?时，现有客户端是否存在兼容性风险？现有代码是否有可能停止编译？二进制兼容性怎么样？如果在更改之前编译的类文件在运行时与较新的注释包一起使用，是否会导致任何运行时问题？

注释的保留政策是CLASS这是否重要。