标签: java-8

鉴于s,一Stream<Map.Entry<K,V>>受s.map(Map.Entry::getKey).distinct().count() == s.count(),我应该怎么产生m,一个Map<K,V>受m.entrySet().equals(s.collect(Collectors::toSet()))？

换句话说,我应该如何根据我想要的条目流生成地图？

我有一个嵌套的地图 Map<String, Map<String, Map<String, ...>

我如何使用Java 8 lambdas在地图上导航.这里可能的必要解决方案:

Object getObjectWithKey(String key) { // key = "parent.parent1.parent1.1"
    Map head = mainMap;

    for (String k in key.split(".")){
      head = head.get(k);
    }

    return (Object) head;
}

长话短说,我在Java中搞乱了一些基本的遗传算法.我用a long来存储我的基因,但我在调试时使用二进制字符串来提高可读性.我遇到了一个奇怪的情况,我无法解析一些以a开头的二进制字符串1(我不知道是否总是这样,但它似乎与长度为64个字符的字符串一致).

我能够通过以下示例复制此内容:

String binaryString = Long.toBinaryString(Long.MIN_VALUE);
long smallestLongPossibleInJava = Long.parseLong(binaryString, 2);

将抛出并生成以下堆栈跟踪:

Exception in thread "main" java.lang.NumberFormatException: For input string: "1000000000000000000000000000000000000000000000000000000000000000"
    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    at java.lang.Long.parseLong(Long.java:592)
    at com.company.Main.main(Main.java:25)

鉴于我有一个正确格式化的六十四个字符的二进制字符串,为什么我不能解析一些字符串？大多数情况下,我的字符串是随机生成的,但在上面的实例中,这应该可以工作(Long.MIN_VALUE在Java中看来肯定是有效的长).

这是一个Java 8中低级问题:

我在Java 6中有以下代码:

    List <ViewWrapperContentElementTypeProperty> vwPropertyList = getFromDao();


    TreeMap <Long, ArrayList<ViewWrapperContentElementTypeProperty>> mappedProperties = new TreeMap<Long, ArrayList<ViewWrapperContentElementTypeProperty>> ();
    for (ViewWrapperContentElementTypeProperty vwCetP:vwPropertyList)
    {
        if(null==mappedProperties.get(vwCetP.getContentElementTypeId()))
        {

            ArrayList<ViewWrapperContentElementTypeProperty> list = new ArrayList<ViewWrapperContentElementTypeProperty>());
            list.add(vwCetP);
            mappedProperties.put(vwCetP.getContentElementTypeId(), list);
        }
        else
        {
            mappedProperties.get(vwCetP.getContentElementTypeId()).add(vwCetP);
        }

    }

我可以使用vwPropertyList.stream().map()来更有效地实现它吗？

我有以下代码,它使用好旧的java:

List<Bar> repo = ArrayList<>();
public Bar foo(int id) {
    for(Bar c: repo){
        if(c.getId() == id)
            return c;
    }
    Bar target = new Bar();
    target.setFooo("");
    target.setId(0);
    return target;
}

但是,我试图让它变得更好一些(即只是想学习lambdas)

public Bar foo(int id) {
    Bar target = repo.stream().filter(c -> c.getId() == id)
               .findFirst().orElse(null);
    if(target == null){  
        target = new Bar();
        target.setFooo("");
        target.setId(0);
    }
    return target;
}

但上面的代码返回一个ArrayOutOfBounds异常,我不确定如何(因为它是一个列表)或为什么.

在下面的代码中Intellij说"循环推理"

List<String> rows = new ArrayList<>();
rows.add("12345");
rows.add("123");
rows.add("123456");
rows = rows.stream().filter(e -> e.length() > 4).collect(Collectors::toList);
rows.stream().forEach(System.out::println);

必须有一些Collectors::toList我无法理解的问题.

我观看了JoséPaumard在InfoQ上的演讲:http: //www.infoq.com/fr/presentations/jdk8-lambdas-streams-collectors(法语)

问题是我被困在这一点上.要使用流和多线程收集1M Long ,我们可以这样做:

Stream<Long> stream = 
  Stream.generate(() -> ThreadLocalRandom.current().nextLong()) ;

List<Long> list1 = 
  stream.parallel().limit(10_000_000).collect(Collectors.toList()) ;

但考虑到线程总是在检查上述限制以阻碍性能.

在那次演讲中我们也看到了第二个解决方案:

Stream<Long> stream = 
  ThreadLocalRandom.current().longs(10_000_000).mapToObj(Long::new) ;

List<Long> list = 
  stream.parallel().collect(Collectors.toList()) ;

它似乎是更好的表现.

所以这是我的问题:为什么第二个代码更好,是否有更好的,或者至少成本更低的方法呢？

Java语言设计者决定使用虚拟扩展方法而不是像C#这样的静态扩展方法.静态扩展方法可能导致与未来方法的命名冲突,但接口可能不受影响.

那么在Java中使用虚拟扩展方法的原因是什么？

我有不同的理由提出这个问题.

• 在JSR 310:基于的 日期和时间API中切换到微秒的决定是什么？

• 如果我测量时间,System.currentTimeMillis()我该如何解释1ms？多少个方法调用,多少个sysout,多少个HashMap#推送.

我完全清楚这个问题的科学标准很低,但是我想为java操作设置一些默认值.

编辑:

我在说:

long t1 = System.currentTimeMillis();
//do random stuff
System.out.println(System.currentTimeMillis()-t1);

来自Java doc的声明.

An exception parameter of a uni-catch clause is never implicitly declared final, but 也许 effectively final.

这可能意味着什么.请举例说明.