返回列表中的最后一项

Question

I am returning the last item in the list. One or many of the sub-lists may be null or empty. If there are zero items in the list, return null. Note if the actual item is null, return null anyway. For example, in [[10,20], [40,null]]. For basic test, you may assume, neither the list or any sublist or any item in the sub-lists is null.

public static Integer getLastItem(ArrayList<ArrayList<Integer>> list) {
    if (list == null) {
        return null;
    }
    Integer last = null;
    for (ArrayList<Integer> data : list) {
        for (Integer o : data) {
            if (!o.equals(null)) {
                last = o;
            }
        }
    }
    return last;
}

Some reason my code is not passing the comprehensive test and gets stuck at line: assertEquals(null, ListOfListService.getLastItem(list4_nullItems)). I have been working on it for quite some time and cannot figure it out. The rest of the test is.

@Test @Graded(description="GetLastItemComprehensive", marks=4)
public void testGetLastItemComprehensive() {
    testGetLastItemBasic();
    assertEquals(null, ListOfListService.getLastItem(null));
    assertEquals(null, ListOfListService.getLastItem(list4_nullItems));
    list4_nullItems.get(5).set(2, 24);
    assertEquals(Integer.valueOf(24), ListOfListService.getLastItem(list4_nullItems));

    ArrayList<ArrayList<Integer>> allEmptyOrNull = new ArrayList<ArrayList<Integer>>();
    allEmptyOrNull.add(null);
    allEmptyOrNull.add(new ArrayList<Integer>());
    allEmptyOrNull.add(null);
    allEmptyOrNull.add(new ArrayList<Integer>());
    assertEquals(null, ListOfListService.getLastItem(allEmptyOrNull));
    currentMethodName = new Throwable().getStackTrace()[0].getMethodName();
}

Answer 1

One thing that immediately caught my eye was the following line:

if (!o.equals(null)) {
    //...
}

o.equals(null) will never return true. If o is null, a NullPointerException will be thrown instead because you're trying to invoke a method on a null object.

To fix this, you can simply replace the expression inside the if-statement with the following line:

if (o != null) {
    //...
}

This will safely compare o to null without throwing a NullPointerException .

Edit: As @AlexShesterov pointed out, this will still result in a NullPointerException if the list that is passed as an argument to getLastItem contains a null-element. The simplest way to resolve that would be check if data is null before iterating over its elements:

for (ArrayList<Integer> data : list) {
    if (data != null) {
        for (Integer o : data) {
            // ...
        }
    }
}

One solution that might be considered a bit cleaner would be the following:

public static Integer getLastItem(ArrayList<ArrayList<Integer>> list) {
    if (list == null) {
        return null;
    }
    // loop over each data ArrayList in reversed order
    for (int i = list.size() - 1; i >= 0; i--) {
        final ArrayList<Integer> data = list.get(i);
        // skip null elements
        if (data == null) {
            continue;
        }
        // loop over each Integer in data in reversed order
        for (int j = data.size() - 1; j >= 0; j--) {
            final Integer o = data.get(j);
            // the first Integer that was found will be the the last non-null
            // entry of the last non-null data list
            if (o != null) {
                return o;
            }
        }
    }

    // if this place is reached, no element was found, so null should be returned
    return null;
}

This way has two deciding advantages:

• you don't have to loop over the the whole list each time this method is called, which improves performance for large lists
• you avoid reassignment, so the code will be easier to debug

Once again thanks to @AlexShesterov for motivating me to write that last abstract.

Answer 2

You may use flatMap() to flatten your ArrayList, skip all elements and get only the last one.

Note: Optional is used to handle if last element is null and code should not throw a NullPointerException.

public static Integer fetchLastItem(ArrayList<ArrayList<Integer>> list) {
    if (list == null) {
        return null;
    }

    long size = list.stream().flatMap(l -> l.stream()).count();
    Optional<Integer> last = list.stream()
            .flatMap(l -> l.stream())
            .map(Optional::ofNullable)
            .skip(size - 1)
            .findFirst()
            .orElse(null)
             ;

    return last.orElse(null);
}