java - 如何从 ArrayList 中同时删除多个项目

Question

我的家庭作业有问题，问题是我有大约 40.000 HashMap<Character,Character>存储在 ArrayList<HashMap<Character,Character>> 中的对象对象。

每个对象 HashMap<Character,Character>对象表示替换密码的 key 。所以一个 HashMap 对象可能是:a->a; b->b; c->c; d->d; e->e; f->f; g->h; h->g这意味着 g 和 h 在加密/解密期间交换。

问题是我正在编写对此密码的暴力攻击，所以我要遍历这 40.000 个 key 。

当程序检测到说 g->h 是一个错误的替换时，我想删除所有包含该条目的 HashMap 对象，而不仅仅是我在循环中使用的当前元素，因此能够避免一一检查 key 。

到目前为止，我已经尝试了以下方法，但它毫无异常(exception)地卡住了，或者任何事情都没有完成，甚至在调试时也没有:

  ArrayList<HashMap<Character,Character>> all_keys = new ...`
  all_keys = generateAllCombinations();`
  ArrayList<HashMap<Character,Character>> keys_to_delete = new ...`

  for(HashMap<Character,Character> key:all_keys){`
     all_keys.removeAll(keys_to_delete);
     \\other stuff going on...`
        if (!letters[0].getChar().equals(Constants.CHAR_E)){
         Character invChar = key.get(Constants.CHAR_E);
          for(HashMap<Character,Character> key2 : all_keys){
                if(key2.get(Constants.CHAR_E).equals(invChar)){
                 keys_to_delete.add(key2);
                }
          }

    }
   }

Answer 1

我已经提到过，从当前正在迭代的集合中删除元素时必须小心。这很容易导致 ConcurrentModificationException。对于不能轻易使用迭代器的“复杂”情况，通常可以应用的模式是，而不是做类似的事情

Collection<Element> collection = ...
for (Element element : collection)
{
    if (hasToBeRemoved(element)) 
    {
        // Will cause a ConcurrentModificationException!
        collection.remove(element);
    }
}

您收集要删除的元素，并一次将它们全部删除

Collection<Element> collection = ...
Collection<Element> elementsToRemove = new List<Element>();
for (Element element : collection)
{
    if (hasToBeRemoved(element)) 
    {
        elementsToRemove.add(element);
    }
}
collection.removeAll(elementsToRemove);

根据代码，您似乎尝试过类似的操作，使用您的keys_to_delete，但这并不完全清楚。

如评论中所述，您应该考虑用于替换等的专用数据结构。但即使您希望为此目的坚持使用列表和 map ，您也应该始终使用接口(interface)在声明中。所以不是

ArrayList<HashMap<Character,Character>> allKeys = ...

你应该写

List<Map<Character,Character>> allKeys = ... 

---

但是，关于实际问题:似乎主要问题可以通过引入类似 computeKeysContaining(maps, entry) 的方法来解决，该方法返回给定集合中包含特定条目的所有 map .

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MapListKeyRemoval
{
    public static void main(String[] args)
    {
        List<Map<Character,Character>> allKeys = generateAllCombinations();

        print("All keys", allKeys);

        Set<Map<Character,Character>> keysToDelete = 
            new LinkedHashSet<Map<Character,Character>>();
        for (Map<Character, Character> key : allKeys)
        {
            for (Entry<Character, Character> entry : key.entrySet())
            {
                if (isInvalidMapping(entry))
                {
                    System.out.println("Invalid mapping: "+entry);
                    Set<Map<Character, Character>> keysWithInvalidMapping =
                        computeKeysContaining(allKeys, entry);

                    print("Keys with invalid mapping", keysWithInvalidMapping);

                    keysToDelete.addAll(keysWithInvalidMapping);
                }
            }
        }
        print("Keys to delete", keysToDelete);

        allKeys.removeAll(keysToDelete);

        print("All keys after removal", allKeys);
    }

    private static void print(
        String message, Iterable<Map<Character,Character>> keys)
    {
        System.out.println(message);
        for (Map<Character, Character> key : keys)
        {
            System.out.println(key);
        }
    }

    private static Set<Map<Character, Character>> computeKeysContaining(
        List<Map<Character,Character>> allKeys,
        Entry<Character, Character> entry)
    {
        Set<Map<Character,Character>> keysContainingEntry =  
            new LinkedHashSet<Map<Character,Character>>();
        for (Map<Character, Character> key : allKeys)
        {
            Object value = key.get(entry.getKey());
            if (value != null && value.equals(entry.getValue()))
            {
                keysContainingEntry.add(key);
            }
        }
        return keysContainingEntry;
    }

    private static boolean isInvalidMapping(Entry<Character, Character> entry)
    {
        return entry.getKey().equals('g') && entry.getValue().equals('h');
    }

    private static List<Map<Character, Character>> generateAllCombinations()
    {
        List<Map<Character, Character>> result = 
            new ArrayList<Map<Character,Character>>();
        result.add(createMapping('f','i','r','s','t','-','g','h'));
        result.add(createMapping('s','e','c','o','n','d','g','x'));
        result.add(createMapping('t','h','i','r','d','-','g','h'));
        result.add(createMapping('f','o','u','r','t','h','g','x'));
        return result;
    }

    private static Map<Character, Character> createMapping(char ... c)
    {
        Map<Character, Character> map = 
            new LinkedHashMap<Character, Character>();
        for (int i=0; i<c.length/2; i++)
        {
            map.put(c[i*2+0], c[i*2+1]);
        }
        return map;
    }
}

(除此之外，我想知道为什么那些正在回答问题的人是那些(必须)创建 https://stackoverflow.com/help/mcve 的人，即使是对于这样简单的问题，但不想推测这里的原因)