Type-safe, bonus unit test.

   import org.junit.Test;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.List;
   import java.util.stream.Collectors;
   import java.util.stream.Stream;
   
   import static junit.framework.TestCase.assertEquals;
   
   public class FlattenList {
   
       @Test
       public void test() {
           // [1, [2, 3], [4, [5, 6]], [7, [8, [9, 10]]]]
           final FlattenableList<Integer> list = new FlattenableList<>();
           list.add(new SingleFlattenable<>(1));
   
           list.add(new ListOfSingles<>(Arrays.asList(2, 3)));
   
           list.add(new Flattenable<Integer>(){{
               add(new SingleFlattenable<>(4));
               add(new ListOfSingles<>(Arrays.asList(5, 6)));
           }});
   
           list.add(new Flattenable<Integer>(){{
               add(new SingleFlattenable<>(7));
               add(new Flattenable<Integer>(){{
                   add(new SingleFlattenable<>(8));
                   add(new ListOfSingles<>(Arrays.asList(9, 10)));
               }});
           }});
   
           assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), list.flatten());
       }
   
       public static class FlattenableList<T> {
   
           final List<Flattenable<T>> list = new ArrayList<>();
   
           void add(final Flattenable<T> item) {
               list.add(item);
           }
   
           List<T> flatten() {
               return list.stream().flatMap(Flattenable::flatten).collect(Collectors.toList());
           }
   
       }
   
       private static class Flattenable<T> {
   
           final List<Flattenable<T>> contents = new ArrayList<>();
   
           Stream<T> flatten() {
               return contents.stream().flatMap(Flattenable::flatten);
           }
   
           void add(final Flattenable<T> content) {
               contents.add(content);
           }
   
       }
   
       private static class ListOfSingles<T> extends Flattenable<T> {
   
           final List<T> list;
   
           ListOfSingles(final List<T> list) {
               this.list = list;
           }
   
           @Override
           Stream<T> flatten() {
               return list.stream();
           }
   
       }
   
       private static class SingleFlattenable<T> extends Flattenable<T> {
   
           final T item;
   
           SingleFlattenable(final T item) {
               this.item = item;
           }
   
           @Override
           Stream<T> flatten() {
               return Stream.of(item);
           }
   
       }
   
   }