小编maa*_*nus的帖子

我该如何实施？

class CaseInsensitiveConcurrentMap<V> implements ConcurrentMap<String , V>

哪个工作就像ConcurrentHashMap<String , V>除了密钥不区分大小写？密钥不应转换为小写或大写.

请注意,这Collections.synchronizedMap(new TreeMap<String, new MyCaseInsensitiveComparator())不是解决方案,因为它不允许并发并错过其他方法.

创建不区分大小写的一个字符串类equals和hashCode没有选择,因为相关地图将被传递给需要使用字符串作为键的方法.

在Delphi中有类似Java内存模型的东西吗？为了防止误解:我的意思是"巨大/大/小",但与其他线程的变化可见性相关的事情.

人们一致认为使用接口比使用类更好.我当然同意:一种接受的库方法ArrayList而不是List废话.

人们一致认为,表现总是一致的.在这里,我的基准是不同的. 接口和抽象类都有1到4个实现.当使用两个以上的实现时,性能开始出现分歧.我正在寻找这种行为的解释(以及错误共识的起源).

我上课了

private volatile long[][] data = new long[SIZE][];

最初只包含空值和访问它的方法.当它命中null元素时,它会创建一个long[]并存储以备将来使用.此操作是幂等的,并且在同一元素上浪费时间的多个线程不是问题.

没有线程必须看到未完全填充的元素.我希望以下代码做得对:

long[] getOrMakeNewElement(int index) {
    long[] element = data[index]; // volatile read
    if (element==null) {
        element = makeNewElement(index); // local operation
        data = data; // ugliness 1
        data[index] = element;
        data = data; // ugliness 2
    }
    return element;
}

第一个丑陋是确保其他线程理论上可以看到所做的更改element.它们实际上无法访问它,因为它还没有存储.但是,在下一个像element存储和另一个线程可能会或可能不会看到这个商店,所以AFAIK第一个丑陋是必要的.

然后第二个丑陋只是确保其他线程看到新的data包含element.这里奇怪的是两次使用丑陋.

这对于安全发布是否必要且充分？

注意:虽然这个问题类似于这一个,这是没有重复的,因为它与修改现有的一维数组,而不是建立一个交易.这使答案清楚.

更新

注:这是没有生产代码,我知道和不关心的替代品(AtomicReferenceArray,synchronized …

我有一个有向图(N, A),每个节点n[i]都有一个值v[i]和一个阈值t[i].对于每个箭头(n[i], n[j]),不变量v[i] <= v[j]成立.我需要有效地实现以下操作:

• increaseThreshold(i, x):设置t[i] = max(t[i], x).这是微不足道的,只是为了完整性.
• increaseValue(i, x):v[i] = max(v[i], x)根据需要设置和增加其他值,以便保持上述不变量.
• evaluate(i):如果返回true v[i] < t[i]

最简单的实现将存储v[i],t[i]以及每个节点的传出箭头.在increaseValue(i, x),它会沿着所有传出箭头传播值(使用一组"开放"节点,就像许多其他图形算法一样).v[i]与每个节点一起存储,evaluate(i)是微不足道的.

由于increaseValue比其他操作更频繁,这种急切的方法似乎是浪费.所以我想知道,如果v[i]根据需要重新计算一些惰性传播可能会更有效.对于这一点,我想保持w[i]作为最大的是x来自increaseValue(i, x)和计算v[j]时的飞行evaluate(j)需要它.它可以计算为有路径的w[i]所有节点的最大值.实际上,一旦我知道,确切的值无关紧要,我可以停止计算.n[i]n[j]v[j] >= t[j]v[j]

不幸的是,这种惰性算法的效率非常低,因此即使increaseValue频率高于数量级,它也不会得到回报evaluate.

我想,一些"部分懒惰"的算法可能会更好,但这只是我的直觉,我无法用它取得任何进展. …

我想知道,如何有效地计算hashCode类似BitSet的实现Set<Integer>.

该BitSet#hashCode显然是快速地计算,而愚蠢的(*)和不兼容的Set#hashCode().

快速兼容的实现可能会像

int hashCode() {
    int result = 0;
    for (int i=0; i<bits.length; ++i) {
        long word = bits[i];
        result += 64 * i * Long.bitCount(word) + weightedBitCount(word);
    }
    return result;
}

如果有一个有效的实施

int weightedBitCount(long word) { // naive implementation
    int result = 0;
    for (int i=0; i<64; ++i) {
        if ((word & (1L << i)) != 0) {
            result += i;
        }
    }
    return result;
}

如果未设置大多数位,可以通过测试word==0 …

我有一堆商店，每个商店都包含一个实体类型的列表，例如

const userStore = EntityStore.create(....)

const supplierStore = EntityStore.create(....)

有些商店可以提供额外的功能，所以我写了

const orderStore = EntityStore
.views(self => ({
    allByUserId: branchId => ....)
}))
.create(....)

