ERROR: array required but (class) found

Question

Good afternoon. I’m creating an algorithm for matrix multiplication, following the linear Algebra property. I chose to create a class with attributes: row and column, after obtaining these values by the constructor, create an array:

matrix = new int[row][column]

And then I created a method to add random values. Everything works. My question comes now... When I create the method to multiply the matrices, it looks like this:

public int[][] produtoMatrizes(CriarMatrizes m1, CriarMatrizes m2){
     if (m1.getLinha() != m2.getColuna()) throw new RuntimeException("Dimensões inconsistentes. Impossível multiplicar as matrizes");
     int[][] result = new int[m1.getLinha()][m2.getColuna()];

     for (int i = 0; i < m1.getLinha(); i++)
       for (int j = 0; j < m2.getColuna(); j++) 
            for (int k = 0; k < m1.getColuna(); k++)
                result[i][j] += (m1[i][k] * m2[k][j]);

    return result;    

 } 

In this row: result[i][j] += (M1[i][k] * m2[k][j]); presents an error, which is: array required but Object found. I’d like some help on this part.

EDIT with the code of the Create matrices.java class

public class CriarMatrizes {

private int[][] matrix; int private line; int private column;

public CriarMatrizes(int linha, int coluna) {
    this.linha = linha;
    this.coluna = coluna;
    matriz = new int[linha][coluna];
}
// os métodos gettes e setters

public void AdicionarValoresMatriz()
{
    SecureRandom gerador = new SecureRandom();

    for(int i = 0; i<getLinha(); i++)
        {
        for(int j = 0; j<getColuna();j++)
            matriz[i][j] = gerador.nextInt(25);

    }
}
public void ExibirMatriz(){
    for(int i=0;i<getLinha();i++)
    {
        for(int j=0;j<getColuna();j++)
        {

            System.out.print(matriz[i][j] + " ");
        }
        System.out.print("\n");
}
}

 public int[][] produtoMatrizes(CriarMatrizes m1, CriarMatrizes m2){
     if (m1.getLinha() != m2.getColuna()) throw new RuntimeException("Dimensões inconsistentes. Impossível multiplicar as matrizes");
     int[][] result = new int[m1.getLinha()][m2.getColuna()];

     for (int i = 0; i < m1.getLinha(); i++)
       for (int j = 0; j < m2.getColuna(); j++) 
            for (int k = 0; k < m1.getColuna(); k++)
                result[i][j] += (m1[i][k] * m2[k][j]);

    return result;    

 } 

}

Answer 1

M1 and m2 should be arrays but are objects of type Criamatrizes. I don’t know if there is an Array inside the Create Matrices object, but you should use the matrix referring to each object Create Matrices.

Without changing almost anything in your code, a possible solution would be:

import java.security.SecureRandom;

public class CriadorDeMatrizes {

    private int[][] matriz;
    private int linha;
    private int coluna;

    /**
     * @return the matriz
     */
    public int[][] getMatriz() {
        return matriz;
    }

    /**
     * @param matriz the matriz to set
     */
    public void setMatriz(int[][] matriz) {
        this.matriz = matriz;
    }

    /**
     * @return the linha
     */
    public int getLinha() {
        return linha;
    }

    /**
     * @param linha the linha to set
     */
    public void setLinha(int linha) {
        this.linha = linha;
    }

    /**
     * @return the coluna
     */
    public int getColuna() {
        return coluna;
    }

    /**
     * @param coluna the coluna to set
     */
    public void setColuna(int coluna) {
        this.coluna = coluna;
    }

    public CriadorDeMatrizes(int linha, int coluna) {
        this.linha = linha;
        this.coluna = coluna;
        matriz = new int[linha][coluna];
    }

    public void adicionarValoresMatriz() {
        SecureRandom gerador = new SecureRandom();

        for (int i = 0; i < getLinha(); i++) {
            for (int j = 0; j < getColuna(); j++)
                matriz[i][j] = gerador.nextInt(25);

        }
    }

    public void exibirMatriz() {
        for (int i = 0; i < getLinha(); i++) {
            for (int j = 0; j < getColuna(); j++) {

                System.out.print(matriz[i][j] + " ");
            }
            System.out.print("\n");
        }
    }

