小编Tag*_*eev的帖子

我有以下设置:

Map<Instant, String> items;
...
String renderTags(String text) {
    // Renders markup tags in a string to human readable form
}
...
<?> getItems() {
    // Here is where I need help
}

我的问题是,作为items地图值的字符串标有标签.我想getItems()返回所有项目,但使用该renderTags(String)方法解析字符串.就像是:

// Doesn't work
items.entrySet().stream().map(e -> e.setValue(renderTags(e.getValue())));

这样做最有效的方法是什么？

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

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())
                )
        )
);

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

例如,对于此代码:

List<Class> classes = 
        Stream.of("java.lang.Object", "java.lang.Integer", "java.lang.String")
              .map(className -> Class.forName(className))
              .collect(Collectors.toList());

这段代码现在运行正常.但是,假设我们在流中有一个空列表,我们对流有大量操作.它可能会得到NullPointer异常等等.我发现尝试捕获这种语句也很困难.处理异常的正确方法是什么？

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

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

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

所以问题是:

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

我如何得到MethodHandle像数组构造函数int[]::new？

这不起作用:

public static void main(String[] args) throws Throwable {
    MethodHandles.Lookup lookup = MethodHandles.publicLookup();
    MethodHandle mh = lookup.findConstructor(int[].class, MethodType.methodType(void.class, int.class));
    System.out.println(mh);
    System.out.println(mh.invoke());
}

结果如下:

Exception in thread "main" java.lang.NoSuchMethodException: no such constructor: [I.<init>(int)void/newInvokeSpecial
    at java.lang.invoke.MemberName.makeAccessException(MemberName.java:871)
    at java.lang.invoke.MemberName$Factory.resolveOrFail(MemberName.java:990)
    at java.lang.invoke.MethodHandles$Lookup.resolveOrFail(MethodHandles.java:1382)
    at java.lang.invoke.MethodHandles$Lookup.findConstructor(MethodHandles.java:920)
    at xx.main(xx.java:11)
Caused by: java.lang.NoSuchMethodError: java.lang.Object.<init>(I)V
    at java.lang.invoke.MethodHandleNatives.resolve(Native Method)
    at java.lang.invoke.MemberName$Factory.resolve(MemberName.java:962)
    at java.lang.invoke.MemberName$Factory.resolveOrFail(MemberName.java:987)
    ... 3 more

这也不是:

public static void main(String[] args) throws Throwable {
    MethodHandles.Lookup lookup = MethodHandles.publicLookup();
    MethodHandle mh = lookup.findConstructor(int[].class, MethodType.methodType(void.class));
    System.out.println(mh); …

我是Java 8新功能的新手,这可能是一个愚蠢的问题,但我仍然坚持这一点.

我试图在eclipse中运行以下代码,但它给出了编译时错误.

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;
import ch.lambdaj.Lambda;

public class LambdajTest {

    public static void main(String[] args) {

        List list = new ArrayList();
        list.add(1);
        list.add(3);
        list.add(8);
        list.add(10);
        list.add(16);

        int sum = list.stream().filter(p -> p > 10).mapToInt(p -> p).sum();
    }

}

错误是: - p无法解析为变量.我在classpath中添加了lambdaj 2.3.3 jar.

请提供解决方案.提前致谢.

我是scala尝试理解的新手,通过将等效的java更改为scala来让我更好地理解.

如何将java 8 map,filter和streams转换为scala？

我有以下java 8代码,我试图转换为Scala:

 public Set<String> getValidUsages(String itemId, long sNo, Date timeOfAccess) {                                                     
     Set<String> itemSet = Sets.newHashSet();                                                                                                   
     TestWindows testWindows = items.get(itemId).getTestWindows();                                                          

     final boolean isTV = existsEligibleTestWindow(testWindows.getTV(), timeOfAccess);                                       
     if (isTV) {                                                                                                                              
         itemSet.add(TV);                                                                                                              
     } else {                                                                                                                                    
         final boolean isCableUseable = existsEligibleTestWindow(testWindows.getCableUse(), timeOfAccess);                         
         final boolean isWifi = existsEligibleTestWindow(testWindows.getWifi(), timeOfAccess);                               
         if (isCableUseable || isWifi) {                                                                                                     
             itemSet.add(MOVIE);                                                                                                           
         }                                                                                                                                       
     }                                                                                                                                           

     if (testWindows.getUsageIds() != null) {                                                                                           
         itemSet.addAll(testWindows.getUsageIds()                                                                                      
                 .entrySet()                                                                                                                     
                 .stream()                                                                                                                       
                 .filter(entry -> existsEligibleTestWindow(entry.getValue(), timeOfAccess))                                               
                 .map(Map.Entry::getKey)                                                                                                         
                 .collect(Collectors.toSet()));                                                                                                  
     }                                                                                                                                           

     return itemSet;                                                                                                                            
 }                                                                                                                                               

 private boolean existsEligibleTestWindow(List<TestWindow> windows, Date timeOfAccess) …