具有默认值的类的java数组

我有一个有理数类，其构造函数的默认值为0/1，如下所示：

public Rational (){ this(0, 1);}

public Rational (int numerator, int denominator){
    this.numerator = numerator;

    if (denominator== 0)
        throw new IllegalArgumentException("Denominator can't be zero.");

    this.denominator = denominator;
}

现在，在一个子类中，我想创建一个有理数数组。它们都设置为“空”。所以我在Rational类中有两个方法将所有值设置为零。一个用于简单数组，另一个用于矩阵：

public Rational[] zero(Rational[] array){
    for (int i=0; i<array.length; i++)
        array[i] = new Rational();

    return array;
}

public Rational[][] zero (Rational[][] matrix){
    for (int i=0; i<matrix.length; i++)
        for(int j=0; j<matrix[i].length; j++)
            matrix[i][j] = new Rational();

    return matrix;
}

第二，是否有一种方法可以创建数组或矩阵，而不必像处理基元类型那样手动将所有位置归零

e、 g:

int[] arr = new int [10];            //All zero
Rational[] arr = new Rational [10];  //All null
arr = arr.zero (arr);                //All "default" - 0/1

---

使用不可变的

Rational

类

public static class Rational {
    public final int num, denom;
    public Rational() {num = denom =0;}
    public Rational(int num, int denom) {this.num=num; this.denom=denom;}
}

可以这样做：

public static void zero(Rational[][] mat) {
    Rational def = new Rational();
    for (Rational[] arr : mat) {
        Arrays.fill(arr, def);
    }
}
public static void main (String[] args) throws java.lang.Exception
{
    Rational[][] mat = new Rational[5][5];
    zero(mat);
}

“自动”默认初始化，这里不可能是C++之类的东西。此外，您为循环嵌套的“新样式”

不起作用，因为设置
rat=new Rational（）
只重新分配临时的
rat
，而不是数组中的值

如您所见，这用相同的默认值
Rational
填充矩阵。对于不可变的
Rational
，这是一个明显的性能和内存使用优化，并避免了重复的构造函数调用。如果您有可变的
Rational
（我不鼓励这样做），这几乎肯定是灾难性的错误：更改一个值将更改所有值。在这种情况下，对于

循环，最好使用嵌套的“旧式”

。（我认为一个外部的“新式”代码< <代码> >具有内部的“旧样式”<代码> < <代码> >循环将不那么容易阅读，但肯定是可行的）
 如果使用数组和矩阵的<代码> Rational < /代码>，请考虑在Realth类：
中编写静态助手方法。
static public Rational[] newArray(int size) {
    Rational[] arr = new Rational[size];
    for (int i = 0; i < size; i++)
        arr[i] = new Rational();
    return arr;
}

static public Rational[][] newMatrix(int h, int w) {
    Rational[][] m = new Rational[h][];
    for (int i = 0; i < h; i++) 
        m[i] = newArray(w);
    return m;
}

或

很抱歉，据我所知，Java没有这样做。对于基本类型，您可以使用
数组。fill
@callyalater
数组。fill（）
也适用于对象，但是，只有当
Rational
是不可变的时，它才适用于这里。@SashaSalauyou我想你在编辑我的答案以包含该信息之前发表了评论：-）因为Rational是可变的，所以当我尝试乘法时，我有这样的结果：
this.numerator=this.numerator*otherRational.numerator（分母相同）。作为回报而无效。所以，如果我选择immutable，我应该这样改变
int num=this.numerator*otherRational.numerator然后我返回一个Rational作为
返回新的Rational（num，den）。对吗？这样做明智吗？@J.F.就是这样做的。这样做通常是明智的，但这取决于你自己。例如，
java.lang.String
以这种方式执行所有操作，但您必须确定这是否适合您的需要。请阅读有关的评论，也许可以了解更多。@J.F.此规则的唯一例外是
java.util.Date
，但
Date
的易变性被认为是设计缺陷，所有变异方法都不推荐使用。@SashaSalauyou确实如此。
BigDecimal
中的三个
.valueOf（）
方法。所有的方法都有一个“非无效”的return.yes。很好用。这很容易理解。
static public Rational[] newArray(int size) {
    Rational[] arr = new Rational[size];
    for (int i = 0; i < size; i++)
        arr[i] = new Rational();
    return arr;
}

static public Rational[][] newMatrix(int h, int w) {
    Rational[][] m = new Rational[h][];
    for (int i = 0; i < h; i++) 
        m[i] = newArray(w);
    return m;
}

Rational[] array = Rational.newArray(10);

Rational[][] matrix = Rational.newMatrix(10, 5);