小编Tag*_*eev的帖子

有没有办法连接两个字符串(不是最终)而不分配内存？

例如,我有这两个字符串:

final String SCORE_TEXT = "SCORE: ";
String score = "1000"; //or int score = 1000;

当我连接这两个字符串时,String会创建一个新对象.

font.drawMultiLine(batch, SCORE_TEXT + score, 50f, 670f);//this creates new string each time

由于这是在主游戏循环中完成的(在一秒钟内执行约60次),因此有很多分配.

我可以不分配地以某种方式做到这一点吗

这是不可变链表的经典实现:

public abstract class List<A> implements Iterable<A> {
    private static final List NIL = new Nil();

    public abstract A head();
    public abstract List<A> tail();
    public List<A> cons(A a) { return new Cons<>(a, this); }

    public static <A> List<A> nil() { return NIL; }

    @Override
    public Iterator<A> iterator() {
        return new Iterator<A>() {
            private List<A> list = List.this;

            @Override
            public boolean hasNext() {
                return list != NIL;
            }

            @Override
            public A next() {
                A n = list.head();
                list = list.tail();
                return …

简而言之，我的问题是：为什么 JMH 基准测试结果在分叉内可以稳定，但分叉之间差异很大。

我在许多基准测试中观察到了这一点（通常涉及数据集的处理）。这是一个简单的例子：

import static java.util.concurrent.TimeUnit.*;
import static java.util.stream.Collectors.*;
import java.util.*;

import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.annotations.*;

@Warmup(iterations = 5, time = 1, timeUnit = SECONDS)
@Measurement(iterations = 15, time = 1, timeUnit = SECONDS)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(MICROSECONDS)
@Fork(50)
@State(Scope.Benchmark)
public class AvgTest {
    private long[] longs = new Random(1).longs(1000).toArray();

    @Benchmark
    public void test(Blackhole bh) {
        bh.consume(Arrays.stream(longs).boxed().collect(averagingLong(x->x)));
    }
}

我使用 5 次一秒预热迭代和 15 次一秒测量迭代。按照指定，整个过程重复 50 次（同时 JVM 重新启动）@Fork(50)。常见的叉子看起来像这样：

# Run progress: 8,00% complete, ETA 00:15:34
# Fork: 5 of 50 …

在java中,您可以将Type参数添加到静态方法,以创建处理泛型的方法.你能用lambdas做同样的事吗？

在我的代码中我有

final private static <K,V> Supplier<Map<K, List<V>> supplier=HashMap::new;

我正在尝试做类型参数,比如它是一个函数,但它不会让我.

如果我这样做:

    final private static Supplier<Map<?, List<?>>> supplier=HashMap::new;

它不接受我尝试使用它的论点.我能做什么？

我有以下课程(有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
    // ...
}

有没有办法将元素T插入Stream<T>？

    ArrayList<Foo> foos = new ArrayList<>();
    Foo foo = new Foo();

    Stream<Foo> stream = Stream.concat(foos.stream(), Stream.of(foo));

还有另外一种方法吗？基本上是一种foo.stream().add(foo)...... - 当然add()不存在.-

我一直在练习java 8流和功能风格.有时我尝试使用流来解决一些编程难题.在这段时间里,我发现了一类我不知道如何用流来解决的任务,只有经典的方法.

这种任务的一个例子是:给定一个数字数组,找到元素的索引,它将使数组左边部分的总和低于零.例如,对于数组[1, 2, 3, -1, 3, -10, 9]答案将是5

我的第一个想法是使用,IntStream.generate(0, arr.length)...但后来我不知道如何累积值并同时意识到索引.

所以问题是:

• 有可能以某种方式在流上累积值然后进行有条件退出吗？
• 什么是并行执行？它不适合寻找我们需要了解元素顺序的索引的问题.

我想知道如何强制立即评估Java8中的每个map函数？我现在的情况是我需要进行多个级别的转换(来自ObjectA - > ObjectB - > ObjectC - > ObjectD),并且在某个对象的转换的每个级别上都可能存在失败(抛出异常).例如

 // stream -> map -> collect sequence
 lists.stream()
      .map(aToB)
      .collect(Collectors.toList())
      .stream()
      .map(bToC)
      .collect(Collectors.toList())
      .stream()
      .map(cToD)
      .collect(Collectors.toList())

 // Try api is from javaslangs
 Function<ObjectA, ObjectB> aToB = a -> Try.of(() -> .....)
                                           .onFailure(....)
                                           .get();

 Function<ObjectB, ObjectC> bToC = b -> Try.of(() -> .....)
                                           .onFailure(....)
                                           .get();

 Function<ObjectC, ObjectD> cToD = c -> Try.of(() -> .....)
                                           .onFailure(....)
                                           .get();

我想测试我的单元测试中的每个转换,例如测试是否测试抛出异常,以及如果A在将A转换为B之类的异常时未成功转换为C,但是使用惰性求值,则无法测试,我能想到的唯一方法是做这一系列的steam() -> map(...) -> collect(...)调用,迫使立即进行评估.我想知道是否有更好的方式来写这个.

我对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 …