assigning each value from the list to a two-dimensional array

I don't really know how to define the assignment of individual elements in the list to 2D array. For example:

I have a list that is String, it contains:

list.get(0) = "1 2 3" 
list.get(1) = "1 4 2"

I want each element to be assigned to int[][] like this way:

tab[0][0] = 1;
tab[0][1] = 2;
tab[0][2] = 3;
tab[1][0] = 1;
tab[1][1] = 4;
tab[1][2] = 2;

I prepared such code:

Scanner scan = new Scanner(System.in);
        List<String> stringToMatrix = new ArrayList<>();

        while (!stringToMatrix.contains("end")) {
            stringToMatrix.add(scan.nextLine());
        }
        stringToMatrix.remove(stringToMatrix.size() - 1);
        //-size of matrix
        int col = stringToMatrix.get(0).length() - stringToMatrix.get(0).split(" ").length + 1;
        int rows = stringToMatrix.size();
        int[][] bigMatrix = new int[rows+2][col+2]; //rows and cols +2 because I want to insert values from the list into the middle of the table.

        int outerIndex = 1;
        for (String line: stringToMatrix) {
            String[] stringArray = line.split(" ");
            int innerIndex = 1;
            for (String str: stringArray) {
                int number = Integer.parseInt(str);
                bigMatrix[outerIndex][innerIndex++] = number;
            }
            outerIndex++;
        }

        for (int[] x: bigMatrix) {
            System.out.print(Arrays.toString(x));
        }

Input:

1 2 3
1 2 3
end

Result:

[0, 0, 0, 0, 0][0, 1, 2, 3, 0][0, 1, 2, 3, 0][0, 0, 0, 0, 0]

Input:

1 -2 53 -1
1 4 -4 24
end

Result

[0, 0, 0, 0, 0, 0, 0, 0, 0][0, 1, -2, 53, -1, 0, 0, 0, 0][0, 1, 4, -4, 24, 0, 0, 0, 0][0, 0, 0, 0, 0, 0, 0, 0, 0]

The problem was there:

int col = stringToMatrix.get(0).length() - stringToMatrix.get(0).split(" ").length + 1;

Here is a small example how to convert it to an 2d int[][] array

List<String> myListIWantToConvert = new ArrayList<Stirng>();
myListIWantToConvert.add("1 2 3");
myListIWantToConvert.add("1 4 2");

int[][] myConvert = new int[][];

int i = 0;
for(String string : myListIWantToConvert) {
    // create new int array
    int[] arrayToPutIn = new int[];
    // split the string by the space
    String[] eachNumber = string.split(" ");
    // loog through string array
    for(int i2 = 0; i2 < eachNumber.length; i2++) {
        // convert string to integer and put in the new integer array
        arrayToPutIn[i2] = Integer.valueOf(eachNumber[i2]);
    }
    // finally add the new array
    myConvert[i] = arrayToPutIn;
    i++; // edit: ( sry forgot :D )
}

A for-loop with another nested one shall do the thing:

List<String> list = ...                           // input list
int[][] tab = new int[2][3];                      // target array

int outerIndex = 0;                               // X-index of tab[X][Y] 
for (String line: list) {                         // for each line...
   String[] stringArray = line.split(" ");        // ... split by a space
   int innerIndex = 0;                            // ... Y-index of tab[X][Y]
   for (String str: stringArray) {                // ... for each item in a line
       int number = Integer.parseInt(str);        // ...... parse to an int
       tab[outerIndex][innerIndex++] = number;    // ...... add to array tab[X][Y]
   }                                                        and increase the Y
   outerIndex++;                                  // ... increase the X
}

Remember, additionally, you might want:

• ... to handle the exceptional values (non-parseable into an int)
• ... to split by multiple white characters (\\s+), not a single space
• ... to handle the array index overflow

The Java 8 Stream API brings the way easier way to do so... if you don't mind Integer[][] as a result instead.

Integer[][] tab2 = list.stream()                  // Stream<String>
    .map(line -> Arrays.stream(line.split(" "))   // ... Stream<String> (split)
        .map(Integer::parseInt))                  // ... Stream<Integer>
        .toArray(Integer[]::new))                 // ... Integer[]
    .toArray(Integer[][]::new);                   // Integer[][]

Sample Solution:

import java.util.*;
public class Main {
public static void main(String []args){
    
        List<String> tempList = new ArrayList<>();
        tempList.add("1 2 3");
        tempList.add("1 4 2");
        
        int[][] resultArr = new int[tempList.size()][3];//Initialzing the 2d array
        
        for (int i = 0; i < resultArr.length; ++i) {//Assigning the elements to 2D Array
             String[] tempArr = tempList.get(i).split(" ");
            for(int j = 0; j < resultArr[i].length; ++j) {
               
                resultArr[i][j] =Integer.parseInt(tempArr[j]);
               
            }
        }
        for (int i = 0; i < resultArr.length; ++i) {//Printing the newly created array elements
             String[] temparr = tempList.get(i).split(" ");
            for(int j = 0; j < resultArr[i].length; ++j) {
               
                System.out.println(resultArr[i][j]);
               
            }
        }
     }

}

Output:
1
2
3
1
4
2

Take care of the int array size. If the list contains different number of elements, you should consider the following:

import java.util.*;
class Main {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("1 2 3");
    list.add("4 5 6 7");
    
    int[][] tab = new int[list.size()][];
    
    for(int i = 0; i < list.size(); i++) {
      String[] value = list.get(i).split(" ");
      tab[i] = new int[value.length];
      for(int j = 0; j < value.length; j++) { 
        tab[i][j] = Integer.parseInt(value[j]);
      }
      System.out.println( Arrays.toString(tab[i]));
    }
  }
}

You must pay attention on the "dimension" definition.

When working with 2 dimensional arrays it's an array that contains array, an 2x3 dimension array would looks like that:

[[x,y,z]] 
[[a,b,c]]

In a more helpful visualization:

[] item 1 of 2 of first dimension
  [x,y,z] the 3 items of the second dimension
[] item 1 of 2 of first dimension
  [a,b,c] the 3 items of the second dimension

Now imagine that the list is a 1 dimension array, if your example we could make it like that:

["1 2 3"]["1 4 2"]

So let's change now the Strings to an array of chars

[['1','2','3']]
[['1','4','2']]

or

[]
  ['1',' ','2',' ','3']
[]
  ['1',' ','4',' ','2']

Can you see the similarities?

Now to get what you want we need to remove the white spaces and to transform them into Integers.

So your algorithm would be:

Create a new array of the desired dimensions (2x3) in your
define two variables to hole the value for line and column index with 0 value
loop over the list of strings:
  transform this line in a array of strings, splinting it by ' '
    loop over the splinted values and convert them to int
    add your converted value in array
[column]
    increase column by 1
  increase line by 1
  set column value to 0

Try it out and have fun