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的首部，這樣就避免了數組元素過多，爆棧了。