Java程序输出奇怪的结果

我的java代码有输出问题。 我正在尝试实现这个乘法矩阵方法，它编译得很好。唯一的问题是我的输出。我似乎得到了以下信息：

  ---- Test Multiply Matrix ----
[[D@7f31245a 
Should return C={{ 3, 2},{ 1, 1}}

有人能帮我理解我哪里出了问题吗。谢谢 以下是我的源代码：

public class Recommendation 
{
public static double[][] multiplyMatrix(double[][] A, double[][] B)
{
    int aRows = A.length;
    int bRows = B.length;
    int aColumns = A[0].length;
    int bColumns = B[0].length;

    if((aColumns != bRows))
    {
        return null;
     }
    else
    {
        double[][] C = new double[aRows][bColumns];
        for (int i = 0; i < 2; i++) 
        {
            for (int j = 0; j < 2; j++) 
            {
                C[i][j] = 0;
            }
        }

        for (int i = 0; i < aRows; i++) 
        {
            for (int j = 0; j < bColumns; j++) 
            { 
                for (int k = 0; k < aColumns; k++) 
                {
                C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return C;
    }
}
static double [][] A =  {{ 1, 0, 2},
                        {  0, 1, 1}};
static double [][] B =  {{1, 2},
                        { 0, 1},
                        { 1, 0}};

    public static void main(String[] argss)
    {
    // TEST multiplyMatrix      
    System.out.println(" ---- Test Multiply Matrix ---- ");
    System.out.println(multiplyMatrix(A,B)); // should return C={{ 3, 2},{ 1, 1}}
    System.out.println("Should return C={{ 3, 2},{ 1, 1}}");
    System.out.println(" ");
    }      
 }

公共类推荐
{
公共静态双[][]乘法矩阵（双[][]A，双[][]B）
{
int aRows=A.长度；
int bRows=B.长度；
int aColumns=A[0]。长度；
int bColumns=B[0]。长度；
如果（（aColumns！=眉毛））
{
返回null；
}
其他的
{
double[]C=新的double[aRows][b列]；
对于（int i=0；i<2；i++）
{
对于（int j=0；j<2；j++）
{
C[i][j]=0；
}
}
for（int i=0；i

您可能希望使用java.util.Arrays中的Arrays.toString来打印数组

---

或者，如果希望输出更加自定义，可以对数组进行迭代。

您可能希望使用java.util.Arrays中的Arrays.toString来打印数组

---

或者，如果希望输出更加自定义，可以对数组进行迭代。

公共静态双[][]乘法矩阵（双[][]a，双[][]B）

。

---

这里返回一个双数组。它不是基元类型。因此，将使用数组的默认toString（）方法（打印

classname@hashCode

，因此是输出）。必须使用数组.toString（）才能正确打印值。

公共静态双精度[][]乘法矩阵（双精度[][]A，双精度[][]B）

。 这里返回一个双数组。它不是基元类型。因此，将使用数组的默认toString（）方法（打印

classname@hashCode

，因此是输出）。必须使用数组.toString（）才能正确打印值。

您可以使用：

---

multilyMatrix

返回一个数组，该数组是一个对象，在Java中，由于每个对象都有

toString（）

方法，默认值是显示类名表示，然后添加

@

符号，然后添加hashcode

为了更好地理解这里发生的事情，请参阅的实现

请注意，如果您希望对输出进行更多控制，例如过滤某些数组或更改它们的显示方式，则可以使用嵌套循环。

您可以使用：

---

multilyMatrix

返回一个数组，该数组是一个对象，在Java中，由于每个对象都有

toString（）

方法，默认值是显示类名表示，然后添加

@

符号，然后添加hashcode

为了更好地理解这里发生的事情，请参阅的实现

---

请注意，如果希望对输出进行更多控制，例如过滤某些数组或更改它们的显示方式，则可以使用嵌套循环。

[[D@7f31245a

表示实际对象的hashcode之后的

双

二维数组

您的

multilyMatrix（）

方法返回的正是这个值，但是调用的

toString（）

方法是在

对象上的方法，该对象正好打印这个值。您需要使用
数组
类上的方法来预打印数组

干杯，
[[D@7f31245a
表示实际对象的hashcode之后的
双
二维数组

您的
multilyMatrix（）
方法返回的正是这个值，但是调用的
toString（）
方法是在
对象上的方法，该对象正好打印这个值。您需要使用
数组
类上的方法来预打印数组

干杯，
请注意array.toString本身并不能帮助您，因为您的数组是二维的

它仍然会打印一些表单：
[[I@355d56d5, [I@2efd552, [I@4f9dfbff]

相反，您可以这样做：

double[][] C = multiplyMatrix(A,B);
for (double[] subArray : C) {
   System.out.print (Arrays.toString (subArray));
   System.out.print (" , ");
}
System.out.println();

或者，您可以使用
Arrays.deepToString（C）
，它将为您处理层次结构。
请注意，Arrays.toString本身对您没有帮助，因为您的数组是二维的

它仍然会打印一些表单：
[[I@355d56d5, [I@2efd552, [I@4f9dfbff]

相反，您可以这样做：

double[][] C = multiplyMatrix(A,B);
for (double[] subArray : C) {
   System.out.print (Arrays.toString (subArray));
   System.out.print (" , ");
}
System.out.println();

或者，您可以使用
Arrays.deepToString（C）
，它将为您处理层次结构

返回的“深层内容”的字符串表示形式
指定的数组。如果该数组包含其他数组作为元素，则
字符串表示法包含其内容等。此方法
用于将多维数组转换为字符串。

对于多维数组，应该使用
java.util.array.deepToString（array）
。当前正在打印
对象
引用的
字符串
表示


您可以使用
#replace
方法将
[]
替换为
{}

//...
public static void main(String[] argss){
    // TEST multiplyMatrix      
    System.out.println(" ---- Test Multiply Matrix ---- ");
    double array[][] = multiplyMatrix(A,B);
    String finalString = Arrays.deepToString(array)
                               .replace("[", "{")
                               .replace("]", "}");
    System.out.println(finalString);
    }//...

返回的“深层内容”的字符串表示形式
指定的数组。如果该数组包含其他数组作为元素，则
字符串表示contai