2

I'd like to create a dynamic Multidimensional ArrayList that reads from a text file with integers separated by spaces, and by lines looking something like this:

0 -5 5 0 -3 0 5
3 1 0 0 0 0 5
5 -5 0 5 5 1 1

(Just a tiny fraction of actual data, and rows and columns are subject to change, hence the need for a dynamic 2D ArrayList.)

So far this is what I have in code:

ArrayList<ArrayList<Integer>> ratings2DArray = new ArrayList<ArrayList<Integer>>();
try {
in = new BufferedReader(new FileReader("PureRatings.txt"));
        int counter = 0;

        while (in.readLine() != null) {
            ratings2DArray.add(new ArrayList<Integer>()); //Adds 2nd dimension.

^ Pretty much saying that for each line in the text file, add a row to the 2D ArrayList.

Down here I need to declare a string (or char?) variable called rating that takes the input from the text file. And have it be delimited by spaces (sorry if I am not using the terminology correctly) so that each character "-5","-3","0","3","5" is put inside the ArrayList individually.

            ratings2DArray.get(counter).add(Integer.parseInt(rating));
            counter ++;
        }

        in.close();

    } catch (IOException e) {
        System.out.println(e.getMessage());
    }

This is barely my second semester with any exposure to programming, so any answers/ advice on whether or not this is feasible, efficient, inefficient, if I should be using different data structures, et cetera, would be greatly appreciated.

Improve this question

2 Answers 2

Reset to default
2

You're headed in the right direction. Remember to always organize your code into logical units, it helps with the conceptualization process, and the maintenance of your program down the line.

public List<List<Integer>> parseRatingsFile(String fileName) throws IOException {
    List<List<Integer>> ratings2DArray = new ArrayList<List<Integer>>(16);

    final BufferedReader in = new BufferedReader(new FileReader(fileName));
    String ratingsLine = null;
    while ((ratingsLine = in.readLine()) != null) {
        ratings2DArray.add(parseRatingsLine(ratingsLine));
    }
    in.close();

    return ratings2DArray;
}

public List<Integer> parseRatingsLine(String ratingsLine) IOException {
    List<Integer> ratings = new ArrayList<Integer>(8);
    if(ratingsLine == null) return ratings;

    String[] ratingsStrArr = ratingsLine.split(" "); // Tokenize on 'space' character
    for(final String ratingStr: ratingsStrArr) {
        // Here you would parse the ratingStr as an Integer, and
        // add it to your list
    }

    return ratings;
}

You should handle NumberFormatExceptions that can arise while you are parsing individual integers. You will notice I dropped the counter variable, it makes your program more complicated and could be the source of bugs. Good luck with the rest of the homework.

Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

Wow, that's a lot of help. Thanks. Do you mind if I ask you a few questions about it so that I understand the code more?
Sure, what do you need help understanding?
What do the 16 and 8 signify when inside the ArrayList method? "List<List<Integer>> ratings2DArray = new ArrayList<List<Integer>>(16);" Also, am I correct in thinking that the while loop adds the rows after the columns have been individually created in the parseRatingsLine method?
The ArrayList class defines a constructor that accepts an int as a parameter. The int parameter defines the initial capacity of the list, in the code example above to 16 and 8 respectively. You can replace 16 and 8 with values more appropriate to your use case - the capacity of the first array list should approximate the number of expected ratings lines in the file. The size of the second array list should approximate the number of expected ratings per line.
Yes, the while loop invokes the parseRatingsLine(...) method and adds it result to the ratings2DArray list.
|
2
  • It is feasible with the approach you are follwing

  • In terms of design of data structure, try using List interface like:

    List<List<Integer>> ratings2DArray = new ArrayList<ArrayList<Integer>>();

    The reason for this is that now tomorrow you can change ArrayList to something else.

  • Regarding efficiency, your soln is fairly efficient regarding the nature of your need. If someone really have to squeeze more performance then the code might not be that readable. One performance soln i think (on top of my head), on the assumption that no. of columns are const for the whole file, is to get rid of second/nested ArrayList and replace it with fixed size int array.

    To determine the column count, we can use the first line in the file as reference.

Elaboration on optimization soln based on below comment.

So what you saying is Column represent Book (every column is a different book) and rows represent customer (every row is a different customer)...

Say I choose -100 as value for unrated books (there are extra spaces in data just for clarity)

           Book1 Book2 Book3 Book4
Customer1  -100   5      5      3
Customer2    0    3      2    -100

Now when i am reading file the number of columns are fixed for a given file, which we can determine from the first line.

Say book 'Book5` is added.

           Book1 Book2 Book3 Book4 Book5
Customer1  -100   5      5      3   -100
Customer2    0    3      2    -100  -100

Say customer 'Customer3` is added.

           Book1 Book2 Book3 Book4 
Customer1  -100   5      5      3 
Customer2    0    3      2    -100
Customer3  -100  -100  -100   -100

So in both cases reading the first line tells us no. of columns and they stay const for the file.

Now if want to add something to the in memory List then above soln is not very optimized. As every update will be have to resize the array. Optimizations are generally for specific use cases.

So for in-memory adding of data, I think your current soln will do well. Only you can do is to pass the no of columns to ArrayList creation like:

// We are telling ArrayList the expected data size
// You can choose noOfColumns + some value according to ur need
// It will expand if more is needed
ratings2DArray.add(new ArrayList<Integer>(noOfColumns));

while loading the file. This way ArrayList is concise and will performance better.

Improve this answer

3 Comments

I don't think that I would be able to have either rows or columns as a fixed amount. I am working on a book rating project and each line (row) represents the ratings given by a customer, and the columns are the ratings for any given book. Because I should be able to add customers and books freely, the best solution I could think of, would be to use a fully dynamic 2D ArrayList. Thanks though.
@Marcos added some more to ans regarding your comment.
Thanks, yeah, I made a separate array for the book titles and will probably create an int variable using the size method of that arrayList to pass the number of columns to this arrayList.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.