小编maa*_*nus的帖子

我积累了ConcurrentHashMap一些变化，应该定期发送到某个地方（用于某种复制）。关于更改，仅针对任何关键事项的最新值。

所以我需要获取并删除一些快照。快照不必是原子的，只要它的每个条目都反映操作期间某个时刻原始映射的状态就足够了。

重要的是，只有结果中存在且最新的条目才可以从原始地图中删除。我想，应该执行以下操作：

<K, V> ConcurrentMap<K, V> getAndRemoveAll(ConcurrentMap<K, V> map) {
    ConcurrentHashMap<K, V> result = new ConcurrentHashMap<>(map);    
    result.forEach((resultKey, resultValue) -> 
    map.computeIfPresent(resultKey,
        (k, mapValue) -> mapValue==resultValue ? null : mapValue)); 
    return result;
}

这真的正确吗？在单次迭代中可能吗？

我遇到一个无辜的请求后,我的客户端被注销了.我控制了两端,经过大量的调试后,我发现发生了以下情况:

• 客户端使用正确的Authorization标头发送请求.
• 服务器响应304 Not Modified没有任何Authorization标头.
• 浏览器提供完整的响应,包括在其缓存中找到的过时的Authorization标头.
• 从现在开始,客户端使用过时的授权并被踢出.

据我所知,浏览器不得缓存包含授权的任何请求.尽管如此,

chrome://view-http-cache/http://localhost:10080/api/SearchHost

节目

HTTP/1.1 200 OK
Date: Thu, 23 Nov 2017 23:50:16 GMT
Vary: origin, accept-encoding, authorization, x-role
Cache-Control: must-revalidate
Server: 171123_073418-d8d7cb0 =
x-delay-seconds: 3
Authorization: Wl6pPirDLQqWqYv
Expires: Thu, 01 Jan 1970 00:00:00 GMT
ETag: "zUxy1pv3CQ3IYTFlBg3Z3vYovg3zSw2L"
Content-Encoding: gzip
Content-Type: application/json;charset=utf-8
Content-Length: 255

有趣的服务器头由一些内部信息替换Jetty服务器头(出于安全原因不应该提供) - 忽略它.这就是curl所说的:

< HTTP/1.1 304 Not Modified
< Date: Thu, 23 Nov 2017 23:58:18 GMT
< Vary: origin, accept-encoding, authorization, x-role
< Cache-Control: must-revalidate …

我有一个带有两个带外键的表的h2数据库

CREATE TABLE master (masterId INT PRIMARY KEY, slaveId INT);
CREATE TABLE slave (slaveId INT PRIMARY KEY, something INT,
    CONSTRAINT fk FOREIGN KEY (slaveId) REFERENCES master(slaveId));

并需要类似的东西

DELETE master, slave FROM master m JOIN slave s ON m.slaveId = s.slaveId
    WHERE something = 43;

即,从两个表中删除(AFAIK在MySql中工作).因为FOREIGN KEY我不能先从master中删除.当我从奴隶中删除时,我丢失了要从主站删除哪些行的信息.使用ON DELETE CASCADE会有所帮助,但我不希望它每次都自动发生.我应该暂时允许吗？我应该使用临时表还是什么是最佳解决方案？

如果java.lang.Integer.rotateLeft通过使用旋转指令进行优化并为其编写基准,我很好奇.结果是不确定的:它比两个班次快得多但比一个班次慢一点.所以我用C++重写了它并获得了相同的结果.通过g++ -S -Wall -O3我编译时可以看到生成的汇编程序中的指令.我的CPU是Intel Core i5.

该基准是很长,肯定不是最好的一段代码,但我不认为这是坏了.或者是吗？根据文档,旋转需要一个周期,就像轮班一样.谁能解释一下结果呢？

rotations:  6860
shift:      5100

前两个答案是错误的.gcc和java的JIT都知道旋转指令并使用它们.关于gcc看到上面的链接,关于java看看我的java基准测试及其结果

benchmark   ns linear runtime
   Rotate 3.48 ====================
NonRotate 5.05 ==============================
    Shift 2.16 ============

我需要以不同的顺序处理一棵树,比方说BFS和DFS.通过使用队列或堆栈,两者都很容易,但是,我在Java中缺少适当的接口,允许执行类似的操作

QueueOrStack<N> pending = ...
while (!pending.isEmpty()) {
    N node = pending.poll(); // <----- this is the problem
    pending.addAll(node.children());
    process(node);
}

