如何将多个arrayList替换为单个集合Java

我正在编写这个实用程序代码，将excel工作表转储到数据库中（本例中为postgres）。我使用poi的HSSF技术处理excel表格。我将excel工作表的每一列存储到字符串类型的单独ArrayList中。在这种情况下，当.xls中的列数大于23时，eclipse将生成一个错误“heap memory full”。我的问题是，我可以将这些ArrayList组合成一个集合对象吗？我应该使用哪种方法

public ArrayList<String> getList(String path, String srnoStr,
        String nameStr, String dobStr, String genderStr, String addressStr,
        String pinStr, String mobStr, String eIdStr, String categoryStr,
        String branchStr) throws IOException, SQLException {

    ArrayList<String> errorList = new ArrayList<String>();
    ArrayList<String> cellError = null;

    // String error=null;
    // OrderedMap errorMap=new LinkedMap();
    // errorMap=null;

    List<Cell> cells_srno = new ArrayList<Cell>();
    List<Cell> cells_name = new ArrayList<Cell>();
    List<Cell> cells_dob = new ArrayList<Cell>();
    List<Cell> cells_gender = new ArrayList<Cell>();
    List<Cell> cells_address = new ArrayList<Cell>();
    List<Cell> cells_pin = new ArrayList<Cell>();
    List<Cell> cells_mob = new ArrayList<Cell>();
    List<Cell> cells_eId = new ArrayList<Cell>();
    List<Cell> cells_category = new ArrayList<Cell>();
    List<Cell> cells_branch = new ArrayList<Cell>();

            try {
        int srnoIndex = 0;
        srnoIndex = getIndex(srno, path);
        cellError = fillList(srnoIndex, srNoId, cells_srno, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int nameIndex = 0;
        nameIndex = getIndex(name, path);
        cellError = fillList(nameIndex, nameId, cells_name, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int dobIndex = 0;
        dobIndex = getIndex(dob, path);
        cellError = fillList(dobIndex, dobId, cells_dob, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int genderIndex = 0;
        genderIndex = getIndex(gender, path);
        cellError = fillList(genderIndex, genderId, cells_gender, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int addressIndex = 0;
        addressIndex = getIndex(address, path);
        cellError = fillList(addressIndex, addressId, cells_address, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int pinIndex = 0;
        pinIndex = getIndex(pin, path);
        cellError = fillList(pinIndex, mobId, cells_pin, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int mobIndex = 0;
        mobIndex = getIndex(mob, path);
        cellError = fillList(mobIndex, pinId, cells_mob, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int eIdIndex = 0;
        eIdIndex = getIndex(eId, path);
        cellError = fillList(eIdIndex, eIdId, cells_eId, path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int categoryIndex = 0;
        categoryIndex = getIndex(category, path);
        cellError = fillList(categoryIndex, categoryId, cells_category,
                path);
        if (cellError != null)
            errorList.addAll(cellError);

        cellError = null;
        int branchIndex = 0;
        branchIndex = getIndex(branch, path);
        cellError = fillList(branchIndex, branchId, cells_branch, path);
        if (cellError != null)
            errorList.addAll(cellError);

        // System.out.println(cells);
        int n = cells_srno.size();
        int k = 0;
        System.out.println("Total number Rows = " + (n - 1));
        int j = 0;
        // System.out.println("Column name=" +cells.get(0));
        if (errorList.isEmpty()) {
            for (int i = 1; i < n; i++) {
                k = Insert(cells_srno.get(i), cells_name.get(i),
                        cells_dob.get(i), cells_gender.get(i),
                        cells_address.get(i), cells_pin.get(i),
                        cells_mob.get(i), cells_eId.get(i),
                        cells_category.get(i), cells_branch.get(i));
                if (k > 0)
                    j++;

            }

        } else {
            System.out.println("Error");
        }

        /*
         * System.out
         * .println("Total no. of physical row in you Excel Sheet=" + j);
         * System.out
         * .println("Operation Successfull!! kindly check the database!!! "
         * );
         */

    } catch (Exception e) {
        e.printStackTrace();
    }
    return errorList;
}

public ArrayList getList（字符串路径、字符串srnoStr、，
字符串nameStr、字符串dobStr、字符串genderStr、字符串addressStr、，
字符串pinStr、字符串mobStr、字符串eIdStr、字符串categoryStr、，
字符串branchStr）抛出IOException、SQLException{
ArrayList errorList=新建ArrayList（）；
ArrayList cellError=null；
//字符串错误=null；
//OrderedMap errorMap=新建LinkedMap（）；
//errorMap=null；
列表单元格\u srno=new ArrayList（）；
列表单元格_name=new ArrayList（）；
List cells_dob=new ArrayList（）；
List cells_gender=new ArrayList（）；
列表单元格\u地址=新的ArrayList（）；
List cells_pin=new ArrayList（）；
List cells_mob=new ArrayList（）；
List cells_eId=new ArrayList（）；
List cells_category=new ArrayList（）；
List cells_branch=new ArrayList（）；
试一试{
int srnoIndex=0；
srnoIndex=getIndex（srno，path）；
cellError=fillList（srnoIndex、srNoId、cells\u srno、path）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
int nameIndex=0；
nameIndex=getIndex（名称、路径）；
cellError=fillList（名称索引、名称ID、单元格名称、路径）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
int-dobIndex=0；
dobIndex=getIndex（dob，路径）；
cellError=fillList（dobIndex、dobId、cells\u dob、path）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
int-genderIndex=0；
genderIndex=getIndex（性别，路径）；
cellError=fillList（genderIndex、genderId、cells\u-gender、path）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
int addressIndex=0；
addressIndex=getIndex（地址、路径）；
cellError=fillList（地址索引、地址ID、单元格地址、路径）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
int-pinIndex=0；
pinIndex=getIndex（pin，路径）；
cellError=fillList（pinIndex、mobId、cells\u-pin、path）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
指数=0；
mobIndex=getIndex（mob，path）；
cellError=fillList（mobIndex、pinId、cells\u mob、path）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
指数=0；
eIdIndex=getIndex（eId，路径）；
cellError=fillList（eIdIndex，eIdId，cells_-eId，path）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
int categoryIndex=0；
categoryIndex=getIndex（类别，路径）；
cellError=fillList（categoryIndex、categoryId、cells\u category、，
路径）；
if（cellError！=null）
errorList.addAll（cellError）；
cellError=null；
int-branchIndex=0；
branchIndex=getIndex（分支，路径）；
cellError=fillList（branchIndex、branchId、cells\u branch、path）；
if（cellError！=null）
errorList.addAll（cellError）；
//系统输出打印项次（单元格）；
int n=单元格大小（）；
int k=0；
System.out.println（“总行数=”+（n-1））；
int j=0；
//System.out.println（“Column name=“+cells.get（0））；
if（errorList.isEmpty（））{
对于（int i=1；i0）
j++；
}
}否则{
System.out.println（“错误”）；
}
/*
*系统输出
*.println（“Excel工作表中的物理行总数=”+j）；
*系统输出
*.println（“操作成功！！请检查数据库！！！”
* );
*/
}捕获（例外e）{
e、 printStackTrace（）；
}
返回错误列表；
}

我将使用

映射

和

枚举

作为键，并进行如下重构：

public List<String> getList(final String path, final Map<CellType, String> data) {
    final Map<CellType, List<Cell>> cells = new EnumMap<CellType, List<Cell>>();
    for (final CellType cellType : CellType.values()) {
        cells.put(cellType, new ArrayList<Cell>());
    }

    final List<String> errorList = new ArrayList<String>();
    try {
        for (final CellType cellType : data.keySet()) {
            final int index = getIndex(data.get(cellType), path);
            final List<String> cellError = fillList(index, /* the ID for cellType */, cells.get(cellType), path);
            if (cellError != null) {
                errorList.addAll(cellError);
            }
        }

        // ... (use the map)
    } catch (final Exception e) {
        e.printStackTrace();
    }

    return errorList;
}

public static enum CellType {
    SRNO, NAME, DOB // ...
}

public List getList（最终字符串路径、最终地图数据）{
最终映射单元格=新的EnumMap（）；
对于（最终CellType CellType:CellType.values（））{
cells.put（cellType，newarraylist（））；
}
最终列表errorList=新的ArrayList（）；
试一试{
for（最终CellType CellType:data.keySet（））{
final int index=getIndex（data.get（cellType），path）；
最终列表cellError=fillList（索引，/*cellType*/的ID，cells.get（cellType），path）；
if（cellError！=null）{
errorList.addAll（cellError）；
}
}
//…（使用地图）
}捕获（最终异常e）{
e、 printStackTrace（）；
}
返回错误列表；
}
公共静态枚举单元类型{
SRNO，NAME，DOB/。。。
}

（未测试）

---

注意：

srNoId

，

nameId

等在您发布的代码中没有定义，因此我不知道它们是什么如果内存不足是问题，我认为您的方法不是很好。您应该通过流媒体减少内存占用，