ry(FileReader reader = new FileReader(filename)) {
            String strFromFile = "";

            
            while (reader.ready()) {
                strFromFile += (char) reader.read();
            }

            String[] arr = strFromFile.split(" |\n");
            Matrix result = new Matrix1D(Integer.valueOf(arr[0]), Integer.valueOf(arr[1]));

try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
}

    public static Matrix fillByKeyboard() {
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter The Number Of Matrix Rows:");
        int rowCount = scan.nextInt();
        System.out.println("Enter The Number Of Matrix Columns:");
        int colCount = scan.nextInt();
        try {
            Matrix m = new Matrix1D(rowCount, colCount);
            System.out.println("Enter Matrix Data:");
            for (int i = 1; i <= rowCount; i++) {
                for (int j = 1; j <= colCount; j++) {
                    int value = scan.nextInt();
                     m.put(i, j, value);
                }
            }
            return m;

        } catch (MatrixIndexException ex) {
            System.err.println(ex.getMessage());

        }
        return null;

    }

3
3
19 20 37 
29 48 32 
38 17 31

diff --git a/src/main/java/matrix/Main.java b/src/main/java/matrix/Main.java
index 9a5e584..213b4af 100644
--- a/src/main/java/matrix/Main.java
+++ b/src/main/java/matrix/Main.java
@@ -6,17 +6,17 @@ import java.util.List;
 public class Main {
 
     public static void main(String[] args) throws MatrixIndexException, java.io.IOException {
-        Matrix m1 = new LargeIntegerMatrix("data1.txt", 100, 100);
-        Matrix m2 = new LargeIntegerMatrix("data2.txt", 100, 100);
+        Matrix m1 = new LargeIntegerMatrix("data1.txt", 3, 3);
+        Matrix m2 = new LargeIntegerMatrix("data2.txt", 3, 3);
         
         MatrixUtils.fillByRandom(m1);
         MatrixUtils.fillByRandom(m2);
         
         Matrix m = MatrixUtils.matrixMultiple(m1, m2);
         
-        System.out.println(m.toString());
+        System.out.println(m.toStringOneColumn());
         MatrixUtils.writeMatrixToFile(m, "file.txt");
         Matrix m3 = MatrixUtils.loadMatrixFromFile("file.txt");
-        System.out.println(m3.toString());
+        System.out.println(m3.toStringOneColumn());
     }
 }
diff --git a/src/main/java/matrix/Matrix.java b/src/main/java/matrix/Matrix.java
index 30de28a..4079adb 100644
--- a/src/main/java/matrix/Matrix.java
+++ b/src/main/java/matrix/Matrix.java
@@ -11,7 +11,7 @@ public abstract class Matrix {
     public abstract int getColCount();
     
     @Override
-    public String toString() {    
+    public String toString() {
         StringBuilder out = new StringBuilder();
         out.append("Matrix:\n[ ");
 
@@ -22,7 +22,7 @@ public abstract class Matrix {
             }
             for (int j = 0; j < getColCount(); j++) {
                 try {
-                    out.append(get(i, j));
+                    out.append(get(i + 1, j + 1));
                     if (j != getColCount() - 1) {
                         out.append(" ");
                     }
@@ -39,6 +39,24 @@ public abstract class Matrix {
         return out.toString();
     }   
 
+    public String toStringOneColumn() {
+        StringBuilder out = new StringBuilder();
+        out.append("Matrix:\n[ \n");
+
+        for (int i = 0; i < getRowCount(); i++) {
+            for (int j = 0; j < getColCount(); j++) {
+                try {
+                    out.append(get(i + 1, j + 1));
+                    out.append("\n");
+                } catch (MatrixIndexException e) {
+                }
+            }
+        }
+        out.append("]");
+        return out.toString();
+    }
+
     @Override
     public boolean equals(Object obj) {
         Matrix m = (Matrix) obj;

public static Matrix loadMatrixFromFile(String filename) throws FileNotFoundException, IOException {

        try{
            

            FileInputStream fs = new FileInputStream(filename);
            
            Scanner input = new Scanner(fs);

            int colCount = input.nextInt();
            int rowCount = input.nextInt();
            
            Matrix m = new 
            
            for(int i = 1; i < m.getColCount(); i++)
                for(int i = 1; i < m.getRowCount(); i++){
                    int value = input.nextInt();
                    m.put();
                }
            
            
            
    }
}

package matrix;

import java.util.Random;
import java.util.Scanner;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class MatrixUtils {

    public static void fillByRandom(Matrix m) {
        int rowCount = m.getRowCount();
        int colCount = m.getColCount();
        Random random = new Random();

        for (int i = 1; i <= rowCount; i++) {

            for (int j = 1; j <= colCount; j++) {
                try {
                    m.put(i, j, random.nextInt(50));
                } catch (MatrixIndexException e) {
                    System.err.println(e.getMessage());

                }

            }
        }
    }

    public static void fillByNumber(Matrix m, int number) {
        int rowCount = m.getRowCount();
        int colCount = m.getColCount();

        for (int i = 1; i <= colCount; i++) {

            for (int j = 1; j <= rowCount; j++) {
                try {
                    m.put(i, j, number);

                } catch (MatrixIndexException e) {
                    System.err.println(e.getMessage());

                }

            }
        }

    }

    public static Matrix fillByKeyboard() {
        Scanner scan = new Scanner(System.in);
        System.out.println("Enter The Number Of Matrix Rows:");
        int rowCount = scan.nextInt();
        System.out.println("Enter The Number Of Matrix Columns:");
        int colCount = scan.nextInt();
        try {
            Matrix m = new Matrix1D(rowCount, colCount);
            System.out.println("Enter Matrix Data:");
            for (int i = 1; i <= rowCount; i++) {
                for (int j = 1; j <= colCount; j++) {
                    int value = scan.nextInt();
                     m.put(i, j, value);
                }
            }
            return m;

        } catch (MatrixIndexException ex) {
            System.err.println(ex.getMessage());

        }
        return null;

    }
    
    public static Matrix matrixMultiple(Matrix a, Matrix b) throws MatrixIndexException {
       
        int aRows = a.getRowCount();
        int aColumns = a.getColCount();
        int bRows = b.getRowCount();
        int bColumns = b.getColCount();

        if (aColumns != bRows) {
            throw new IllegalArgumentException("A:Rows: " + aColumns + " did not match B:Columns " + bRows + ".");
        }

        Matrix c = new Matrix1D(aRows, bColumns);
        for (int i = 0; i < aRows; i++) {
            for (int j = 0; j < bColumns; j++) {
                c.put(i+1,j+1,0);
            }
        }

        for (int i = 0; i < aRows; i++) { // aRow
            for (int j = 0; j < bColumns; j++) { // bColumn
                for (int k = 0; k < aColumns; k++) { // aColumn
                    c.put(i+1,j+1,c.get(i+1,j+1) + a.get(i+1, k+1) * b.get(k+1, j+1));
                }
            }
        }

        return c;   
    }

    public static void writeMatrixToFile(Matrix m, String filename) {

        try (FileOutputStream fileOutputStream = new FileOutputStream(filename);
            DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream)) {
            dataOutputStream.writeInt(m.getRowCount());
            dataOutputStream.writeInt(m.getColCount());
            for (int i = 1; i <= m.getRowCount(); i++){
                for (int j = 1; j <= m.getColCount(); j++){
                    dataOutputStream.writeInt(m.get(i, j));
                }
            }
            dataOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } catch(MatrixIndexException e) {
             e.printStackTrace();
        }
    }

    public static Matrix loadMatrixFromFile(String filename) {

        try (FileInputStream fileInputStream = new FileInputStream(filename);
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
            DataInputStream dataInputStream = new DataInputStream(bufferedInputStream)) {
            int rowCount = dataInputStream.readInt();
            int colCount = dataInputStream.readInt();
            Matrix result = new Matrix1D(rowCount, colCount);
            int row = 1;
            int col = 1;
            for (int i = 0; i < rowCount * colCount; i++){
                result.put(row, col, dataInputStream.readInt());
                col++;
                if (col == result.getColCount() + 1){
                    col = 1;
                    row++;
                }
            }
            return result;
        } catch (MatrixIndexException | IOException ex) {
            throw new RuntimeException(ex);
        }
    }
}

package matrix;

import java.util.LinkedList;
import java.util.List;

public class Main {

    public static void main(String[] args) throws MatrixIndexException, java.io.IOException {
        Matrix m1 = new LargeIntegerMatrix("data1.txt", 3, 3);
        Matrix m2 = new LargeIntegerMatrix("data2.txt", 3, 3);
        
        MatrixUtils.fillByRandom(m1);
        MatrixUtils.fillByRandom(m2);
        
        Matrix m = MatrixUtils.matrixMultiple(m1, m2);
        
        System.out.println(m.toStringOneColumn());
        MatrixUtils.writeMatrixToFile(m, "file.txt");
        Matrix m3 = MatrixUtils.loadMatrixFromFile("file.txt");
        System.out.println(m3.toStringOneColumn());
    }
}

package matrix;

public abstract class Matrix {
    
    public abstract int get(int i, int j) throws MatrixIndexException;
    
    public abstract void put(int i, int j, int value) throws MatrixIndexException; 
        
    public abstract int getRowCount();

    public abstract int getColCount();
    
    @Override
    public String toString() {
        StringBuilder out = new StringBuilder();
        out.append("Matrix:\n[ ");

        for (int i = 0; i < getRowCount(); i++) {
            if (i != 0) {
                out.append("\n");
                out.append("  ");
            }
            for (int j = 0; j < getColCount(); j++) {
                try {
                    out.append(get(i + 1, j + 1));
                    if (j != getColCount() - 1) {
                        out.append(" ");
                    }
                } catch (MatrixIndexException e) {

                }
                if (j == getColCount() - 1) {

                    out.append(" ]");
                }

            }
        }
        return out.toString();
    }   

    public String toStringOneColumn() {
        StringBuilder out = new StringBuilder();
        out.append("Matrix:\n[ \n");

        for (int i = 0; i < getRowCount(); i++) {
            for (int j = 0; j < getColCount(); j++) {
                try {
                    out.append(get(i + 1, j + 1));
                    out.append("\n");
                } catch (MatrixIndexException e) {

                }
            }
        }
        out.append("]");
        return out.toString();
    }

    @Override
    public boolean equals(Object obj) {
        Matrix m = (Matrix) obj;
        try {
            if (m.getRowCount() != getRowCount() || m.getColCount() != getColCount()) {
                return false;
            }
    
            for (int i = 0; i < getRowCount(); i++) {
                for (int j = 0; j < getColCount(); j++) {
                    if (this.get(i + 1, j + 1) != m.get(i + 1, j + 1)) {
                        return false;
                    }
                }
            }
    
            return true;
        } catch (MatrixIndexException ex) {
            return false;
        }
    }
}