小编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 中的默认方法解决吗？

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

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

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

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

我一直在尝试重现(并解决)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; …

我试图理解为每个棋子确定有效移动背后的算法。我遇到的具体问题是确定一块何时无法移动通过某个点，因为它被自己颜色的一块挡住了，或者能够占据相反颜色的一块但无法移动通过该点。

我对每件作品的简单算法是：

有效王棋，如果棋子从（X1，Y1）移动到（X2，Y2），当且仅当|X2-X1|<=1且|Y2-Y1|<=1时该棋步有效。

有效的象棋移动，如果棋子从 (X1, Y1) 移动到 (X2, Y2)，则移动有效当且仅当 |X2-X1|=|Y2-Y1|。

有效的车子移动，如果棋子从（X1，Y1）移动到（X2，Y2），则当且仅当 X2=X1 或 Y2=Y1 时移动有效。

有效的后移动，如果后移动是有效的象或车移动，则该移动是有效的。

有效的骑士移动，如果棋子从 (X1, Y1) 移动到 (X2, Y2)，则移动有效当且仅当 (|X2-X1|=1 and |Y2-Y1|=2) 或 (|X2 -X1|=2 和 |Y2-Y1|=1）。

有效的Pawn移动，如果棋子从（X1，Y1）移动到（X2，Y2），则当且仅当X2=X1且Y2-Y1=1时移动有效（仅适用于白色Pawn）。

任何意见，将不胜感激。

我试图用java8的Collectors.toMap上Stream的ZipEntry.它可能不是最好的主意,因为在处理过程中可能会出现异常,但我想它应该是可能的.

我现在得到一个编译错误(类型推理引擎,我猜),我不明白.

这是一些提取的演示代码:

import java.io.IOException;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

public class TestMapCollector {

    private static class MyObject {
    }

    public static void main(String[] argv) throws IOException {
        try (ZipFile zipFile = new ZipFile("test")) {
            Map<String, MyObject> result = zipFile.stream()
                    .map(ZipEntry::getName)
                    .collect(Collectors.toMap(f -> "test", f -> new MyObject()));
        }
    }
}

此代码按原样构建,但如果您只是对该.map(ZipEntry::getName)行进行注释,则不会构建该代码.好像toMap收集器可以工作,如果输入是一个流String但不是输入是一个流ZipEntry？

作为参考,这是构建错误的开始,它非常模糊:

no suitable method found for collect(Collector<Object,CAP#1,Map<String,MyObject>>)
    method Stream.<R#1>collect(Supplier<R#1>,BiConsumer<R#1,? super CAP#2>,BiConsumer<R#1,R#1>) …

如何使用Java Stream Api替换此代码？

for (Book book : Books.getAllBooks()) {
        for (SearchResult searchResult : searchResultList) {
          if (searchResult.getTableName().replace("attr_", "") .equals(book.getTableName())) {
            bookList.add(book);
          }
        }
      }

我得到了一个从 db 调用返回的列表。

List<employee> list = empolyeeRepository.findByEmployeeId(id);

列表包含员工 pojo 类对象。我想删除一个属性，让我们在从休息电话返回时说“员工银行账户号”。

@RequestMapping(value = "/employeeInformation/{id}",
     method = RequestMethod.GET,
     produces = MediaType.APPLICATION_JSON_VALUE)
@Timed
public List<Employee> getEmployeeInformation(@PathVariable("id") String id) throws Exception {
            return empolyeeRepository.findByEmployeeId(id);
        }

是否有任何注释或良好做法可以做到这一点？

我有一个类,它将元素添加到ArrayList(实例变量).当我使用Junit为类编写测试用例时,我只对类初始化一次.我在两个测试用例中都做了同样的工作.

public class Solution {

    List<String> list = new ArrayList<String>();

    public void modifyList() {
        list.add("A");
        list.add("B");
        list.add("C");
    }
}

SolutionTest.java

public class TestSolution {

    Solution sol = new Solution();

    @Test
    public void testModifyList1() {
        sol.modifyList();
        Assert.assertEquals(3, sol.list.size());
        System.out.println(sol.list);
    }

    @Test
    public void testModifyList2() {
        sol.modifyList();
        Assert.assertEquals(3, sol.list.size());
        System.out.println(sol.list);
    }
}

当我在两个测试用例中打印列表时,为什么列表在第二个测试用例中打印时不返回[A, B, C, A, B, C].它为什么只是回归[A, B, C].我的理解是,该类只初始化一次,因此列表只有一个副本,应该修改两次.但是,当我打印列表时,它只打印从该测试用例修改的值.有人可以解释一下这种行为吗？

当我在两个不同的测试用例中对同一个对象调用相同的方法时,为什么列表不会被更新两次？

我有一个List<DataBean>bean定义如下，

private int id;
private int activityId;
private String info;
private int answerCode;
private String otherData;

还有另一个带有不同 bean 的 List List<Answer>，其 bean 如下所示：

   private int id;
   private int code;

我需要找到所有的答案List<Answer>，其code包含在列List<DataBean>.answerCode。

例子：

List<DataBean> 包含

id  activityId  info answerCode
1   1           ..   144
1   1           ..   153
1   2           ..   160
1   3           ..   177

List<Answer> 包含

id  code
--------
1   160
2   161

因此，我的结果List<Answer>只有一个： 1 160.