到目前为止，一切都很好，但现在我想创建一个“商店经理”，其中包含所有此类商店的列表，但失败并显示如下消息

错误：[mobx-state-tree] 转换 ...
EntityStore 类型的值时出错：(id: Order)> 不可分配给 type: EntityStore，
应为 ... 的实例EntityStore或类似的快照
（请注意，快照提供的值与目标类型兼容）

消息很明确，我的“EntityStore with views”与“EntityStore”的类型不同。但它是它的扩展，所以我想知道是否有声明允许它。像List<? extends EntityStore>Java中的东西？

或者一个很好的解决方法，允许我在EntityStore不改变其类型的情况下添加附加功能？

我仍在使用旧的org.hibernate.Criteria，并且对获取模式越来越困惑。在各种查询中，我需要以下所有变体，因此我无法通过注释来控制它。我只是将所有内容都切换到@ManyToOne(fetch=FetchType.LAZY)，否则，查询中的任何内容都没有更改。

到目前为止我能找到的要么涉及 HQL 或 JPA2，要么只提供两种选择，但对于旧标准和（至少）以下三种情况，我需要它：

• 执行 JOIN，并从两个表中获取。除非数据过于冗余（例如，主数据很大或在结果中重复多次），否则这是可以的。在 SQL 中，我会写
  SELECT * FROM item JOIN order on item.order_id = order.id
WHERE ...;
• 执行 JOIN，从第一个表中获取，并与另一个表分离。这通常是前一个查询的更有效的变体。在 SQL 中，我会写
  SELECT item.* FROM item JOIN order on item.order_id = order.id
WHERE ...;

SELECT order.* FROM order WHERE ...;
• 执行 JOIN，但不获取连接的表。这很有用，例如，对于基于另一个表的数据进行排序。在 SQL 中，我会写
  SELECT item.* FROM item JOIN order on item.order_id = order.id
WHERE ...
ORDER BY order.name, item.name;

看起来没有明确指定fetch=FetchType.LAZY，一切都会像第一种情况一样急切地获取，这有时太糟糕了。我想，使用Criteria#setFetchMode，我可以获得第三种情况。我还没有尝试过，因为我仍然错过了第二个案例。我知道，它在某种程度上可能，还有的@BatchSize标注。

• 我对上面的说法正确吗？
• 有没有办法如何使用旧标准获得第二个案例？ …

为什么

public List<String> getList(){
    if (isMyListOKReady())
        return myList;
    return Collections.emptyList();
}

汇编得很好,但是

public List<String> getList(){
    return isMyListReady() ? myList : Collections.emptyList();
}

Eclipse说"Type mismatch: cannot convert from List<Object> to List<String>"？

我有一张大约30排,大约10列的桌子.行是一个更大的集合的子范围(我手动操作以避免巨大的DOM).列存储在列表中[{name: "firstname", width: 200}, {name: "married", type: "bool"}],这样可以提供一些灵活性(比如将属性"已婚"显示为复选框).

所以只有大约300个字段,但摘要周期大约需要一秒钟(在我的i5-2400 CPU @ 3.10GHz上).

我在解释Batarang表演页面时遇到了麻烦.它说

p.name | translate  16.0%  139.6ms
e[c.name]           15.8%  138.4ms
c.name | translate  11.1%   96.3ms

(稀疏命名的)变量的含义对我来说很清楚:

• e 代表实体,即表格行.
• p 代表财产,只发生在桌子外面.
• c 代表专栏.
• e[c.name]代表字段内容(来自实体名称e的属性c).

但性能数据没有多大意义:

• p.name只使用了10次,怎么可能需要那么长时间？
• c.name | translate也只发生了10次(在标题行中),它怎么能花那么长时间？

我知道{::a_once_only_bound_expression},我尝试过,但没有太大的成功.我真正需要的是以下内容:

• 当c更改时,重新创建整个表(这只是异常发生,所以我不关心速度).
• 当e变化,重新建立其整个行(当有一个变化,那么只有在单排).

有没有办法实现这个目标？

解决方案的想法

我想,我需要的是使用一个指令在渲染后从行中剥离掉所有角度的东西:

• 删除所有子范围
• 用他们所有的手表
• 但保留所有的HTML和听众

如果需要,我可以每行添加一个负责重绘的手表.

是否有意义？

更新

我一直忙于应用程序 - 改进除性能之外的其他事情.我很幸运,并获得了一些表现作为奖金.然后我将页面简化了一点,现在速度可以接受.至少现在(是.

仍然:

• 我不相信上述Batarang的表现值.
• 我仍然很好奇如何实现上述解决方案的想法,如果它是有道理的.