小编shm*_*sel的帖子

说我有以下代码:

Map<String, Boolean> map = ...
map.put("foo", true);

从理论上讲,true必须进行自动装箱,与插入相比会导致轻微的性能损失Boolean.TRUE.但是由于我们正在处理一个文字值,编译器是否有可能用一个盒装文字替换原始文字,因此没有额外的运行时开销？

在任何人攻击我之前,我通常会为了代码清晰度而选择原始文字,即使性能成本很低.这个问题大多是理论上的.

Matcher实现MatchResult，它“包含用于确定与正则表达式匹配结果的查询方法。” 出人意料的是，虽然group()，group(int)并且groupCount()通过提供MatchResult接口，group(String)是不是。

这是疏忽，还是出于兼容性原因将其排除在 Java 7 之外？如果是为了向后兼容，难道不能用 Java 8 中的默认方法解决吗？

我需要打印金字塔形状的字符数组.到目前为止我所拥有的是:

char[] chars = {'F', 'E', 'L', 'I', 'Z', ' ', 'A', 'N','I', 'V', 'E', 'R', 'S', 'A', 'R', 'I', 'O'};
    int length = chars.length;


  for (int i = 1; i < length; i += 2) {
  for (int j = 0; j < 9 - i / 2; j++)
    System.out.print(" ");

  for (int j = 0; j < i; j++)
    System.out.print(chars[j]);

  System.out.print("\n");
}
  for (int i = length; i > 0; i -= 2) {
  for (int j = …

我想在List的每个元素上调用lambda函数,并将结果放在一个新的List中.

我目前的版本是这样的:

b = a.stream().map(i-> i+1).collect(Collectors.toList());

但它似乎相当冗长,并且通过从列表到流的转换所需的所有样板代码隐藏了代码的意图,反之亦然.其他语言(例如ruby)中的相同代码将更加简洁,如下所示:

b = a.map{|i| i+1}

当然可以做这样的事情:

for (int i: a) {
    b.add(i+1);
}

但它看起来有点过时,而且不如lambda版本灵活.

为了改变现有的List,Holger的评论 list.replaceAll(i->i+1)很好,但我有兴趣创建一个新的List对象.

是否有一种方法可以在列表的每个元素上调用lambda并创建一个带有结果的新元素？

我有一个字符串

"Red apple, blue banana, orange".

我怎么能先用“，”分割它，然后在两个词之间添加“_”（例如 Red_apple 但不是橙色）并将所有字母大写。我阅读了一些帖子并找到了一个解决方案，但它只有拆分部分，我如何还添加“_”并将所有字母大写？：

   Pattern pattern = Pattern.compile(", ");
   List<Fruit> f = pattern.splitAsStream(fruitString)
  .map(Fruit::valueOf)
  .collect(Collectors.toList());

Fruit 是一个枚举对象。所以基本上，如果我能够将字符串转换为某种格式，并且我能够根据 Enum 名称获取 Enum 对象。

我正在研究java 8并行流并且想要在并行流中打印元素是一些顺序(比如插入顺序,逆序或顺序顺序).

为此,我尝试了以下代码:

        System.out.println("With forEachOrdered:");
        listOfIntegers
            .parallelStream()
            .forEachOrdered(e -> System.out.print(e + " "));
        System.out.println("");

        System.out.println("With Sequential:");
        listOfIntegers.parallelStream()
                    .sequential()
                    .forEach(e -> System.out.print(e + " "));

对于这两个,我得到相同的输出如下:

With forEachOrdered:
1 2 3 4 5 6 7 8 
With Sequential:
1 2 3 4 5 6 7 8 

从api文档中,我可以看到:

forEachOrdered - >这是一个终端操作.

和

顺序 - >这是一个中间操作.

所以我的问题是哪一个更好用？在哪种情况下,一个应该优先于其他情况？

我经常发现自己使用这个习语：

AtomicReference<MyCoolObject> coolReference = new AtomicReference(new MyCoolObject());

getOptionalValue().ifPresent(presentValue -> {
  coolReference.set(new MyCoolObject(presentValue));
});
return coolReference.get(); 

这是一个坏习惯，还是一个合法的使用AtomicReference？

我正在尝试在netbeans 8.2和JDK 1.8.131上调试java代码,但我一直收到这个错误

nbproject\build-impl.xml:1351:执行此行时发生以下错误:nbproject\build-impl.xml:858:nbjpdastart不支持嵌套的"modulepath"元素.

当我谷歌它时,没有足够的解释这个错误,谢谢你的帮助谢谢

我是Java 8的新手,还处于学习阶段.我必须使用java 8编写以下逻辑.我有一个Json数组数据,我的json结构如下所示.

{"list":[{"core":{"min":281.556,"max":286.67,"top":972.73},"dt":"2017-02-16 12:00:00"},{"core":{"min":281.821,"max":285.66,"top":970.91},"dt":"2017-02-16 15:00:00"},{"core":{"min":274.498,"max":277.05,"top":970.44},"dt":"2017-02-16 18:00:00"},{"core":{"min":271.503,"max":272.78,"top":969.32},"dt":"2017-02-16 21:00:00"}]}

这个jsonArray将包含大约100个jsonObject,每3小时有一个数据.我实际上需要使用java 8流或使用其他java 8功能分别找到max的平均值和max的平均值.另一个标准是最小和最大平均值应基于白天或夜晚.如果dt包含06:00或09:00或12:00或15:00,则应为dayavg(白天的最小值+最大值),否则应为夜间平均值((夜间最小值+最大值)).顶部不依赖于白天或黑夜.任何帮助赞赏

下面是使用java 7的登录.需要使用Java 8功能.

int dayavg=0;
        int nightavg = 0;
        int topavg=0;
        int day=0;
        int night = 0;
        int top=0;
    for(int i=0;i<50;i++){
        JsonNode node = list.get(i);
        String dt = node.get("dt").textValue();
        if(dt.contains("06:00:00")|| dt.contains("09:00:00") || dt.contains("12:00:00") || dt.contains("15:00:00")){
            int val = node.get("core").get("min").asInt() + node.get("core").get("max").asInt();
            day = day + val;
        }
        if(dt.contains("18:00:00")|| dt.contains("21:00:00") || dt.contains("00:00:00") || dt.contains("03:00:00")){
            int val = node.get("core").get("min").asInt() + node.get("core").get("max").asInt();
            night = night + val;
        }
        int val = node.get("core").get("top").asInt(); …

我一直在尝试重现(并解决)ConcurrentModificationException当一个实例HashMap被多个Threads 读取和写入时.

免责声明:我知道这HashMap不是线程安全的.

在以下代码中:

import java.util.*;

public class MyClass {

    public static void main(String args[]) throws Exception {
        java.util.Map<String, Integer> oops = new java.util.HashMap<>();
        oops.put("1", 1);
        oops.put("2", 2);
        oops.put("3", 3);

        Runnable read = () -> {
            System.out.println("Entered read thread");

            /*
             * ConcurrentModificationException possibly occurs
             *
            for (int i = 0; i < 100; i++) {
                List<Integer> numbers = new ArrayList<>();
                numbers.addAll(oops.values());
                System.out.println("Size " + numbers.size());
            }
            */

            for (int i = 0; …