How to create a list of list of given size and initialize with values in java

This is the code to initialize a list of list with some values and given size in C++

vector<vector<int>> arr = vector<>(rowSize, vector<>(colSize, value));

Is there any equivalent code in Java?

We could use the IntStream.range() to stream and create new List and add it to the main list. Then loop through the 2D list and set some default values.
I'm searching for something similar to c++ implementation mentioned above

You could do that:

Supplier<List<Integer>> s = Stream.generate(() -> value)
      .limit(colSize)
      .collect(toCollection(ArrayList::new)); 
List<List<Integer>> table = Stream.generate(s)
  .limit(rowSize)
  .collect(toCollection(ArrayList::new));

But it may be overkill to use Stream for that:

List<Integer> columnTemplate = Collections.nCopies(colSize, value);
List<List<Integer>> table = new ArrayList<>(rowSize); 
for (int i = 0; i < rowSize; ++i) {
  table.add(new ArrayList<>(columnTemplate)); // because list is immutable
}

As you can see, I used version that do no return immutable collection: you would probably want to be able to change the value at some row/col:

table.get(row).set(col, n);

This will fail if you use toList() on Stream or nCopies directly.

You can use Collections.nCopies for a List of primitives filled with a certain value. To create the List of Lists, you can use Stream.generate (to ensure that each row is a separate reference).

For example:

int value = 1, rowSize = 3, colSize = 10;
List<List<Integer>> list = Stream.generate(() -> 
       (List<Integer>)new ArrayList<>(Collections.nCopies(colSize, value)))
       .limit(rowSize).collect(Collectors.toCollection(ArrayList::new));

You have two ways of doing this, and both take a generic type for the value.

Traditional for loop, or with streams.

Note: The Collections.nCopies method returns an immutable list, so you will need to pass it to the ArrayList constructor if you intend to modify it.

import java.util.*;
import java.util.stream.*;

public class Matrix {
    public static void main(String[] args) {
        List<List<Integer>> intMatrix1 = initializeMatrix(3, 4, 1);
        List<List<Integer>> intMatrix2 = initializeMatrix2(3, 4, 1);

        System.out.println(intMatrix1); // [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
        System.out.println(intMatrix2); // [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
    }

    public static <E> List<List<E>> initializeMatrix(int rows, int cols, E value) {
        List<List<E>> matrix = new ArrayList<>();
        for (int rowIndex = 0; rowIndex < rows; rowIndex++) {
            List<E> row = new ArrayList<>();
            for (int colIndex = 0; colIndex < cols; colIndex++) {
                row.add(colIndex, value);
            }
            matrix.add(row);
        }
        return matrix;
    }

    public static <E> List<List<E>> initializeMatrix2(int rows, int cols, E value) {
        return Stream.generate(() -> new ArrayList<>(Collections
                .nCopies(cols, value)))
                .limit(rows)
                .collect(Collectors.toList());
    }
}