Java-从构造函数填充数组

我已经有一段时间没有接触Java了，我对如何处理这个问题有点困惑

我有一个类“Foo”，它有一个大小为5的int的私有数组

在类构造函数中，我需要传递这5个整数，所以我有这样的东西

public class Foo{

int [] numbers = new int[5];

Foo (int n0, int n1, int n2, int n3, int n4) {
    numbers[0] = n0;
    numbers[1] = n1;
    numbers[2] = n2;
    numbers[3] = n3;
    numbers[4] = n4;
}

这似乎是太多的工作，有一个更简单的方法来做，我只是没有得到它。类似于限制数组长度的for循环，如

Foo(int n0, int n1, int n2, int n3, int n4, int s0, int s1) {
    for ( int i = o; i<= numbers.length; i++ ) {
         numbers[i]= "n + i";   // This is wrong, but just to get the idea.
    }
}

Foo（int n0、int n1、int n2、int n3、int n4、int s0、int s1）{
对于（int i=o；i，我认为构造函数不应被视为在数据结构中插入（添加）对象的函数。如果我要这样做，我会这样写：

Foo(int size) {
   this.numbers = new int[size];
}

void insert(int n, int location) {
   numbers[location] = n;
}

然后，您可以使用循环从客户端程序（main）插入，并使用变量
i
（用于循环计数器）分配
位置

注意：您可能需要处理代码中可能出现的
数组越界
错误。
我认为不应将构造函数视为在数据结构中插入（添加）对象的函数。如果我要这样做，我将编写如下内容：

Foo(int size) {
   this.numbers = new int[size];
}

void insert(int n, int location) {
   numbers[location] = n;
}

然后，您可以使用循环从客户端程序（main）插入，并使用变量
i
（用于循环计数器）分配
位置

注意：您可能需要处理代码中可能出现的
数组越界
错误。
试试这个

Foo(int... n) {
    if (n.length != 5)
        throw new IllegalArgumentException("specify 5 ints");
    for (int i = 0; i < 5; ++i)
        numbers[i] = n[i];
}

Foo（int…n）{
如果（n.长度！=5）
抛出新的IllegalArgumentException（“指定5个整数”）；
对于（int i=0；i<5；++i）
数字[i]=n[i]；
}
试试这个

Foo(int... n) {
    if (n.length != 5)
        throw new IllegalArgumentException("specify 5 ints");
    for (int i = 0; i < 5; ++i)
        numbers[i] = n[i];
}

Foo（int…n）{
如果（n.长度！=5）
抛出新的IllegalArgumentException（“指定5个整数”）；
对于（int i=0；i<5；++i）
数字[i]=n[i]；
}
答案在某种程度上取决于解决方案的上下文

如果这5个整数来自同一个域，并且打算成为一个组的一部分，那么我建议传递一个表示该组的参数，而不是5个单独的项。Java提供了很好的机制来动态创建各种集合

一些潜在的“群体”可能是：

public Foo(IntStream values) { ... }
new Foo(Stream.of(1, 3, 5, 7, 9));

public Foo(int[] values) {  ... }
new Foo(new int[]{1, 3, 5, 7, 9});

public Foo(int... values) { ... }
new Foo(1, 3, 5, 7, 9);

public Foo(List<Integer> values) { ... }
new Foo(Arrays.asList(1, 3, 5, 7, 9));

publicfoo（IntStream值）{…}
新富(1,3,5,7,9);；
公共Foo（int[]值）{…}
新的Foo（新的int[]{1,3,5,7,9}）；
公共Foo（int…value）{…}
新富(1,3,5,7,9),；
公共Foo（列表值）{…}
新的Foo（Arrays.asList（1,3,5,7,9））；

所有这些都提供了检查大小的方法，或者截断并转换为您希望的任何内部格式。如果您希望发送的值的数量发生变化，这将需要最小的更改。对特定值进行硬编码意味着当值的数量发生变化时，构造函数的签名也会发生变化

另一方面，如果参数不在同一个域中，但实际上表示可区分的属性，则将它们作为单个参数提供给构造函数是有意义的。但是，在这种情况下，将它们作为集合在内部存储没有多大意义，因此您可能需要使用标准
this.bar=bar
patterns将值存储在单独的变量中。
答案在某种程度上取决于解决方案的上下文

如果这5个整数来自同一个域，并且打算成为一个组的一部分，那么我建议传递一个表示该组的参数，而不是5个单独的项。Java提供了很好的机制来动态创建各种集合

一些潜在的“群体”可能是：

public Foo(IntStream values) { ... }
new Foo(Stream.of(1, 3, 5, 7, 9));

public Foo(int[] values) {  ... }
new Foo(new int[]{1, 3, 5, 7, 9});

public Foo(int... values) { ... }
new Foo(1, 3, 5, 7, 9);

public Foo(List<Integer> values) { ... }
new Foo(Arrays.asList(1, 3, 5, 7, 9));

publicfoo（IntStream值）{…}
新富(1,3,5,7,9);；
公共Foo（int[]值）{…}
新的Foo（新的int[]{1,3,5,7,9}）；
公共Foo（int…value）{…}
新富(1,3,5,7,9),；
公共Foo（列表值）{…}
新的Foo（Arrays.asList（1,3,5,7,9））；

所有这些都提供了检查大小的方法，或者截断并转换为您希望的任何内部格式。如果您希望发送的值的数量发生变化，这将需要最小的更改。对特定值进行硬编码意味着当值的数量发生变化时，构造函数的签名也会发生变化

另一方面，如果参数不在同一个域中，但实际上表示可区分的属性，则将它们作为单个参数提供给构造函数是有意义的。但是，在这种情况下，将它们作为集合在内部存储没有多大意义，因此您可能需要使用标准
this.bar=bar
patterns将值存储在单独的变量中。
C'mon，不要使事情过于复杂：
publicfoo（int[]numbers）{this.numbers=numbers；}
在这种情况下如何限制数组大小？在实际代码中，我需要填充多个数组，因此在该解决方案中，我需要在Arguments中指定搜索数组的大小。拜托，不要过于复杂：
public Foo（int[]numbers）{this.numbers=numbers；}
在这种情况下，我如何限制数组大小？在实际代码中，我需要填充多个数组，因此在该解决方案中，我需要在参数中指定搜索数组的大小。一个答案提供了代码和问题的合理解释以及可感知的解决方案，而另一个答案只提供了无法解释的“试试这个”代码。你认为哪一个更好？一个答案提供代码和对问题的合理解释以及可感知的解决方案，另一个答案只提供无法解释的“试试这个”代码。你认为哪一个更好？