小编map*_*ple的帖子

当我使用Iterator迭代 some 时TreeMap，我发现相同Map.Entry的内容会发生变化。例如：

import java.util.Map.Entry;
import java.util.TreeMap;

public class Solution {
    public static void main(String[] args) {
        TreeMap<Integer, Integer> map = new TreeMap<>();
        map.put(1,1);
        map.put(2,2);
        map.put(3,3);
        System.out.println("map: " + map);
        Map<Integer, Integer> fromMap = map.tailMap(2);
        System.out.println("fromMap: " + fromMap);
        Iterator<Entry<Integer, Integer>> iter = fromMap.entrySet().iterator();
        Entry<Integer, Integer> entry = iter.next();
        System.out.println(entry); // line 1  
        iter.remove();
        System.out.println(entry); // line 2. Why does entry content change?
    }
}

结果：

map: {1=1, 2=2, 3=3}
fromMap: {2=2, 3=3}
2=2 …

第一个代码：

List<Integer>[] array = (List<Integer>[]) new Object[size]; 

它将给出以下异常：

java.lang.ClassCastException: class [Ljava.lang.Object; cannot be cast to class [Ljava.util.List; ([Ljava.lang.Object; and [Ljava.util.List; are in module java.base of loader 'bootstrap')

为什么会这样呢？我只是按照有效Java第三版 132页的方法进行操作：

第二码：

E[] array = (E[]) new Object[size];

但是我发现以下代码有效

第三码：

List<Integer>[] array = (List<Integer>[]) new List[size];

我的问题：

1. 为什么第一个代码是错误的，但是在有效Java中建议使用第二个代码？我有误会吗？

例如：为什么以下代码运行良好，但是第一个代码错误？

public class Test<E>{
    E[] array;
    public Test(){
        array = (E[]) new Object[10];
    }
    public E set(E x){
        array[0] = x;
        System.out.println(array[0]);
        return array[0];
    }

    public static void …

例如，给定一个 Integer 列表List<Integer> list = Arrays.asList(5,4,5,2,2)，如何maxHeap从该列表中获取O(n)时间复杂度的 a ？

天真的方法：

PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
for (Integer i : list) {
    maxHeap.offer(i);
}

然而，时间复杂度为O(nlogn)。

我们可以使用以下构造函数来触发heapify方法：

PriorityQueue<Integer> maxHeap = new PriorityQueue<>(list);

时间复杂度为O(n). 然而，它迫使我使用自然顺序，即minHeap。

我的问题：

如何通过使用自定义比较器堆化集合来构造 PriorityQueue？

参考： PriorityQueue 的 Java 文档

PS：@user207421
Heapify算法可以及时将任何未排序的数组转换为堆O(n)，而不是O(nlogn)。关于heapify的文章有很多，也在CLRS的Introduction to Algorithms Page 159中，从任何未排序的数组构建堆是O(n)。而且堆也不是排序数组。它是一个完整的树，具有堆属性，可以用数组进行编码。

例如，给定一个数组

arr = np.array([1,2,3,2,3,7,2,3,4])

有9元素。

我想求每个3元素的总和：

[6, 12, 9]

有没有我可以使用的 numpy api？

我遇到了类似的问题，可以简化如下：

例如我有一个文件结构如下：

----folder
    ---- main.py
    ---- math.py

我在 中定义了一个函数math.py，我想将其导入math.py到 中main.py。

中的代码math.py如下

# math.py
def f(x) :
    return x**3

如果我编写main.py如下代码

# main.py
import math

def main() :
    print(math.f(3))

if __name__ == "__main__":
    main()

然后它返回AttributeError: module 'math' has no attribute 'f'

如果我编写main.py如下代码

# main.py
from . import math

def main() :
    print(math.f(3))

if __name__ == "__main__":
    main()

然后它返回ImportError: cannot import name 'math' from '__main__' (main.py)

我的问题：

1. 如果我只想 …

PS： 考虑到有关 JDK 实现细节的动机或权衡的讨论经常会在 StackOverflow 上遇到阻力，普遍认为 JDK 工程师有权独立做出决策（之前关于 JDK 动机的帖子的关闭证明了这一点） ，我想澄清的是，这个问题严格集中在 HashMap 的算法和结构方面，特别是在两个单独的链接实现（头插入和尾插入）之间进行选择时涉及的分析和工程考虑。

在单独链接的HashMap 中，冲突是通过链接列表中的链接条目来管理的。当发生冲突时，新元素可以插入到链表的头部或尾部。两种方法具有相同的最坏时间复杂度，因为需要对列表进行完整扫描来识别重复项或插入点。然而，传统智慧和算法教育（例如，Sedgewick 的算法来源，算法简介，CLRS p.258）表明最好在头部插入，因为较新的元素更有可能很快被访问。

奇怪的是，虽然 JDK7 HashMap（第 402、766 行和JDK 7 源代码addEntry()中的方法）通过在头部插入来遵循此约定，但JDK8 切换到尾部插入（第 611、641 行和JDK 8 源代码中的方法）。putVal()