¿Podemos suponer valores de matriz por defecto en Java? por ejemplo, supongamos que una matriz int se establece en todos los ceros?

En la práctica, ¿puedo suponer que todas las matrices en formato int en Java comenzarán llenas de ceros? para todas las máquinas en las que se ejecuta la JVM?

¿Es esto cierto para todos los tipos? ¿carbonizarse? booleano? enums?

¿Dónde está esto oficialmente documentado?

Los libros de texto que tengo dicen que las matrices en int se establecen en cero, pero también recomiendan que se escriba un for-loop para establecer todos los valores en cero solo para “ser más claros”.

La especificación del lenguaje Java es el lugar correcto para buscar dicha información:

Los componentes de matriz son variables sin nombre que se crean y se inicializan a valores predeterminados (§4.12.5) siempre que se crea un nuevo objeto que es una matriz

Los valores predeterminados se dan en la sección 4.12.5 .

  • Para tipo byte , el valor predeterminado es cero, es decir, el valor de (byte) 0 .
  • Para el tipo abreviado , el valor predeterminado es cero, es decir, el valor de (corto) 0 .
  • Para tipo int , el valor predeterminado es cero, es decir, 0 .
  • Para tipo largo , el valor predeterminado es cero, es decir, 0L .
  • Para tipo flotante , el valor predeterminado es cero positivo, es decir, 0.0f .
  • Para el tipo doble , el valor predeterminado es cero positivo, es decir, 0.0d .
  • Para el tipo char , el valor predeterminado es el carácter nulo, es decir, ‘\ u0000’ .
  • Para tipo booleano , el valor predeterminado es falso .
  • Para todos los tipos de referencia, el valor predeterminado es nulo .

Sí. Los tipos primitivos en Java siempre se inicializan en cero. Las referencias también se inicializan a nulo.

Debe ser la especificación de lenguaje Java §4.12.5 Valores iniciales de variables . en lugar de §4.5.5

“Para tipo byte, el valor predeterminado es cero, es decir, el valor de (byte) 0.
Para el tipo abreviado, el valor predeterminado es cero, es decir, el valor de (corto) 0.
Para tipo int, el valor predeterminado es cero, es decir, 0.
Para tipo largo, el valor predeterminado es cero, es decir, 0L.
Para tipo flotante, el valor predeterminado es cero positivo, es decir, 0.0f.
Para el tipo doble, el valor predeterminado es cero positivo, es decir, 0.0d.
Para el tipo char, el valor predeterminado es el carácter nulo, es decir, ‘\ u0000’.
Para tipo booleano, el valor predeterminado es falso.
Para todos los tipos de referencia (§4.3), el valor predeterminado es nulo. ”

¡Tu libro de texto está equivocado! Escribir dicho código no tiene sentido, y es una pérdida de tiempo tipearlo y que las computadoras lo ejecuten.

Como han dicho otros, el comstackdor garantiza que las variables que están fuera de los métodos (variables de clase / instancia) reciben un valor de 0, falso o nulo. Como probablemente sepa, el comstackdor no proporciona variables dentro de los valores de los métodos y, en su lugar, le obliga a darles un valor antes de que se utilicen.

Si hace las cosas “bien”, encontrará que entre el 90% y el 95% de sus “variables” nunca cambian después de recibir un valor. Sin embargo, los progtwigdores nuevos tienden a hacer cosas como esta:

 int x = 0; // some code that never uses x x = 5; // more code that only reads x and never modifies it. 

esto le impide marcar x como “final”. Si puede marcar x como “final”, entonces evita la modificación accidental del valor, lo que evita errores.

Escribiría el código como:

 final int x; // some code that never uses x x = 5; // more code that only reads x and never modifies it. 

Esto se denomina final en blanco (una variable final que no tiene un valor cuando se declara).

Si recuerda que las variables de clase / instancia son inicializadas por el tiempo de ejecución entonces, con suerte, no escribirá el código para inicializarlas con los valores desechables, y luego podrá marcarlas como definitivas.

Mi práctica personal es marcar siempre todo como final hasta que encuentre que necesito modificarlo, y nunca inicializar una variable hasta que sepa el valor real que quiero que tenga. Hacer esto hace que el código sea más rápido (no se nota ya que las tareas son generalmente muy rápidas) y más seguro ya que rara vez modifico accidentalmente un valor cuando no debería hacerlo.