Java 使用并发hashmap

我想知道在下面的代码中迭代hashmap之后是否可以访问得到的值（我知道它们存储在map中，但希望在循环外使用它们）。在循环中迭代键和相应的值。并发hashmap可以帮助我获取值并在循环外使用它们吗

多谢各位

     public static void main(String[] args) {
    Map<String, List<String>> maleMap = new LinkedHashMap<String,  List<String>>();
Map<String, List<String>> femaleMap = new LinkedHashMap<String, List<String>>();
    try {

Scanner scanner = new Scanner(new FileReader(.txt));

        while (scanner.hasNextLine()) {
            String nextLine = scanner.nextLine();
            String[] column = nextLine.split(":");
            if (column[0].equals("male") && (column.length == 4)) {
                maleMap.put(column[1],
                Arrays.asList(column[2], column[3]));
        } else if (column[0].equals("female") && (column.length == 4)) {
        femaleMap.put(column[1],
                    Arrays.asList(column[2], column[3]));
            }
        }
        Set<Entry<String, List<String>>> entries = maleMap.entrySet();
        Iterator<Entry<String, List<String>>> entryIter = entries
                .iterator();
        while (entryIter.hasNext()) {
            Map.Entry entry = (Map.Entry) entryIter.next();
            Object key = entry.getKey(); // Get the key from the entry.

            List<String> value = (List<String>) entry.getValue();
            Object value1 = " ";
            Object value2 = " ";
            int counter = 0;
            for (Object listItem : (List) value) {
                Writer writer = null;
                Object Name = key;
                Object Age = null;
                Object ID = null;
                if (counter == 0) {// first pass assign value to value1
                    value1 = listItem;
                    counter++;// increment for next pass
                } else if (counter == 1) {// second pass assign value to
                                            // value2
                    value2 = listItem;
                    counter++;// so we dont keep re-assigning listItem for
                                // further iterations
                }
            }
            System.out.println(key + ":" + value1 + "," + value2);
            scanner.close();
            Writer writer = null;
            Object Name = key;
            Object Age = value1;
            Object ID = value2;

            try {
                String filename = ".txt";
            FileWriter fw = new FileWriter(filename, true); 

 fw.write("# Table" +  Name + "\n" + "map:"+ Name + " a d2rq:ClassMap;" + "\n"
 + "    dataStorage map:database;" + "\n"+ "Pattern " +"\""+ Name + "/@@"+ Age +    
 "." + ID + "@@\";" + "\n"+ "   class :" + Name +";"+"\n"+ "     ."+"\n");// 
                fw.close();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }

publicstaticvoidmain（字符串[]args）{
Map maleMap=新建LinkedHashMap（）；
Map femaleMap=新建LinkedHashMap（）；
试一试{
Scanner Scanner=新扫描仪（新文件读取器（.txt））；
while（scanner.hasNextLine（））{
字符串nextLine=scanner.nextLine（）；
String[]column=nextLine.split（“：”）；
if（column[0].equals（“male”）&&（column.length==4））{
maleMap.put（列[1]，
asList（列[2]，列[3]）；
}else如果（列[0]。等于（“女性”）&&（列.length==4））{
femaleMap.put（列[1]，
asList（列[2]，列[3]）；
}
}
Set entries=maleMap.entrySet（）；
迭代器入口=条目
.iterator（）；
while（entryIter.hasNext（））{
Map.Entry=（Map.Entry）entryIter.next（）；
Object key=entry.getKey（）；//从条目中获取密钥。
List value=（List）entry.getValue（）；
对象值1=“”；
对象值2=“”；
int计数器=0；
for（对象列表项：（列表）值）{
Writer=null；
对象名称=键；
对象年龄=空；
对象ID=null；
如果（计数器==0）{//第一次传递将值分配给值1
value1=列表项；
计数器+++；//下一个过程的增量
}如果（计数器==1）{//第二次传递将值赋值给
//价值2
value2=列表项；
计数器+++；//所以我们不会一直为
//进一步迭代
}
}
System.out.println（键+“：“+value1+”，“+value2”）；
scanner.close（）；
Writer=null；
对象名称=键；
对象年龄=值1；
对象ID=值2；
试一试{
字符串filename=“.txt”；
FileWriter fw=新的FileWriter（文件名，true）；
fw.write（“#Table”+Name+”\n“+”映射：“+Name+”一个d2rq:ClassMap；“+”\n”
+“数据存储映射：数据库；“+”\n“+”模式“+“\”+Name+“/@@”+Age+
“+ID+”@@\”；“+”\n“+”类：“+Name+”；“+”\n“+”+“+”\n”）；//
fw.close（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}

ConcurrentHashMap

设计为线程安全。
如果你不使用多个线程，这比没有用还要糟糕

您应该只使用一个

多重映射

---

您始终可以访问循环外部的值。

ConcurrentHashMap是故障安全的。它不会提供任何并发修改异常。它适用于多线程操作。ConcurrentHashMap的整个实现与HashMap相同，但在检索元素时，HashMap锁定整个映射，限制进一步修改但在ConcurrentHashMap中，锁定发生在bucket级别，因此不存在出现并发修改异常的可能性。

您实际使用的是多线程吗？a）ConcurrentHashMap是线程安全的映射，看起来不是多线程的；b）两个循环中的哪一个？c）什么变量？