Question

我基本上正在做以下事情：

将数据库表中的整行数据作为字符串转储到ArrayList< ArrayList< String>>。
为另一个数据库表做同样的事情。
通过遍历它并执行ArrayList< String>来查找第二个数据库中第一个数据库中的所有行a.contains(b.get(i))。如果包含true，那么我会a.remove(b.get(i))

现在，如果我改为使用Hashtable＆lt;的ArrayList＆LT;串GT;＆GT;使用a.containsKey(i.getKey())代替上面提到的ArrayList，其中i是b上的迭代器，然后使用i.remove删除？进行改变是否足够好？

另外，使用Hashmap会更谨慎吗？如果是这样的原因......

Answer 1

我自下而上的回答：

Hashtable和HashMap之间的区别已在Differences between HashMap and Hashtable?中进行了（彻底）讨论。简短摘要：HashMap更有效，应该用来代替Hashtable。
在散列数据结构中查找数据（contains（）和remove（）操作）的顺序为O（log2） - 也就是说，它与数据点数的2对数成比例在结构中。如果有4个数据元素需要X时间;如果有8个元素需要2倍时间，16个元素，3倍时间等等。哈希结构的数据访问时间增长非常缓慢查找列表中的数据的顺序为O（N） - 即，与列表中的元素数量成正比。 1个元素占用Y时间，2个元素占用2Y时间，4个元素占用4Y时间，依此类推。因此，时间消耗随着列表的大小线性增长。
所以：如果你必须从数据结构中随机找到随机的大量元素，那么哈希数据结构是最好的选择，只要：
- data有一个像样的hashCode（）实现（ArrayList的实现是正常的）
- 数据具有相互匹配的hashCode（）和equals（）实现，即。如果a.equals（b）则a.hashCode（）== b.hashCode（）。对于ArrayList也是如此。
另一方面，如果您正在使用有序数据，则还有其他算法可以减少搜索并显着消除时间。如果数据库中的数据被索引，则在获取数据时使用ORDER BY然后使用算法来获取有序数据可能是值得的。

总结：使用HashMap而不是ArrayList作为列表a。

我写了一个小程序来对问题进行基准测试。结果优先：在Core i5 2.40 GHz CPU上，程序在Sun JVM 1.6.0_41上运行，适用于Windows 7,32位。打印输出：

For 1000 words: List: 1 ms, Map: 2 ms
For 5000 words: List: 15 ms, Map: 12 ms
For 10000 words: List: 57 ms, Map: 12 ms
For 20000 words: List: 217 ms, Map: 37 ms
For 30000 words: List: 485 ms, Map: 45 ms
For 50000 words: List: 1365 ms, Map: 61 ms

在这样的简单测试中，性能特征非常好。我运行了包含更多数据的地图版本并获得了以下内容：

For 100000 words: List: - ms, Map: 166 ms
For 500000 words: List: - ms, Map: 1130 ms
For 1000000 words: List: - ms, Map: 3540 ms

最后是基准测试代码：

public void benchmarkListVersusMap() {
    for (int count : new int[]{1000, 5000, 10000, 20000, 30000, 50000}) {
        // Generate random sample data
        List<List<String>> words = generateData(count, 10, count);

        // Create ArrayList
        List<List<String>> list = new ArrayList<List<String>>();
        list.addAll(words);

        // Create HashMap
        Map<List<String>, Boolean> map = new HashMap<List<String>, Boolean>();
        for (List<String> row : words) {
            map.put(row, true);
        }

        // Measure:
        long timer = System.currentTimeMillis();
        for (List<String> row: words) {
            if (list.contains(row)) {
                list.remove(row);
            }
        }
        long listTime = System.currentTimeMillis() - timer;
        timer = System.currentTimeMillis();
        for (List<String> row : words) {
            if (map.containsKey(row)) {
                map.remove(row);
            }
        }
        long mapTime = System.currentTimeMillis() - timer;
        System.out.printf("For %s words: List: %s ms, Map: %s ms\n", count, listTime, mapTime);
    }
}

private List<List<String>> generateData(int rows, int cols, int noOfDifferentWords) {
    List<List<String>> list = new ArrayList<List<String>>(rows);
    List<String> dictionary = generateRandomWords(noOfDifferentWords);
    Random rnd = new Random();
    for (int row = 0; row < rows; row++) {
        List<String> l2 = new ArrayList<String>(cols);
        for (int col = 0; col < cols; col++) {
            l2.add(dictionary.get(rnd.nextInt(noOfDifferentWords)));
        }
        list.add(l2);
    }
    return list;
}

private static final String CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
private List<String> generateRandomWords(int count) {
    Random rnd = new Random();
    List<String> list = new ArrayList<String>(count);
    while (list.size() < count) {
        StringBuilder sb = new StringBuilder(20);
        for (int i = 0; i < 10; i++) {
            sb.append(CHARS.charAt(rnd.nextInt(CHARS.length())));
        }
        list.add(sb.toString());
    }
    return list;
}

Answer 2

摘自Javadoc comment of ArrayList：

运行size，isEmpty，get，set，iterator和listIterator操作在恒定的时间。添加操作以分摊的常量时间运行，也就是说，添加n个元素需要O（n）时间。所有其他的操作以线性时间运行（粗略地说）。不变因素与LinkedList实现相比较低。

这意味着，第二个列表上的get操作以恒定时间O（1）运行，从性能的角度来看应该没问题。但是包含和删除操作（在第一个列表上）以线性时间O（n）运行。像第二个列表的大小一样多次调用这些操作可能会持续很长时间，特别是如果两个列表都很大。

对第一个使用散列数据结构将导致恒定时间 - O（1） - 用于调用操作包含和删除。我建议使用HashSet作为第一个“列表”。但这只有在所有行不相等的情况下才有效。

但在尝试优化某些内容之前，您应始终始终进行分析。首先要确保你正在优化正确的地方。

.contains（）方法对于Hashtable <arraylist <string>，boolean＆gt;的速度要快多少？比ArrayList <arraylist <string>＆gt;？</arraylist <string> </arraylist <string>

2 个答案: