如何嵌套列表转换成多维数组？ [英] How to convert nested List into multidimensional array?

问题描述

在Java的我想转换一个嵌套的列表这在最深层次包含了一个统一的类型到该类型的多维数组。例如，的ArrayList＆LT; ArrayList的＆LT; ArrayList的＆LT; ArrayList的＆LT;弦乐＆GT;＆GT;＆GT;＆GT; 到的String [] [] [] [] 。我试过几件事情，我只能获得对象的数组，如对象[] [] [] [] 。对于简单列表似乎阿帕奇共享郎做的工作，但我想不出嵌套的情况。

更新：

为了获得Object类型的多维数组我使用一个递归函数，所以我不能使用设置的toArray密钥类型（）见摘录：

  //这个函数的参数是一个（嵌套）名单
公共静态对象转换（Object对象）{    [对象]结果= NULL;
    列表列表=（列表）对象;
    如果（名单！= NULL）{        对象类型= getElementType（名单）;
        如果（键入的instanceof名单）{            INT大小=则为list.size（）;
            结果=新对象[大小]
            对于（INT计数器= 0;反＆LT;大小;反++）{                Object元素= list.get（柜）;
                结果[窗口] =（元素！= NULL）？转换（元）：空;
            }
        }其他{
            结果= list.toArray（）;
        }
    }    返回结果;
}私有静态对象getElementType（名单列表）{    对象result = NULL;
    对于（Object元素：名单）{
        如果（元素！= NULL）{            结果=元素;
            打破;
        }
    }    返回结果;
}
 

解决方案

这是有人建议解决的字符串方式键入。 硬脂酸钙（列表＆LT;＆GT;）返回多维数组。它可以被推广到使用类类型作为参数。谢谢您的意见。

 静态INT DIMENSION2（Object对象）{    INT结果为0;
    如果（对象的instanceof名单＆LT;＆GT;）{        结果++;
        清单＆LT;＆GT;名单=（列表＆LT;＆GT;）对象;
        对于（Object元素：名单）{
            如果（元素！= NULL）{
                结果+ = DIMENSION2（元）;
                打破;
            }
        }
    }    返回结果;
}
静态对象硬脂酸钙（列表＆LT;＆GT; L）{    INT昏暗= DIMENSION2（L）;
    如果（昏暗== 1）{
        返回l.toArray（新的String [0]）;
    }    INT []变暗=新INT [DIMENSION2（L）];
    变暗[0] = l.size（）;
    对象A = Array.newInstance（为String.class，变暗）;
    的for（int i = 0; I＆LT; l.size（）;我++）{        清单＆LT;＆GT; E =（列表＆LT;＆GT;）l.get（I）
        如果（E == NULL）{
            Array.set（A，I，NULL）;
        }否则如果（DIMENSION2（E）→1）{
            Array.set（A，I，硬脂酸钙（e）条）;
        }其他{
            Array.set（A，I，e.toArray（新的String [0]））;
        }
    }
    返回;
}
 

In Java I want to convert a nested List which contains at the deepest level a uniform type into an multidimensional array of that type. For example, ArrayList<ArrayList<ArrayList<ArrayList<String>>>> into String[][][][]. I've tried several things and I only can obtain an array of objects like Object[][][][]. For 'simple lists' it seems that Apache Commons Lang does the work but I cannot figure out for nested cases.

Update:

In order to obtain a multidimensional array of Object type I'm using a recursive function so I cannot set the key type using toArray() see excerpt:

// the argument of this function is a (nested) list
public static Object convert(Object object) {

    Object[] result = null;
    List list = (List) object;
    if (list != null) {

        Object type = getElementType(list);
        if (type instanceof List) {

            int size = list.size();
            result = new Object[size];
            for (int counter = 0; counter < size; counter++) {

                Object element = list.get(counter);
                result[counter] = (element != null) ? convert(element) : null;
            }
        } else {
            result = list.toArray();
        }
    }

    return result;
}

private static Object getElementType(List list) {

    Object result = null;
    for (Object element : list) {
        if (element != null) {

            result = element;
            break;
        }
    }

    return result;
}

解决方案

This is the way that someone suggested to solved for String type. Cast2(List<?>) returns the multidimensional array. It may be generalized to use the class type as parameter. Thank you for your comments.

static int dimension2(Object object) {

    int result = 0;
    if (object instanceof List<?>) {

        result++;
        List<?> list = (List<?>) object;
        for (Object element : list) {
            if (element != null) {
                result += dimension2(element);
                break;
            }
        }
    }

    return result;
}


static Object cast2(List<?> l) {

    int dim = dimension2(l);
    if (dim == 1) {
        return l.toArray(new String[0]);
    }

    int[] dims = new int[dimension2(l)];
    dims[0] = l.size();
    Object a = Array.newInstance(String.class, dims);
    for (int i = 0; i < l.size(); i++) {

        List<?> e = (List<?>) l.get(i);
        if (e == null) {
            Array.set(a, i, null);
        } else if (dimension2(e) > 1) {
            Array.set(a, i, cast2(e));
        } else {
            Array.set(a, i, e.toArray(new String[0]));
        }
    }
    return a;
}

这篇关于如何嵌套列表转换成多维数组？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！