Convert two dimensional array to List in java?

Question

I have am X n two dimensional array of an Object say Foo. So I have Foo[][] foosArray. What is the best way to convert this into a List<Foo> in Java?

Which order do you want the elements to appear in, or do you want a list of lists? — vaughandroid, Jul 12 '12 at 08:25
Please go through this--- http://stackoverflow.com/questions/11326038/all-possible-combinations-of-a-2d-array — Kumar Shorav, Jul 12 '12 at 08:32
@Subhra You still haven't told us what sort of list you want at the end of this. Do you want a `List`, a `List>`, a `List`, or something else? — vaughandroid, Jul 12 '12 at 08:37
@Baqueta I edited the question . Actually the 'backticks' were missing. — Inquisitive, Jul 12 '12 at 08:40

score 40 · Accepted Answer · answered Jul 12 '12 at 08:37

40

This is a nice way of doing it for any two-dimensional array, assuming you want them in the following order:

[[array[0]-elems], [array[1]elems]...]

public <T> List<T> twoDArrayToList(T[][] twoDArray) {
    List<T> list = new ArrayList<T>();
    for (T[] array : twoDArray) {
        list.addAll(Arrays.asList(array));
    }
    return list;
}

answered Jul 12 '12 at 08:37

Keppil

45,603
8
97
119

2

But what if I want to convert a 2D array(```String[][] arr```) as 2D ArrayList, something like ```ArrayList> list; ``` ? – Saurav Shrivastav Feb 20 '22 at 14:33

score 22 · Answer 2 · edited Jun 03 '17 at 22:52

22

Since java-8

List<Foo> collection = Arrays.stream(array)  //'array' is two-dimensional
    .flatMap(Arrays::stream)
    .collect(Collectors.toList());

edited Jun 03 '17 at 22:52

Jeffmagma

452
2
8
20

answered May 28 '16 at 11:32

Tomasz Mularczyk

34,501
19
112
166

2

I want to convert int [ ] [ ] array to List< List >. I get an error - Bad return type in method reference: cannot convert java.util.stream.IntStream to java.util.stream.Stream>. How do I fix this ? – MasterJoe Jul 18 '20 at 06:21

score 19 · Answer 3 · edited Nov 19 '21 at 20:57

19

This can be done using Java 8 stream API this way:

String[][] dataSet = new String[][] {{...}, {...}, ...};
List<List<String>> list = Arrays.stream(dataSet)
                               .map(Arrays::asList)
                               .collect(Collectors.toList());

Basically, you do three things:

Convert the 2-d array into stream
Map each element in stream (which should be an array) into a List using Arrays::asList API
Reduce the stream into a new List

edited Nov 19 '21 at 20:57

1000Nettles

2,314
3
22
31

answered Jul 27 '16 at 06:50

nybon

8,894
9
59
67

2

I want to convert int [ ] [ ] array to List< List >. I get an error - Required type: List> Provided:List>. How do I fix this ? – MasterJoe Jul 18 '20 at 06:16
1

You cannot convert array type int. You must have the array of type Integer. To stream it to List – Sunandan Bose Oct 15 '20 at 17:26
Please check my solution – Sergey Afinogenov Feb 07 '21 at 09:43

Dmitry Zaytsev · Answer 4 · 2016-01-21T11:48:06.367

14

for(int i=0;i<m;i++)
    for(int j=0;j<n;j++)
        yourList.add(foosArray[i][j]);

I think other tricks are unnecessary, because, anyway, they'll use this solution.

edited Jan 21 '16 at 11:48

answered Jul 12 '12 at 08:27

Dmitry Zaytsev

23,650
14
92
146

score 4 · Answer 5 · answered Jul 18 '20 at 21:15

Here is a step by step solution to convert a 2D array of int (i.e. primitive data types) to a list. The explanations are in the code comments.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Temp {
    public static void main(String... args) {
        System.out.println("Demo...");
        int [] [] twoDimArray = new int[][]{
                {1,2}, {3,5}, {8,15}
        };

        List< List<Integer> > nestedLists =
                Arrays.
                //Convert the 2d array into a stream.
                stream(twoDimArray).
                //Map each 1d array (internalArray) in 2d array to a List.
                map(
                        //Stream all the elements of each 1d array and put them into a list of Integer.
                        internalArray -> Arrays.stream(internalArray).boxed().collect(Collectors.toList()
                    )
        //Put all the lists from the previous step into one big list.
        ).collect(Collectors.toList());

        nestedLists.forEach(System.out::println);
        
    }
}

Output :

Demo...
[1, 2]
[3, 5]
[8, 15]

score 3 · Answer 6 · answered Jul 12 '12 at 08:29

3

The only way to transform it to a list is to iterate through the array and build the list as you go, like this:

ArrayList<Foo[]> list = new ArrayList<Foo[]>(foosArray.length);
for(Foo[] foo: foosArray){
    list.add(foo);
}

answered Jul 12 '12 at 08:29

Razvan

9,925
6
38
51

score 3 · Answer 7 · answered Apr 26 '18 at 17:16

3

Use java8 "flatMap" to play around. One way could be following

List<Foo> collection = Arrays.stream(array).flatMap(Arrays::stream).collect(Collectors.toList());

answered Apr 26 '18 at 17:16

Amit

656
1
6
19

How is this any different from Tomasz Mularczyk's answer? – Jean-François Beauchef May 25 '20 at 19:40