    public static int[][] produtoMatrizes(CriadorDeMatrizes m1, CriadorDeMatrizes m2) {
        if (m1.getLinha() != m2.getColuna())
            throw new RuntimeException("Dimensões inconsistentes. Impossível multiplicar as matrizes");
        int[][] result = new int[m1.getLinha()][m2.getColuna()];

        for (int i = 0; i < m1.getLinha(); i++)
            for (int j = 0; j < m2.getColuna(); j++)
                for (int k = 0; k < m1.getColuna(); k++)
                    result[i][j] += (m1.getMatriz()[i][k] * m2.getMatriz()[k][j]);

        return result;
    }

    public static void main(String[] args) {
        CriadorDeMatrizes criadorUm = new CriadorDeMatrizes(4, 4);
        criadorUm.adicionarValoresMatriz();
        CriadorDeMatrizes criadorDois = new CriadorDeMatrizes(4, 4);
        criadorDois.adicionarValoresMatriz();
        int[][] retorno = CriadorDeMatrizes.produtoMatrizes(criadorUm, criadorDois);
        for (int i = 0; i < retorno.length; i++) {
            for (int j = 0; j < retorno[i].length; j++) {

                System.out.print(retorno[i][j] + " ");
            }
            System.out.print("\n");
        }       
    }
}

A simpler solution to what you are wishing to do would be:

import java.security.SecureRandom;

public class CriadorDeMatrizesSimples {

    /***
     * Metodo responsavel por gerar uma matriz com numeros aleatorios de 0 a 25.
     * 
     * @param matriz - Matriz gerada.
     */
    public static int[][] gerarMatriz(int linhas, int colunas) {
        int[][] retorno = new int[linhas][colunas];
        SecureRandom gerador = new SecureRandom();
        for (int i = 0; i < linhas; i++) {
            for (int j = 0; j < colunas; j++)
                retorno[i][j] = gerador.nextInt(25);
        }
        return retorno;
    }

    /***
     * Metodo responsavel por exibir os numeros da matriz.
     * 
     * @param matriz - Matriz a qual sera exibida os valores.
     */
    public static void exibirMatriz(int[][] matriz) {
        for (int i = 0; i < matriz.length; i++) {
            for (int j = 0; j < matriz[i].length; j++) {
                System.out.print("[" + matriz[i][j] + "]");
            }
            System.out.print("\n");
        }
    }

    /***
     * Metodo responsavel por multiplicar duas matrizes.
     * @param matrizUm - Primeira Matriz
     * @param matrizDois - Segunda Matriz
     * @return int[][] - Matriz resultante do da multiplicacao da primeira matriz com a segunda matriz.
     */
    public static int[][] produtoMatrizes(int[][] matrizUm, int[][] matrizDois) {
        if (matrizUm.length != matrizDois[0].length)
            throw new RuntimeException("Dimensões inconsistentes. Impossível multiplicar as matrizes");

        int[][] resultado = new int[matrizUm.length][matrizDois[0].length];

        for (int i = 0; i < matrizUm.length; i++)
            for (int j = 0; j < matrizDois[0].length; j++)
                for (int k = 0; k < matrizUm[0].length; k++)
                    resultado[i][j] += (matrizUm[i][k] * matrizDois[k][j]);

        return resultado;
    }

    public static void main(String[] args) {
        int[][] matrizUm = CriadorDeMatrizesSimples.gerarMatriz(2, 2);
        System.out.println("Matriz Um:");
        CriadorDeMatrizesSimples.exibirMatriz(matrizUm);

        int[][] matrizDois = CriadorDeMatrizesSimples.gerarMatriz(2, 2);
        System.out.println("Matriz Dois:");
        CriadorDeMatrizesSimples.exibirMatriz(matrizDois);

        int[][] matrizResultante = CriadorDeMatrizesSimples.produtoMatrizes(matrizUm, matrizDois);
        System.out.println("Matriz Resultante:");
        CriadorDeMatrizesSimples.exibirMatriz(matrizResultante);
    }
}