从文件 Java 中获取矩阵

Question

I currently have a text file in the format

matrix
row
a
b
c
row
d
e
f
row
g
h
i
row
j
k
l
matrix
row
m
n
o
p
q
row
r
s
t
u
v

I would like to convert this into two integer matrices (stored as 2 2D arrays), in the format

a b c

d e f

g h i

j k l

and

m n o p q

r s t u v

So far, I have created a Scanner object of the file and put each line in a text array:

Scanner sf = new Scanner(new File("C:\\textfiles\\matrices.txt"));
int maxIndex = -1;
String text[] = new String[10000]; // I added more than necessary for safety
while (sf.hasNext()){
    maxIndex++;
    text[maxIndex] = sf.nextLine();
}
sf.close();

This way, the text file is now contained in a string array, where each line is a new element of the array. Right now, I would like to partition the array into two arrays with each array being the matrices. How should I continue? (note: I am a total beginner and desire answers that are simple (no arraylist, hashmap, etc., and that's why this question is not a duplicate of How to read two matrices from a txt file in java because it uses BufferedReader, and there are other potential duplicate questions, so I would like to clear this up)

What I currently have after the top:

int counter = 0;
int iCounter = 0; // row
int jCounter = 0; // column

int matrix1[][];
int matrix2[][];
while (counter < maxIndex){
    if (counter = 0)
    {
        \\not yet written...
    }
    \\not yet written...
}

Answer 1

This does what you want. Unfortunately doing this with 2D arrays is considerably harder since once you set the size of an array its difficult to manage changing it. Therefore using ArrayList is much easier.

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Main {

    public static final String MATRIX = "matrix";
    public static final String ROW = "row";

    public static void main(String[] args) throws FileNotFoundException {
        // Use correct file name here
        Scanner sf = new Scanner(new File("matrices.txt"));

        // This is a List of 2D Lists
        List<List<List<String>>> matrices = new ArrayList<>();

        // easier to process lines as we're reading them in so we
        // only iterate over the file once
        while (sf.hasNext()) {
            boolean hasBeenProcessed = false;

            String inputValue = sf.nextLine();

            switch (inputValue) {
                case MATRIX:
                    ArrayList<List<String>> matrix = new ArrayList<>();
                    matrices.add(matrix);
                    hasBeenProcessed = true;
                    break;
                case ROW:
                    List<List<String>> currentMatrix = getMatrixBeingProcessed(matrices);
                    currentMatrix.add(new ArrayList<String>());
                    hasBeenProcessed = true;
                    break;
            }
            if (!hasBeenProcessed) {
                List<List<String>> currentMatrix = getMatrixBeingProcessed(matrices);
                List<String> currentRow = getCurrentRow(currentMatrix);
                currentRow.add(inputValue);
            }
        }

        // Print out the results:
        int i = 1;
        for (List<List<String>> matrix : matrices) {
            System.out.println("Matrix " + i);
            for (List<String> row : matrix) {
                for (String element : row) {
                    System.out.print(element + " "); // no newline until end of the row
                }
                System.out.println(); // new line
            }
            i++;
            System.out.println(); // new line
        }
    }

    private static List<String> getCurrentRow(List<List<String>> currentMatrix) {
        int lastRow = currentMatrix.size() - 1;
        return currentMatrix.get(lastRow);
    }

    private static List<List<String>> getMatrixBeingProcessed(List<List<List<String>>> matrices) {
        int lastMatrix = matrices.size() - 1;
        List<List<String>> currentMatrix = matrices.get(lastMatrix);
        return currentMatrix;
    }
}

Output:

Matrix 1
a b c 
d e f 
g h i 
j k l 

Matrix 2
m n o p q 
r s t u v 


Process finished with exit code 0

Answer 2

As @Rob said, it's really cumbersome to do this without dynamic data structures such as ArrayList's. But nevertheless, here's a code that does your job (considering you have only two matrices), without using any List's:

int counter = 0;
int iCounter = 0; // row
int jCounter = 0; // column
int matrix1[][];
int matrix2[][];

int rowSize = 0, numberOfRows = 0;
counter = 2;
while (!text[counter].equals("row") && !text[counter].equals("matrix")) {
  counter++;
  rowSize++;
}

//now we have the row size
numberOfRows = 1;
while (!text[counter].equals("matrix")) {
  if (text[counter].equals("row"))
    numberOfRows++;
  counter++;
}
//now we have the total number of rows
matrix1 = new int[numberOfRows][rowSize];

counter = 2;  //to start from the first matrix
//now counter should point to the first row of the first matrix
while (!text[counter].equals("matrix")) {
  jCounter = 0;
  while (!text[counter].equals("row")
         && !text[counter].equals("matrix")) {
    matrix1[iCounter][jCounter++] = Integer.parseInt(text[counter]);
    //supposing your input is Integers, otherwise, you can change
    //it to the corresponding type (i.e. Long, Double, etc)
    counter++;
  }
  iCounter++;
  if (!text[counter].equals("matrix"))
    counter++;
}
//now we finished with the first matrix, and the counter points to
//the first "row" of the second matrix, so we do the same thing again
rowSize = 0;
numberOfRows = 0;
int startOfSecondMatrix = counter + 2;  //save this for later
counter += 2;  // so that counter points to the first number
while (counter < text.length && !text[counter].equals("row")) {
  counter++;
  rowSize++;
}
numberOfRows = 1;
while (counter < text.length) {
  if (text[counter].equals("row"))
    numberOfRows++;
  counter++;
}
matrix2 = new int[numberOfRows][rowSize];

counter = startOfSecondMatrix;
iCounter = 0;
while (counter < text.length) {
  jCounter = 0;
  while (counter < text.length && !text[counter].equals("row")) {
    matrix2[iCounter][jCounter++] = Integer.parseInt(text[counter]);
    counter++;
  }
  iCounter++;
  counter++;
}

For each matrix we perform the same operations: -We first go through the matrix to count its size to be able to initialize it, after that, we go row by row, and parse each number.
You might as well put all the work for one matrix into a function (and take care of the bounds) and call it as long you still have more matrices.

Answer 3

Since you don't want to use List and arrays can't be resized once initialized, this is not easy.

There are two ways: Read the file and initialize arrays knowing the size (as @Maaddy posted) or 'resizing' arrays. That's not possible but it is if you use Arrays.copyOf() so you can create a new array.

The idea is create a 'tridimensional' array where you can store: matrix, row and column; and then start to read the file. Every time you find a word the entire array will be updated creating a new array with one length more.

If the word is 'matrix' the extra length will be added to the first position (the position who 'store' the matrix)

If the word is 'row' then the space will be added for the current matrix. So in this way, the current matrix will have one more array where store the column values.

If the word is other then is a value for the column. The column is resized and added to the correct position.

Note that if a word 'matrix' or 'row' is found, the new array is initialized with no length. This is because will be resized later, when is necessary.

The code is as follows:

//Initialize array with no positions
String[][][] arrays = new String[0][0][0];
Scanner sf = new Scanner(new File("path/matrices.txt"));
int matrix = -1;
int row = -1;
int column = -1;
while (sf.hasNext()){
    String line = sf.nextLine();
    if(line.equals("matrix")) {
        //'Resize' array: Create new array with 1 more length and old data
        arrays = Arrays.copyOf(arrays, arrays.length + 1);
        //Start new matrix
        arrays[++matrix] = new String[0][0];
        row = -1;
        column = -1;
    }else if(line.equals("row")) {
        //'Resize' matrix: Create a new array with 1 more length and old data
        arrays[matrix] = Arrays.copyOf(arrays[matrix], arrays[matrix].length+1);
        row++;
        arrays[matrix][row] = new String[0];
        column = -1;
    }else{
        //'Resize' matrix
        column++;
        arrays[matrix][row] = Arrays.copyOf(arrays[matrix][row], arrays[matrix][row].length+1);
        arrays[matrix][row][column] = line;
    }
}
sf.close();

//Print result
for(int i = 0 ; i < arrays.length; i++) {
    System.out.println("Matrix "+i);
    for(int j = 0; j < arrays[i].length; j++ ) {
        for(int k = 0; k < arrays[i][j].length; k++) {
            System.out.print(arrays[i][j][k]+ " ");
        }
        System.out.println();
    }
    System.out.println();
}   

And the result is:

Matrix 0
a b c 
d e f 
g h i 
j k l 

Matrix 1
m n o p q 
r s t u v