score 1 · Answer 8 · edited May 23 '17 at 10:31

Please note that: while working on arrays conversion as a list there is difference between primitive array and Object array. i.e) int[] and Integer[]

e.g)

int [][] twoDArray = {     
        {1,  2,  3,  4,  40},
        {5,  6,  7,  8,  50},
        {9,  10, 11, 12, 60},
        {13, 14, 15, 16, 70},
        {17, 18, 19, 20, 80},
        {21, 22, 23, 24, 90},
        {25, 26, 27, 28, 100},
        {29, 30, 31, 32, 110},
        {33, 34, 35, 36, 120}};

List list = new ArrayList();
for (int[] array : twoDArray) {
    //This will add int[] object into the list, and not the int values.
    list.add(Arrays.asList(array));
}

and

Integer[][] twoDArray = {     
        {1,  2,  3,  4,  40},
        {5,  6,  7,  8,  50},
        {9,  10, 11, 12, 60},
        {13, 14, 15, 16, 70},
        {17, 18, 19, 20, 80},
        {21, 22, 23, 24, 90},
        {25, 26, 27, 28, 100},
        {29, 30, 31, 32, 110},
        {33, 34, 35, 36, 120}};

List list = new ArrayList();
for (Integer[] array : twoDArray) {
    //This will add int values into the new list 
    // and that list will added to the main list
    list.add(Arrays.asList(array));      
}

To work on Keppil answer; you have to convert your primitive array to object array using How to convert int[] to Integer[] in Java?

Else add the int values one by one in the normal for loop.

int iLength = twoDArray.length;
List<List<Integer>> listOfLists = new ArrayList<>(iLength);
for (int i = 0; i < iLength; ++i) {
    int jLength = twoDArray[0].length;
    listOfLists.add(new ArrayList(jLength));
    for (int j = 0; j < jLength; ++j) {
      listOfLists.get(i).add(twoDArray[i][j]);
    }
}

Also note that Arrays.asList(array) will give fixed-size list; so size cannot be modified.

score 1 · Answer 9 · answered May 29 '21 at 14:00

1

E.g.

Integer[][] a = { { 1, 2, 3 }, { 4, 5, 6 }, { 9, 8, 9 }, };
        
List<List<Integer>> arr = Arrays.stream(a)
                .map(Arrays::asList)
                .collect(Collectors.toList());

answered May 29 '21 at 14:00

Hanamant Jadhav

627
7
12

score 0 · Answer 10 · answered Jul 31 '15 at 19:05

0

another one technique.

//converting 2D array to string
String temp = Arrays.deepToString(fooArr).replaceAll("\\[", "").replaceAll("\\]", "");
List<String> fooList = new ArrayList<>(Arrays.asList(","));

answered Jul 31 '15 at 19:05

Yogi

1,527
15
21

score 0 · Answer 11 · answered Jun 20 '18 at 10:57

0

ArrayList<Elelement[]> allElelementList = new ArrayList<>(allElelements.length);
    allElelementList.addAll(Arrays.asList(allElelements));

allElelements is two-dimensional

answered Jun 20 '18 at 10:57

mrclrchtr

948
10
14

Sergey Afinogenov · Answer 12 · 2021-02-07T10:00:37.753

Let's add some primitive type arrays processing. But you may pass to parameter any object. Method correctly process as int[][] as Object[][]:

 public <T, E> List<E> twoDArrayToList(T twoDArray) {

   if (twoDArray instanceof int[][])
     return Arrays.stream((int[][])twoDArray)
                  .flatMapToInt(a->Arrays.stream(a))
                  .mapToObj(i->(E)Integer.valueOf(i))
                  .collect(Collectors.toList());

   //… processing arrays of other primitive types 

   if (twoDArray instanceof Object[][])
        return Arrays.stream((E[][])twoDArray)
               .flatMap(Arrays::stream)
               .collect(Collectors.toList());

   return null; // better to throw appropriate exception 
                // if parameter is not two dimensional array
}

score 0 · Answer 13 · answered Sep 29 '21 at 16:48

0

In Java 8 , to convert from int[][] to List<Integer>, you can use the below code :

List<Integer> data = Arrays.stream(intervals)
              .flatMapToInt(Arrays::stream)
              .boxed()
              .collect(Collectors.toList());

answered Sep 29 '21 at 16:48

Jayanth

746
6
17

score 0 · Answer 14 · answered Feb 17 '22 at 14:05

0

List<Foo> list =  Arrays.stream(fooArray)
      .flatMap(e -> Stream :: of).collect(Collectors.toList());

answered Feb 17 '22 at 14:05

Manoj H U

37
9

score 0 · Answer 15 · answered Jul 30 '23 at 07:28

0

Some of the comments in the above answers are asking:

How can we convert an int[][] to ArrayList> ?

This can be a good way to do that:

List<List<Integer>> convertTo2DList(int[][] intervals){
List<List<Integer>> list = new ArrayList<>();
for (int[] arr : intervals) 
{
    List<Integer> temp=new ArrayList<>();
    for(int i:arr) temp.add(i);
    list.add(temp);
}
return list;
}

answered Jul 30 '23 at 07:28

Omkar

1

https://stackoverflow.com/questions/11447780/convert-two-dimensional-array-to-list-in-java – vaibhavsahu Aug 03 '23 at 19:36

Convert two dimensional array to List in java?

15 Answers15

How can we convert an int[][] to ArrayList> ?

Linked

Related