Java 从数组列递归获取字符串

我有一个对象数组。每个数组元素的内容可以是字符串，也可以是另一个带有字符串的数组。也可以是包含字符串的数组数组

例如：

Object obj1 = array[[str1, str2, str3], [str4, str5]] 

or: Object obj2 =array [str1, str2]

or: Object obj3 = "this string"

我需要一个将这个对象作为参数的方法，如果它是前两种情况之一，则返回包含这些元素的单个数组。若这是最后一种情况，它将返回一个数组，其中包含一个字符串元素，该元素作为param传入

所以，如果我这样做了

getDataForColumn(obj1) i get array: [str1, str2. str3....str5]
getDataForColumn(obj2) i get array: [str1, str2] //same as input, i know
getDataForColumn(obj3) i get array: ["this string"]     

我正在尝试，但我真的不知道如何用递归实现这一点，也不可能，至少以这种方式

这就是我想出来的，并且被卡住了

private static Object[] getDataForColumn(Object column) {

if(column instanceof Object[]){
    Object[] castarray = (Object[])column;
        Object[]newArray = new Object[castArray.length];

    for (int i = 0; i < castarray.length; i++) {

              if((castarray[i] instanceof Object[])){
                 //recursion, but how :D    
                  }
               else{
                        newArray[i] = castArray[i];     
        }
    }
      return newArray;
   }    
 return new array with object that came in.....
}

