Conversion of an ArrayList<ArrayList<Integer>> to List<List<Integer>>

Question

I was doing a little coding challenge at work and we were required to perform quite a bit of business logic that result in a List of Lists of Integers. I had the required information in an ArrayList of ArrayList of Integers, but could never figure out how to convert it to the correct return type.

Also many variations on using T or Object as they types. I've searched stack overflow and there are many similar problems, but none that give me a straight answer; they're more conceptual.

Problem to answer: The output MUST be a

    List<List<Integer>> (not negotiable).

Given an existing:

    ArrayList<ArrayList<Integer>> **currentArrayList** HOW do you convert that to a List<List<Integer>>.

I no longer need the code, but It's going to drive me nuts to be able to do all the logic but not a simple type conversion.

List<List<Integer>> returnList(){
    ArrayList<ArrayList<Integer>> currentArrayList = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> innerList = new ArrayList<Integer>();
    innerList.add(new Integer(123));
    currentArrayList.add(innerList);
    List<List<Integer>> newList = ????
    // ??Logic to copy over currentArrayList into newList???
    return newList;
}

What makes you think you should be able to do this conversion? A List<ArrayList<Integer>> isn't a List<List<Integer>>. — VeeArr
– VeeArr, Commented Jul 24, 2018 at 21:36
@shmosel That's certainly true; I just wanted to point out that there won't be a way to do so that's necessarily type-safe, similar to how casting an Object to a specific subclass wouldn't be (though not for the same reasons). — VeeArr
– VeeArr, Commented Jul 24, 2018 at 21:39
You don't have to cast. You can copy them to a new list: List<List<Integer>> newList = new ArrayList<>(currentArrayList); — shmosel
– shmosel, Commented Jul 24, 2018 at 21:41

Glains · Accepted Answer · 2018-07-24 22:09:34Z

1

You should work against interfaces and remove extact implementation detail. In your example, use a reference to List<List<Integer> instead, since you can add any List implementation to it, including your ArrayList.

public List<List<Integer>> returnList(){
    List<List<Integer>> currentList = new ArrayList<>();
    List<Integer> innerList = new ArrayList<>();
    innerList.add(123);
    currentList.add(innerList);
    return currentList;
}

If you need to return a new List, simply wrap it into another one:

return new ArrayList<>(currentList);

Alternatively, make the returned List unmodifiable:

return Collections.unmodifiableList(currentList);

Edit

If you are really stuck using ArrayList you can cast it to a List with

return (List) currentArrayList;

This cast throws a compiler warning, but you can ignore it with @SuppressWarnings("unchecked") since you know that the correct type is returned.

edited Jul 24, 2018 at 22:09

answered Jul 24, 2018 at 21:50

Glains

2,8833 gold badges19 silver badges32 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

cybersam Over a year ago

Typo: currentArray should be currentList.

lealceldeiro · Accepted Answer · 2018-07-25 12:32:02Z

1

Just change the declaration type like this since ArrayList extends from AbstractList which implements List:

List<List<Integer>> returnList(){
    List<List<Integer>> currentArrayList = new ArrayList<>();
    List<Integer> innerList = new ArrayList<>();
    innerList.add(new Integer(123));
    currentArrayList.add(innerList);
    return currentArrayList;
}

Running example on GitHub

edited Jul 25, 2018 at 12:32

answered Jul 24, 2018 at 21:38

lealceldeiro

15.1k7 gold badges54 silver badges85 bronze badges

4 Comments

Luke Hollenback Over a year ago

This is the right way to do it from the beginning, but if legacy code is being worked on, it might not be easily possible to go back and declare it simply as a List of Lists.

Glains Over a year ago

@Treebasher I suppose a little coding challenge is not legacy code and the methods return type does not get modified here, only implementation detail.

Glains Over a year ago

@lealceldeiro As i stated in my answer, you should probably change ArrayList<Integer> innerList = new ArrayList<>() to List<Integer> innerList = new ArrayList<>(); as well.

lealceldeiro Over a year ago

@Glains sure! That was my intention from the beginning. I totally missed that one :) Thank you very much for pointing that out!

Luke Hollenback · Accepted Answer · 2018-07-24 21:49:48Z

0

If you are okay with suppressing unchecked cast warnings, its as simple as:

@SuppressWarnings("unchecked")
private static List<List<Integer>> convertToInterfaceVersion(ArrayList<ArrayList<Integer>> original) {
  return (List) original;
}

This is possible because List is just an interface which ArrayList ultimately implements. But this is also a prime example of why people usually don't declare their ArrayLists explicitly as ArrayLists, but rather just as Lists—it completely prevents this situation in the first place.

answered Jul 24, 2018 at 21:49

Luke Hollenback

7916 silver badges16 bronze badges

Comments

Soner from The Ottoman Empire · Accepted Answer · 2018-07-24 22:05:56Z

Rule of thumb: Always try coding to an interface.

If you are not the beginning of the code, that is, there is no chance to change the return type, you can use the following, it uses ctor of ArrayList to copy passed List

List<List<Integer>> returnList() {
   ArrayList<ArrayList<Integer>> currentArrayList = new ArrayList<>();
   ArrayList<Integer> innerList = new ArrayList<>();
   innerList.add(123);
   currentArrayList.add(innerList);
   List<List<Integer>> newList = new ArrayList<>(currentArrayList);
   return newList;
}

Otherwise, if there is chance to change its return type, just alter the declaration type to List<List<Integer>>, it applies the rule of thumb.

List<List<Integer>> returnList() {
   List<List<Integer>> currentArrayList = new ArrayList<>();
   List<Integer> innerList = new ArrayList<>();
   innerList.add(123);
   currentArrayList.add(innerList);
   return currentArrayList;
}

Johannes Kuhn · Accepted Answer · 2018-07-25 02:08:02Z

As others mentioned, program to an interface.

Your one-line solution is:

List<List<Integer>> newList = Collections.unmodifiableList(currentArrayList);

But this has an obvious downside:
You can not add new elements to it.

It makes sense if you think about it.
While you could add a LinkedList<Integer> to a List<List<Integer>>, you can not add a LinkedList<Integer> to a List<ArrayList<Integer>>.

If you need the ability to modify the list, then you can create a new List:

List<List<Integer>> newList = new ArrayList<>(currentArrayList);

This means that the outer list is copied.

There is a last solution that you should not take, and is using a raw type:

List<List<Integer>> newList = (List) currentArrayList;

While this will compile, it can break later if someone adds e.g. a LinkedList<Integer> into that list, while you still expect every element in that list to be an ArrayList<Integer>

Collectives™ on Stack Overflow

Conversion of an ArrayList<ArrayList<Integer>> to List<List<Integer>>

5 Answers 5

1 Comment

4 Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

4 Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related