java语言 flatten（Object[] objs）{} 方法

flatten() 我自己理解就是一个将N维数组压成一个一维数组并返回的东西，

private static Object[] flatten(Object[] objs) {
        LinkedList<Object> list = new LinkedList<Object>(),
                           slist = new LinkedList<Object>(); 

        Collections.addAll(list, objs);

        Object end = new Object(); 
        int id = end.hashCode();
        list.addLast(end);

        while(list.getFirst().hashCode() != id) {

            if( list.getFirst() instanceof Object[]) {

                Object[] first = (Object[])list.removeFirst();

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

                    if(first[i] instanceof Object[]) {

                        for(int j = i; i < first.length; ++i) {

                            list.addFirst(
                            first[first.length - 1 - (i - j)]); 
                        }
                    } 

                    else slist.addLast(first[i]);
                }       
            } 

            else {

                slist.addLast(list.getFirst());

                list.removeFirst();
            }
        }

        return slist.toArray();

    }

具体的想法就是，给你一串Object[] 数组(标记list1)，这里面可能包含多重嵌套的数组，
例如： [“ssss”, 1, 2, [123, 355, “ssss”], 1, 45]
现在要求输出的要求输出的顺序是：
“ssss”, 1, 2, 123, 355, “ssss”, 1, 45
这时候，你可以用一个LinkedList（标记list2）来保存Object[] 数组，然后
1.每次从首部取list1数组的第一个元素，遍历，
2.如果不是数组，就放在list2里面，
3.如果是数组就放在首部，继续执行第一步
这样就能保证，如果list1取出来的第一个元素还是数组的话就继续遍历，直到不是数组为止，这样在list2中的元素的顺序就得到了保证，返回的就是一个正确的顺序。

要说技巧的话，就是第二步里面，如果是数组的话，就马上结束对list1的遍历，并且将得到的这个子数组放回 list1的首部，这样就避免了数组元素过多，爆栈了。