Java 是否有将所有数组元素初始化为零的快捷方式？

在

C/C++

中，我曾经

int arr[10] = {0};

…将我的所有数组元素初始化为0

Java中有类似的快捷方式吗

我想避免使用循环，可能吗

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

int-arr[]=新的int[10]；
对于（int i=0；i

在java中，默认情况下，所有元素（基本整数类型

字节
短
，
整数
，
长
）都初始化为0。您可以保存循环。
您可以保存循环，初始化已设置为0。即使对于局部变量也是如此

但为了可读性（公认的最佳实践），请更正括号的位置：

整数类型数组的默认值为0，由以下条件保证：

每个类变量、实例变量或数组组件在创建时都会使用默认值进行初始化（§15.9，§15.10）[…]对于类型
int
，默认值为零，即
0

如果要将一维数组初始化为不同的值，可以使用（当然会在内部使用循环）。
当其他答案正确时（int数组值默认初始化为0），如果要显式执行此操作（例如，如果希望数组中填充值42），可以使用类的fill（）方法：

或者，如果您是单行程序的粉丝，您可以使用以下例程：

将为arr提供以下值：

[42, 42, 42]

（虽然它是
Integer
，而不是
int
，但如果您需要原语类型，可以遵循例程：

它如何降低应用程序的性能…？请阅读以下内容

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

对于类型byte，默认值为0，即（byte）的值为0

对于类型short，的默认值为零，即（short）的值为0

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

对于类型long，默认值为零，即0L

对于类型float，默认值为正零，即0.0f

对于类型double，默认值为正零，即0.0d

对于类型char，默认值是null字符，即“\u0000”

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

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

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

因为数组是一个容器对象，它包含固定数量的单一类型的值。
现在，对于您来说，数组的类型是<强> int /强>，因此考虑所有数组元素的默认值将是<强>自动为0 < /强>，因为它是<强>保持int类型>/P>
现在，考虑字符串类型的数组，以便所有数组元素都有默认值为null

为什么不那样做？

您可以按照问题中的建议，通过使用循环来分配空值

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

int-arr[]=新的int[10]；
对于（int i=0；i更多处理数据的时间==>输出时间将显著增加。因此，应用程序数据处理可以被视为低级别（降低到某个级别）。
如果使用浮点或整数，则可以这样指定默认值

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

将数组声明为类中的实例变量，即out-of-each方法，JVM将为其提供0作为默认值。您不必再担心了
是的，数组中的int值初始化为零。但您不能保证这一点。Oracle文档说明这是一种不好的编码做法。
您可以创建一个新的空数组使用现有阵列大小，您可以将它们重新分配给阵列。这可能比其他方法更快。
鹬：

结果:

0
0
0
0
0    
0
0
0
0

inta=7，b=7，c=0，d=0；
int dizi[][]=新int[a][b]；
对于（int i=0；i，正如大家所提到的，初始化后int值已经为零。如果您确实需要将数组值设置为零，并希望对其进行优化，请使用
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);

static private int[]zeros=新浮点[64]；
...
int[]值=。。。
如果（zeros.length

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

您还可以使用
Arrays.fill
，正如其他一些人所提到的。
Arrays.fill
可以在智能JVM中使用
memcpy
，但可能只是一个Java循环和需要的边界检查

当然，对您的优化进行基准测试。
另一种方法是在Java8上使用lambda

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

在c/cpp中，没有快捷方式，只能使用零下标初始化所有数组。例如：

  int arr[10] = {0};

但是在java中有一个叫做Arrays.fill（）的神奇工具，它可以用
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();               
    }

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);

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

  int arr[10] = {0};

  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));
   }
 }

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]

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]

int[] intArray = new int[10];