任何快捷方式初始化所有数组元素为零?

在java中，所有元素(基本整数类型byte short， int， long)默认初始化为0。你可以保存循环。

你可以保存循环，初始化已经被设为0。即使是局部变量。

但是为了可读性(公认的最佳实践)，请更正您放置括号的位置:

int[] arr = new int[10];

整型数组的默认值为0由语言规范保证:

每个类变量、实例变量或数组组件在创建时都使用默认值初始化(§15.9，§15.10)[…]对于int类型，默认值为0，即0。,

如果你想将一个一维数组初始化为不同的值，你可以使用java.util.Arrays.fill ()(这当然会在内部使用循环)。

虽然其他答案是正确的(int数组值默认初始化为0)，如果你想显式地这样做(例如，如果你想用值42填充数组)，你可以使用数组类的fill()方法:

int [] myarray = new int[num_elts];
Arrays.fill(myarray, 42);

或者如果你喜欢1-liners，你可以使用Collections.nCopies()例程:

Integer[] arr = Collections.nCopies(3, 42).toArray(new Integer[0]);

将为arr赋值:

[42, 42, 42]

(虽然它是Integer，而不是int，如果你需要基本类型，你可以遵循Apache Commons ArrayUtils.toPrimitive()例程:

int [] primarr = ArrayUtils.toPrimitive(arr);

它如何降低应用程序的性能....?阅读以下。

在Java语言规范中，任何对象的默认/初始值可以如下所示。

对于类型字节， 默认值为零，即(byte)的值为0。

对于类型短， 默认值为零，即(short)的值为0。

对于类型int， 默认值为零，即0。

对于类型长， 默认值为零，即0 l。

对于类型浮动， 默认值为积极的零，即0.0度。

对于类型双， 默认值为积极的零，即0.0 d。

对于类型字符， 默认值是零字符，即'\ u0000'。

对于类型布尔， 默认值为假。

对于所有引用类型， 默认值为零。

考虑到这些，你不需要为数组元素初始化0值，因为默认情况下，int array的所有数组元素都是0。

现在考虑为字符串类型的数组，这样所有数组元素都有默认值为零。

为什么不这样做......?

你可以在你的问题中建议使用循环来分配空值。

int arr[] = new int[10];
for(int i=0;i<arr.length;i++)
arr[i] = 0;

机器使用周期越长，处理数据的时间越长。这样你的应用程序数据处理可以被认为是低级别的(慢到某个级别)。

如果你正在使用浮点或整数，那么你可以像这样分配默认值…

Integer[] data = new Integer[20];
Arrays.fill(data,new Integer(0));

将数组声明为类中的实例变量，即在每个方法之外，JVM将给它0作为默认值。你不必再担心了

是的，数组中的int值初始化为0。但你不能保证这一点。Oracle文档指出这是一种糟糕的编码实践。

package com.array.zero;
public class ArrayZero {
public static void main(String[] args) {
// Your array with data
int[] yourArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//Creating same sized array with 0
int[] tempArray = new int[yourArray.length];
Assigning temp array to replace values by zero [0]
yourArray = tempArray;


//testing the array size and value to be zero
for (int item : yourArray) {
System.out.println(item);
}
}
}

结果:

0
0
0
0
0
0
0
0
0

    int a=7, b=7 ,c=0,d=0;
int dizi[][]=new int[a][b];
for(int i=0;i<a;i++){
for(int q=d;q<b;q++){
dizi[i][q]=c;
System.out.print(dizi[i][q]);
c++;
}


c-=b+1;
System.out.println();
}

正如每个人都提到的，初始化后int值已经为零。如果你确实需要将数组值设置为0并想要优化它，请使用System.arraycopy:

static private int[] zeros = new float[64];
...
int[] values = ...
if (zeros.length < values.length) zeros = new int[values.length];
System.arraycopy(zeros, 0, values, 0, values.length);

这在大多数或所有JRE实现中使用memcpy。注意，即使是多线程，使用这样的静态也是安全的，因为最坏的情况是多个线程并发地重新分配zeros，这不会造成任何损害。

你也可以像其他人提到的那样使用Arrays.fill。Arrays.fill 可以在智能JVM中使用memcpy，但可能只是一个Java循环和随之而来的边界检查。

当然，要对优化进行基准测试。

另一种方法是在java 8之上使用lambda

 Arrays.stream(new Integer[nodelist.size()]).map(e ->
Integer.MAX_VALUE).toArray(Integer[]::new);

在c/cpp中，除了初始化所有带有0下标的数组外，没有其他快捷方式。例:

  int arr[10] = {0};

但是在java中有一个神奇的工具叫做Arrays.fill()，它可以用你选择的整数填充数组中的所有值。例:

  import java.util.Arrays;


public class Main
{
public static void main(String[] args)
{
int ar[] = {2, 2, 1, 8, 3, 2, 2, 4, 2};
Arrays.fill(ar, 10);
System.out.println("Array completely filled" +
" with 10\n" + Arrays.toString(ar));
}
}

在零的情况下不需要初始化，因为Java中的int默认值为零。 对于非0的值java.util.Arrays提供了许多选项，最简单的一个是填充方法

int[] arr = new int[5];
Arrays.fill(arr, -1);
System.out.println(Arrays.toString(arr));  //[-1, -1, -1, -1, -1 ]


int [] arr = new int[5];
// fill value 1 from index 0, inclusive, to index 3, exclusive
Arrays.fill(arr, 0, 3, -1 )
System.out.println(Arrays.toString(arr)); // [-1, -1, -1, 0, 0]

我们也可以使用Arrays.setAll()如果我们想在条件的基础上填充值:

int[] array = new int[20];
Arrays.setAll(array, p -> p > 10 ? -1 : p);


int[] arr = new int[5];
Arrays.setAll(arr, i -> i);
System.out.println(Arrays.toString(arr));   // [0, 1, 2, 3, 4]

你在你的问题中正确地定义了它，它几乎与c++相同。对于基元数据类型，您需要做的就是初始化数组。默认值是int 0。

int[] intArray = new int[10];

您可以简单地执行以下操作

 int[] arrayOfZeros= new int[SizeVar];