没有真正的问题,我可以将其封装ArrayList到实现Queue^{1的内容中},但是我敢打赌,我忽略了Java Collection Framework中的某些内容.还是真的不见了？

__

¹或使用最新的第一个比较器PriorityQueue,这可能是一个愚蠢的想法

我真的很想知道这样的界面是什么用的.该方法的目的称为

_dont_implement_Matcher___instead_extend_BaseMatcher_

很清楚,但界面的目的是什么？

如果我不想让人们实现一个接口,我就不会提供任何接口 - 一个抽象类可以完成这项工作.除非有一些我无法看到的隐藏原因.有人可以吗？

我有以下代码，我在其中使用 superList 和 subList，我想检查 subList 实际上是 superList 的 subList。

我的对象没有实现 hashCode 或 equals 方法。我在测试中创造了类似的情况。当我运行测试时，结果显示 JDK 集合和普通集合的结果之间的性能差异非常大。运行测试后，我得到以下输出。

使用 Java Collection API 的时间流逝 8953 MilliSeconds & 结果为真 使用 Commons Collection API 的时间流逝 78 MilliSeconds & 结果为真

我的问题是为什么 java collection 在处理 containsAll 操作时如此缓慢。我在那里做错了吗？我无法控制从遗留代码中获得的集合类型。我知道如果我对 superList 使用 HashSet 那么我会使用 JDK containsAll 操作获得很大的性能提升，但不幸的是，这对我来说是不可能的。

package com.mycompany.tests;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

import org.apache.commons.collections.CollectionUtils;
import org.junit.Before;
import org.junit.Test;

public class CollectionComparison_UnitTest {

    private Collection<MyClass> superList = new ArrayList<MyClass>();
    private Collection<MyClass> subList = new HashSet<MyClass>(50000);

    @Before
    public void …

我有两台运行 Firebird 的计算机（我们称它们为 A 和 B）和两个数据库文件（我们称它们为 a.fdb 和 b.fdb），都复制到两台计算机上。在 BI 上获取消息

b.fdb 不是有效的数据库 其他文件工作，在 A 上两个文件工作。

这很容易解释，如果 B 是旧版本，但它是新版本（它是 FB 2.1，由于这个问题，我安装了 FB 2.5）。文件 a.fdb 和 b.fdb 分别具有 ODS 11.1 和 10.1。看起来新版本的 FB 不再支持 ODS 10.1，我不敢相信。但我看不到其他解释，你能吗？

在Comparable的契约中，没有任何东西强迫一个对象与它自己相比较。只是

强烈推荐，但不严格要求 (x.compareTo(y)==0) == (x.equals(y))

这意味着，它的建议对于x.compareTo(x)不扔。但是可以写一个

class X implements Comparable<Y> {
    ...
}

其中X和Y是两个不相关的类。我看不出它有什么好处，但在 Java 8 版本中HashMap甚至有相应的检查。

• 是否允许X implements Comparable<Y>使用两个不相关的类来实现？
• 有什么意义吗？

^{我想答案是肯定的和否定的，但这只是一个猜测}

昨天，我用于keytool列出我们的密钥库，如下所示：

keytool -list -keystore src/keystore.p12 
Enter keystore password:  
Keystore type: JKS
Keystore provider: SUN

Your keystore contains 5 entries

octopus, Jan 15, 2018, PrivateKeyEntry, 
Certificate fingerprint (SHA1): FE:B2:B7:C0:A7:CF:...

由于存在问题，我得出的结论是第一份证书刚刚过期。今天我要

octopus, Jan 16, 2018, PrivateKeyEntry, 
Certificate fingerprint (SHA1): FE:B2:B7:C0:A7:CF:...

难道keytool真的意味着用于显示当前日期或只是开玩笑???

但我认为日期是“不晚于”日期，因为这很有意义。不能是条目添加或最近修改的日期。我可能做错了，但是

• 我确定日期已经更改，就像我昨天发送的电子邮件中看到的一样
• 我确定git跟踪的密钥库没有发生变化。我什至删除了它并再次签出，没有变化
• 我确定密钥库自六个月前以来就没有改变过（git同意）
• 其他条目显示不同的日期

keytool不提供任何版本信息。

java version "1.8.0_151"
Java(TM) SE Runtime Environment (build 1.8.0_151-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)