将二维数组转换为由原始数组支持的二维 ArrayList

Question

I have looked through various examples on how to do this and I have got to this stage. My data import is copied into the array list but I am not seeing the data where I thought it would be.

When I use a 2D array it displays the imported data fine, but I want to be able to make changes to the data, hence the array list. I need the data to populate two things, first a Java Table and then I will reuse the data in an export to a spreadsheet. If you can just help me with the conversion of 2D array to a 2D (if this is what I need) ArrayList that would be great.

ArrayList<ArrayList<String>> student_data = new ArrayList<ArrayList<String>>();

System.out.println(DataImport.dataImport(file_path).length);
System.out.println(Arrays.deepToString(DataImport.dataImport(file_path)));
for (int i = 0; i < DataImport.dataImport(file_path).length; i++) {
    for (int j = 0; j <= 249; j++) {
        student_data.add(new ArrayList<String>(Collections.singleton(
                DataImport.dataImport(file_path)[i][j])));
        System.out.println(student_data.get(i, j));
    }
}

DataImport.dataImport(filepath) array displays the correct file path and data when deepToString is called as a check. So I know the data is there. I'm new to Java and stuck fast on this one. I modified my output to show the counters and array list when the loop completes and it now contains the data from data import, but each cell is in a separate list when what I need are rows and columns. So it is definitely the way I am populating the array list that I need help with.

Answer 1

I don't know if DataImport.dataImport(file_path) is a very fast call, but you shouldn't call it repeatedly, even if it is. Only calling it once will also improve the code readability.

Since you want a 2D array converted to a 2D list, you certainly don't want to use Collections.singleton() . Instead, you'd want to create a list inside the outer loop.

String[][] data = DataImport.dataImport(file_path);
System.out.println(data.length);
System.out.println(Arrays.deepToString(data));

ArrayList<ArrayList<String>> student_data = new ArrayList<>();
for (String[] row : data) {
    ArrayList<String> list = new ArrayList<>();
    for (String value : row) {
        list.add(value);
    }
    student_data.add(list);
}

The inner loop can be eliminated using the Arrays.asList() helper method:

String[][] data = DataImport.dataImport(file_path);
ArrayList<ArrayList<String>> student_data = new ArrayList<>();
for (String[] row : data)
    student_data.add(new ArrayList<>(Arrays.asList(row)));

If you'd like to use Java 8 Streams, you'd do it like this:

String[][] data = DataImport.dataImport(file_path);
List<List<String>> student_data = Arrays.stream(data)
        .map(row -> Arrays.stream(row).collect(Collectors.toList()))
        .collect(Collectors.toList()));

Answer 2

So in the end and after understanding the method posted by Akif Hadziabdic, I developed my own solution. I have posted it below just in case anyone else is having the same issue. Using guidance from Multi Dimensional ArrayList in Java I simply had to create a new arraylist within the first row iteration within the existing arraylist. So simple here is the code:

ArrayList<ArrayList<String>> student_data = new ArrayList<ArrayList<String>>();

for (int i = 0; i < DataImport.dataImport(file_path).length; i++) {
    student_data.add(new ArrayList<>());
    for (int j = 0; j <= 249; j++) {
        student_data.get(i).add(DataImport.dataImport(file_path)[i][j]);
    }
}

Answer 3

You can use the following methods in sequence: Arrays.stream , then Arrays::asList and Collectors.toUnmodifiableList to convert a multidimensional array to the same list that is backed by the original array and has a fixed size , since the array is always of a fixed size .

String[][] array = {{"str1", "str2"}, {"str3"}, {"str4", "str5", "str6"}};

List<List<String>> list = Arrays
        // returns a sequential stream over the array rows
        .stream(array)
        // returns a fixed-size list backed by the
        // specified array row, disallows null
        // values when the array row is null
        .map(Arrays::asList)
        // so as not to confuse the list itself and
        // its internal lists, i.e. array rows, disallows
        // null values when the array row is null
        .collect(Collectors.toUnmodifiableList());

// changing the data in the list
list.get(1).set(0, "str33");

// you can't add data to the inner lists and to
// the list itself, only modify existing data
// list.get(1).add("str34");
// list.add(Arrays.asList("str71"));
// UnsupportedOperationException

// output
System.out.println(Arrays.deepToString(array));
System.out.println(list);
//[[str1, str2], [str33], [str4, str5, str6]]
//[[str1, str2], [str33], [str4, str5, str6]]

Answer 4

You can implement a custom asList method using the Arrays#asList method for the rows of the 2D array and then for the array itself:

/**
 * Returns a fixed-size list backed by the specified array. Changes made to
 * the array will be visible in the returned list, and changes made to the
 * list will be visible in the array...
 *
 * @param array the 2D array by which the list will be backed
 * @param <T>   the class of the objects in the 2D array
 * @return a list view of the specified array
 * @throws NullPointerException if the specified array is 'null',
 *                              or one of its rows is 'null'
 * @see Arrays#asList(Object[])
 */
public static <T> List<List<T>> asList(T[][] array) {
    return Arrays.asList(Arrays.stream(array)
            .map(Arrays::asList).<List<T>>toArray(List[]::new));
}

// test
public static void main(String[] args) {
    String[][] array = {{"A", "B"}, {"C", "D", null}};
    List<List<String>> list = asList(array);

    System.out.println(Arrays.deepToString(array));
    // [[A, B], [C, D, null]]
    System.out.println(list);
    // [[A, B], [C, D, null]]

    list.get(1).set(2, "E");

    System.out.println(Arrays.deepToString(array));
    // [[A, B], [C, D, E]]
    System.out.println(list);
    // [[A, B], [C, D, E]]
}

Answer 5

a) Do the DataImport.dataImport(file_path) only once before loops, no need to read it all the time inside the loop

var rawData = DataImport.dataImport(file_path)

b) Second j-loop should iterate till rawData[i].lenght

c) Most important. You should create outer list BEFORE i-loop, inner List BEFORE j-loop. And inside j-loop add data to inner list. After j-loop - add this inner list to outer.

Something like

var rawData = DataImport.dataImport(file_path)
var studentList = new List<List<>>
for (int i = 0; i < rawData.lenght; i++) {
    var innerList = new List<>;
    for (int j = 0; i < rawData[i].lenght; j++) {
        innerList.add(rawData[i][j])
    }
    studentList.add(innerList);
}