Respostas:
Eles são semanticamente idênticos. A int array[]
sintaxe foi adicionada apenas para ajudar os programadores C a se acostumarem ao java.
int[] array
é muito preferível e menos confuso.
int array[]
sintaxe. Também lógico ... de alguma maneira distorcida. :)
int array[]
faz mais sentido para mim. O que você acha dessa declaração? int[] x, y
? É y
uma matriz ou não? Talvez seja, talvez não seja. Gurus única do Java pode responder com confiança ....
int[] x, y
, y
é uma matriz (porque []
pertence ao tipo) e, no caso de int x[], y
, y
não é uma matriz ( []
pertence à variável).
Há uma pequena diferença, se você declarar mais de uma variável na mesma declaração:
int[] a, b; // Both a and b are arrays of type int
int c[], d; // WARNING: c is an array, but d is just a regular int
Observe que este é um estilo de codificação ruim, embora o compilador quase certamente capte seu erro no momento em que você tentar usar d
.
Não há diferença.
Eu prefiro o type[] name
formato em é claro que a variável é uma matriz (menos olhando ao redor para descobrir o que é).
EDITAR:
Oh, espere, há uma diferença (eu esqueci porque nunca declaro mais de uma variável por vez):
int[] foo, bar; // both are arrays
int foo[], bar; // foo is an array, bar is an int.
Não, são os mesmos. Contudo
byte[] rowvector, colvector, matrix[];
é equivalente a:
byte rowvector[], colvector[], matrix[][];
Retirado da especificação Java . Isso significa que
int a[],b;
int[] a,b;
são diferentes. Eu não recomendaria nenhuma dessas múltiplas declarações. A leitura mais fácil (provavelmente) seria:
int[] a;
int[] b;
Na seção 10.2 da especificação da linguagem Java :
O [] pode aparecer como parte do tipo no início da declaração, ou como parte do declarador para uma variável específica, ou ambas, como neste exemplo:
byte[] rowvector, colvector, matrix[];
Esta declaração é equivalente a:
byte rowvector[], colvector[], matrix[][];
Pessoalmente, quase todo o código Java que eu já vi usa a primeira forma, o que faz mais sentido, mantendo todas as informações de tipo sobre a variável em um só lugar. Eu gostaria que a segunda forma não fosse permitida, para ser honesto ... mas tal é a vida ...
Felizmente, acho que nunca vi esse código (válido):
String[] rectangular[] = new String[10][10];
int[] a[];
- isso nunca ficará claro ;-)
Os dois comandos são a mesma coisa.
Você pode usar a sintaxe para declarar vários objetos:
int[] arrayOne, arrayTwo; //both arrays
int arrayOne[], intOne; //one array one int
consulte: http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html
Não faz diferença.
Citações da Sun :
O
[]
podem aparecer como parte do tipo no início da declaração, ou como parte do Declarador para uma variável em particular, ou ambos, como neste exemplo:byte[] rowvector, colvector, matrix[];
Esta declaração é equivalente a:
byte rowvector[], colvector[], matrix[][];
Não há diferença entre os dois; ambos declaram uma matriz de int
s. No entanto, o primeiro é preferido, pois mantém as informações de tipo em um só lugar. O último só é realmente suportado em benefício dos programadores de C / C ++ que se mudam para Java.
Não há diferença real; Contudo,
double[] items = new double[10];
é preferido, pois indica claramente que o tipo é uma matriz.
Ambos são igualmente válidos. A int puzzle[]
forma é, contudo, desencorajados, a int[] puzzle
é o preferido de acordo com as convenções de codificação . Veja também o tutorial oficial sobre matrizes Java :
Da mesma forma, você pode declarar matrizes de outros tipos:
byte[] anArrayOfBytes; short[] anArrayOfShorts; long[] anArrayOfLongs; float[] anArrayOfFloats; double[] anArrayOfDoubles; boolean[] anArrayOfBooleans; char[] anArrayOfChars; String[] anArrayOfStrings;
Você também pode colocar colchetes após o nome da matriz:
float anArrayOfFloats[]; // this form is discouraged
No entanto, a convenção desencoraja esse formulário; os colchetes identificam o tipo de matriz e devem aparecer com a designação de tipo.
Observe o último parágrafo.
Eu recomendo a leitura dos tutoriais oficiais da Sun / Oracle em vez de alguns de terceiros. Caso contrário, você correria o risco de aprender más práticas.
É uma forma alternativa, que foi emprestada de C
, no qual o java é baseado.
Como curiosidade, existem três maneiras de definir um main
método válido em java:
public static void main(String[] args)
public static void main(String args[])
public static void main(String... args)
public static void main ( String \u005B \u005D args )
, essa também é outra variante.
String... param
, é uma matriz
, then why it is not possible to call a method like say
someMethod (1, 2) `se alguém estiver definindo someMethod
como someMethod ( int[] numbers )
. As matrizes exigem que o argumento deva ser do local contíguo da memória, porém varargs
, criarão uma matriz com os argumentos fornecidos primeiro. Além disso, a varargs
pode ser apenas o argumento final de um método, embora o mesmo não seja verdadeiro para uma matriz.
meth(int... a)
pode ser chamado como meth(1, 2)
ou meth(new int[] {1, 2})
. Varargs é o açúcar sintático que transforma a primeira versão na segunda. O tipo real (bytecode) do parâmetro é um tipo de matriz. Quanto a ter que ser o último, se você pensar bem, não há outra escolha sensata.
A especificação da linguagem Java diz:
The [] may appear as part of the type at the beginning of the declaration,
or as part of the declarator for a particular variable, or both, as in this
example:
byte[] rowvector, colvector, matrix[];
This declaration is equivalent to:
byte rowvector[], colvector[], matrix[][];
Assim, eles resultarão exatamente no mesmo código de bytes.
Eles são completamente equivalentes. int [] array
é o estilo preferido. int array[]
é fornecido apenas como um estilo compatível com C equivalente.
Ambos têm o mesmo significado. No entanto, a existência dessas variantes também permite isso:
int[] a, b[];
que é o mesmo que:
int[] a;
int[][] b;
No entanto, esse é um estilo de codificação horrível e nunca deve ser feito.
Eles são os mesmos, mas há uma diferença importante entre estas declarações:
// 1.
int regular, array[];
// 2.
int[] regular, array;
em 1. regular é apenas um int, em oposição a 2. onde regular e array são matrizes de int.
A segunda afirmação que você possui é, portanto, preferida, pois é mais clara. O primeiro formulário também é desencorajado de acordo com este tutorial no Oracle .
Como já foi dito, não há muita diferença (se você declarar apenas uma variável por linha).
Observe que o SonarQube trata seu segundo caso como um pequeno cheiro de código:
Os designadores de matriz "[]" devem estar no tipo, não na variável (squid: S1197)
Os designadores de matriz sempre devem estar localizados no tipo para melhor legibilidade do código. Caso contrário, os desenvolvedores devem examinar o tipo e o nome da variável para saber se uma variável é ou não uma matriz.
Exemplo de código não conforme
int matrix[][]; // Noncompliant int[] matrix[]; // Noncompliant
Solução compatível
int[][] matrix; // Compliant
Sim, exatamente o mesmo. Pessoalmente, eu prefiro
int[] integers;
porque torna imediatamente óbvio para quem lê seu código que números inteiros são uma matriz de int's, em oposição a
int integers[];
o que não torna tudo tão óbvio, principalmente se você tiver várias declarações em uma linha. Mas, novamente, eles são equivalentes, então tudo se resume à preferência pessoal.
Confira esta página em matrizes em Java para obter exemplos mais detalhados.
ao declarar uma única referência de matriz, não há muita diferença entre elas. portanto, as duas declarações a seguir são iguais.
int a[]; // comfortable to programmers who migrated from C/C++
int[] a; // standard java notation
ao declarar várias referências de matriz, podemos encontrar diferença entre elas. as duas declarações a seguir significam o mesmo. de fato, cabe ao programador qual deles seguir. mas a notação java padrão é recomendada.
int a[],b[],c[]; // three array references
int[] a,b,c; // three array references
Embora a int integers[]
solução tenha raízes na linguagem C (e, portanto, possa ser considerada a abordagem "normal"), muitas pessoas acham int[] integers
mais lógico, pois não permite criar variáveis de tipos diferentes (por exemplo, int e array) em uma declaração (em oposição a a declaração de estilo C).