如何扁平化数组并摆脱null？

Question

I am trying to take an arbitrarily deep-nested array and flatten the array, as well as get rid of any null objects in the array.

For example I want to be able to input a nested array like [1, 5, [[6, 4], 91, 12, null, [[null]]], -2] and return a one-dimensional array without any null values. How would I go about solving this?

I provided my solution below, but I keep getting an

I cannot be cast to java.lang.Integer error.

public static void main(String[] args) {
    int[][] numbers = {null, {4, 5, 6},{3, 1, 10}, {4, 2, 9}, null, null};
    flatten(numbers);
}

public static ArrayList<Integer> flatten(Object[] nestedNumbers) {
    if (nestedNumbers == null) return null;
    ArrayList<Integer> flattenedNumbers = new ArrayList<>();
    for (Object element : nestedNumbers) {
        if (element != null) {
            flattenedNumbers.add((Integer)element);
        } 
    }
    return flattenedNumbers;
 }

Answer 1

A possible solution using the Stream API introduced in Java 8 is the following:

public static int[] flatten(Object[] array) {
    return Arrays.stream(array)
                 .filter(Objects::nonNull)
                 .flatMapToInt(a -> {
                    if (a instanceof Object[]) return Arrays.stream(flatten((Object[]) a));
                    return Arrays.stream((int[]) a);
                 })
                 .toArray();
}

The first point to consider is that an int[] is not an Object[] . So, this method accepts a Object[] to represent that it can be given any type of integer array with at least 2 dimensions, ie int[][] , up to any number of dimensions. It filters out null elements, with the Objects::nonNull predicate.

Then the magic happens: the Stream<Object> , returned by Arrays.stream(array) , is flat mapped to an IntStream : if the elements inside it are Object[] , then it means that we still have more than 2 dimensions, and the method is recursively calling itself. On the other hand, if we have an instance of int[] , then we can just replace it with a Stream of that.

Example calling code:

public static void main(String[] args) {
    int[][][] numbers = {null, {{4}, {5}, {6,1}},{{3,2}, {1}, {10}}, {{4,1}, {2,3}, {9,8}}, null, null};
    int[] flat = flatten(numbers);
    System.out.println(Arrays.toString(flat));
}

Of course, this method doesn't accept int[] , which would be the case where is nothing to flatten (and nothing to filter since int can't be null ).

Answer 2

One of simplest (but not necessary fastest) solution could be to:

• generate string which will represent your array ( Arrays.deepToString can be helpful here) like

   "[null, [4, 5, 6], [3, 1, 10], [4, 2, 9], null, null]" 

• remove from it characters like [ ] ,

• split on spaces
• iterate over received array to
  • filter all "null" strings
  • convert non-null strings to numeric type of your choice and add it to result list.

In short your solution could look like (I am assuming you are allowed to use Java 8)

public static List<Integer> flatten(Object[] nestedNumbers) {
    String text = Arrays.deepToString(nestedNumbers);
    System.out.println(text);
    return Stream.of(text.replaceAll("\\[|\\]|,", "").split("\\s+"))
        .filter(s->!s.equals("null"))
        .map(Integer::parseInt)
        .collect(Collectors.toList());
}

---

In case you want to split floating point numbers and your locale is also using , as decimal mark 1,25 you would need to decide which , we should remove and which , is part of number and should stay. For such case solution could be removing , which has space after it (but we don't want to remove that space because we need it in split ). Since replaceAll is using regex we can use look-ahead (?=...) mechanism which will allow us to test part after current match, but not include that tested part in match.

So we would need to replaceAll("\\\\[|\\\\]|,(?=\\\\s)","") which will ensure that removed , must have space after it, but will not remove that space.