私有静态对象[]getDataForColumn（对象列）{
if（对象[]的列实例）{
对象[]数组=（对象[]）列；
Object[]newArray=新对象[castArray.length]；
对于（int i=0；i

请帮忙。

---

Thanx

我建议使用ArrayList按顺序将所有展开的数组添加到一起。您可以创建一个数组来合并当前的“结果”-数组和递归调用返回的数组，但是使用ArrayList会更容易。这样，您就不必迭代两个数组并将它们放在一个数组中

private static Object[] getDataForColumn(Object column) {
ArrayList results = new ArrayList();

if(column instanceof Object[]){

    Object[] castarray = (Object[])column;

    for (int i = 0; i < castarray.length; i++) {

          if((castarray[i] instanceof Object[])){
             results.addAll(Arrays.asList(getDataForColumn(castarray[i])))    
           }
           else{
             results.add(castarray[i]);    
           }
    }
    return results.toArray();
}

私有静态对象[]getDataForColumn（对象列）{
ArrayList结果=新建ArrayList（）；
if（对象[]的列实例）{
对象[]数组=（对象[]）列；
对于（int i=0；i

我没有测试这个，但我认为应该可以

---

希望能有所帮助。

我建议使用ArrayList将所有展开的数组按顺序添加到一起。您可以创建一个合并当前“结果”的数组-数组和递归调用返回的数组，但使用ArrayList更容易。这样，您不必迭代两个数组并将它们放在一个数组中

private static Object[] getDataForColumn(Object column) {
ArrayList results = new ArrayList();

if(column instanceof Object[]){

    Object[] castarray = (Object[])column;

    for (int i = 0; i < castarray.length; i++) {

          if((castarray[i] instanceof Object[])){
             results.addAll(Arrays.asList(getDataForColumn(castarray[i])))    
           }
           else{
             results.add(castarray[i]);    
           }
    }
    return results.toArray();
}

getDataFromColumn(Object column) {
  List<String> list = new LinkedList<String>();
  recGetData(column,list);
  return list.toArray();
}
public void recGetData(Object column,List<String> list) {
  if (column instanceof String) {
     list.add((String)column);
  } else {
     for (Object o : (Object[])column) { 
      recGetData(o,list);
     }
  }
}

私有静态对象[]getDataForColumn（对象列）{
ArrayList结果=新建ArrayList（）；
if（对象[]的列实例）{
对象[]数组=（对象[]）列；
对于（int i=0；i

我没有测试这个，但我认为应该可以

希望对您有所帮助。

getDataFromColumn（对象列）{
getDataFromColumn(Object column) {
  List<String> list = new LinkedList<String>();
  recGetData(column,list);
  return list.toArray();
}
public void recGetData(Object column,List<String> list) {
  if (column instanceof String) {
     list.add((String)column);
  } else {
     for (Object o : (Object[])column) { 
      recGetData(o,list);
     }
  }
}

列表=新建LinkedList（）；
记录数据（列、列表）；
return list.toArray（）；
}
public void recGetData（对象列，列表）{
if（字符串的列实例）{
添加（（字符串）列）；
}否则{
对于（对象o:（对象[]）列）{
记录数据（o，列表）；
}
}
}

希望这就是你的意思。
尚未对其进行测试，但应能正常工作….

getDataFromColumn（对象列）{
列表=新建LinkedList（）；
记录数据（列、列表）；
return list.toArray（）；
}
public void recGetData（对象列，列表）{
if（字符串的列实例）{
添加（（字符串）列）；
}否则{
对于（对象o:（对象[]）列）{
记录数据（o，列表）；
}
}
}

希望这就是你的意思。

---

还没有测试它，但应该可以使用…

这里有一个简单的方法。我使用列表是因为我更喜欢在数组上使用它，但当然，您可以制作一个包装器，最终将其转换为数组：

public static List<String> flat(Object o)
{
    List<String> strings = new ArrayList<String>();
    if (o.getClass().isArray())
    {
        Object[] oarr = (Object[]) o;
        for (Object obj : oarr)
        {
            strings.addAll(flat(obj));
        }
    }
    else
    {
        strings.add(o.toString());
    }
    return strings;
}

公共静态列表平面（对象o）
{
列表字符串=新的ArrayList（）；
if（o.getClass（）.isArray（））
{
对象[]oarr=（对象[]）o；
用于（对象对象对象：oarr）
{
strings.addAll（flat（obj））；
}
}
其他的
{
add（o.toString（））；
}
返回字符串；
}

这里有一个简单的方法。我使用List是因为我更喜欢在数组中使用它，但当然，您可以制作一个包装器，最终将其转换为数组：

public static List<String> flat(Object o)
{
    List<String> strings = new ArrayList<String>();
    if (o.getClass().isArray())
    {
        Object[] oarr = (Object[]) o;
        for (Object obj : oarr)
        {
            strings.addAll(flat(obj));
        }
    }
    else
    {
        strings.add(o.toString());
    }
    return strings;
}

公共静态列表平面（对象o）
{
列表字符串=新的ArrayList（）；
if（o.getClass（）.isArray（））
{
对象[]oarr=（对象[]）o；
用于（对象对象对象：oarr）
{
strings.addAll（flat（obj））；
}
}
其他的
{
add（o.toString（））；
}
返回字符串；
}

是的，这是可能的，也许不是最好的方法

private static Object[] getDataForColumn(Object column) {
    if(column instanceof Object[]){
       Object[] castarray = (Object[])column;
       Object[] newArray = new Object[castArray.length];

       for (int i = 0; i < castarray.length; i++) {
          newArray[i] = getDataForColumn(castarray[i]);
       }

    } else {
       String[] newArray = {column};
    }
    return newArray;
}

私有静态对象[]getDataForColumn（对象列）{
if（对象[]的列实例）{
对象[]数组=（对象[]）列；
Object[]newArray=新对象[castArray.length]；
对于（int i=0；i

---

我没有测试它，但我希望这会给你一个想法

是的，这是可能的，也许不是最好的方法

private static Object[] getDataForColumn(Object column) {
    if(column instanceof Object[]){
       Object[] castarray = (Object[])column;
       Object[] newArray = new Object[castArray.length];

       for (int i = 0; i < castarray.length; i++) {
          newArray[i] = getDataForColumn(castarray[i]);
       }

    } else {
       String[] newArray = {column};
    }
    return newArray;
}

私有静态对象[]getDataForColumn（对象列）{
if（对象[]的列实例）{
对象[]数组=（对象[]）列；
Object[]newArray=新对象[castArray.length]；
对于（int i=0；i

我没有测试它，但我希望这会让你了解这是什么语言，C#？哦，等等……instanceof不是C#关键字……也许是Java？可以吗