Java 从单个文本文件加载大量属性文件并插入LinkedHashMap

我有一个包含很多属性的文件，一行一行的文件可能是1000左右，每个属性文件大约有5000个键值对。例如：-示例（abc.txt）-

所以我打开这个文件，当它读取每一行时，我在loadProperties方法中加载属性文件。并将该属性中的键值对存储在LinkedHashMap中

public class Project {
    public static HashMap<String, String> hashMap;

    public static void main(String[] args) {
        BufferedReader br = null;
        hashMap = new LinkedHashMap<String, String>();
        try {
            br = new BufferedReader(new FileReader("C:\\apps\\apache\\tomcat7\\webapps\\examples\\WEB-INF\\classes\\abc.txt"));
            String line = null;
            while ((line = br.readLine()) != null) {
                loadProperties(line);//loads abc1.properties first time
            }
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
//I am loading each property file in this method. And checking whether the key 
already exists in the hashMap if it exists in the hashMap then concatenate the
new key value  with the previous key value. And keep on doing everytime you 
find key exists.

    private static void loadProperties(String line) {
        Properties prop = new Properties();
        InputStream in = Project.class.getResourceAsStream(line);
        String value = null;
        try {
            prop.load(in);
            for(Object str: prop.keySet()) {
                if(hashMap.containsKey(str.toString())) {
                    StringBuilder sb = new StringBuilder().append(hashMap.get(str)).append("-").append(prop.getProperty((String) str));
                    hashMap.put(str.toString(), sb.toString());
                } else {
                    value = prop.getProperty((String) str);
                    hashMap.put(str.toString(), value);
                    System.out.println(str+" - "+value);
                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }


    }

}

公共类项目{
公共静态HashMap HashMap；
公共静态void main（字符串[]args）{
BufferedReader br=null；
hashMap=newlinkedhashmap（）；
试一试{
br=新的BufferedReader（新的文件阅读器（“C:\\apps\\apache\\tomcat7\\webapps\\examples\\WEB-INF\\classes\\abc.txt”）；
字符串行=null；
而（（line=br.readLine（））！=null）{
loadProperties（行）；//第一次加载abc1.properties
}
}捕获（FileNotFoundException e1）{
e1.printStackTrace（）；
}
捕获（IOE异常）{
e、 printStackTrace（）；
}最后{
试一试{
br.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
}
//我正在用这个方法加载每个属性文件，并检查
hashMap中已经存在，如果它存在于hashMap中，则连接
用上一个键值创建新的键值，并在每次创建时继续执行
查找密钥存在。
私有静态void loadProperties（字符串行）{
Properties prop=新属性（）；
InputStream in=Project.class.getResourceAsStream（第行）；
字符串值=null；
试一试{
道具荷载（in）；
对于（对象str:prop.keySet（））{
if（hashMap.containsKey（str.toString（）））{
StringBuilder sb=new StringBuilder（）.append（hashMap.get（str））.append（“-”）.append（prop.getProperty（（String）str））；
put（str.toString（），sb.toString（））；
}否则{
value=prop.getProperty（（String）str）；
put（str.toString（），value）；
System.out.println（str+“-”+值）；
}
}
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}最后{
试一试{
in.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
}

---

所以我的问题是，我有1000多个属性文件，每个属性文件有5000多个键值对。大多数属性文件都有相同的键，但值不同，因此如果键相同，我必须将该值与前一个值连接起来。因此，随着属性文件和属性文件中的键值对不断增加，LinkedHashMap的大小是否有任何限制。所以这段代码已经优化到足以处理这类问题了？

除了为JVM分配的内存堆大小之外，Map没有任何限制，可以使用选项

-Xmx

从性能角度看，您的代码还可以

但我可以提出以下改进建议

避免使用

hashMap.containsKey（str.toString（））

然后使用

hashMap.get（str）

containsKey（key）

实现为

return get（key）！=null，因此实际上调用了两次
get（）
。你可以这样说：

value=map.get（键）；
if（值！=null）{
值+=str；
}
map.put（键、值）

不要调用

str.toString（）

。这个调用只是创建另一个与原始实例相同的字符串实例。因为属性类没有参数化，所以使用强制转换，即

（String）str

如果仍然存在性能问题，可以先合并所有属性文件，然后使用

properties.load（）

将它们作为一次加载。您可能会获得一些性能优势

public class Project {
    public static HashMap<String, String> hashMap;

    public static void main(String[] args) {
        BufferedReader br = null;
        hashMap = new LinkedHashMap<String, String>();
        try {
            br = new BufferedReader(new FileReader("C:\\apps\\apache\\tomcat7\\webapps\\examples\\WEB-INF\\classes\\abc.txt"));
            String line = null;
            while ((line = br.readLine()) != null) {
                loadProperties(line);//loads abc1.properties first time
            }
        } catch (FileNotFoundException e1) {
            e1.printStackTrace();
        }
        catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
//I am loading each property file in this method. And checking whether the key 
already exists in the hashMap if it exists in the hashMap then concatenate the
new key value  with the previous key value. And keep on doing everytime you 
find key exists.

    private static void loadProperties(String line) {
        Properties prop = new Properties();
        InputStream in = Project.class.getResourceAsStream(line);
        String value = null;
        try {
            prop.load(in);
            for(Object str: prop.keySet()) {
                if(hashMap.containsKey(str.toString())) {
                    StringBuilder sb = new StringBuilder().append(hashMap.get(str)).append("-").append(prop.getProperty((String) str));
                    hashMap.put(str.toString(), sb.toString());
                } else {
                    value = prop.getProperty((String) str);
                    hashMap.put(str.toString(), value);
                    System.out.println(str+" - "+value);
                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }


    }

}