Разница между массивом int [] и массивом int []

Недавно я думал о различии между двумя способами определения массива:

int[] array
int array[]

Есть ли разница?

Ответ 1

Они семантически идентичны. Синтаксис int array[] был добавлен только для того, чтобы помочь программистам C использовать java.

int[] array является гораздо предпочтительнее и менее запутанным.

Ответ 2

Есть одно небольшое различие, если вам приходится объявлять более одной переменной в одном объявлении:

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

Обратите внимание, что это плохой стиль кодирования, хотя компилятор почти наверняка поймает вашу ошибку в тот момент, когда вы пытаетесь использовать d.

Ответ 3

Нет никакой разницы.

Я предпочитаю формат type[] name at is is clear, что переменная является массивом (меньше оглядывается, чтобы узнать, что это такое).

EDIT:

О, подождите, есть разница (я забыл, потому что я никогда не объявлял больше одной переменной за раз):

int[] foo, bar; // both are arrays
int foo[], bar; // foo is an array, bar is an int.

Ответ 4

Нет, это то же самое. Однако

byte[] rowvector, colvector, matrix[];

эквивалентно:

byte rowvector[], colvector[], matrix[][];

Взято из Спецификация Java. Это означает, что

int a[],b;
int []a,b;

разные. Я бы не рекомендовал ни одно из этих множественных объявлений. Проще всего читать было бы (возможно):

int[] a;
int[] b;

Ответ 5

Из раздела 10.2 Спецификации языка Java:

[] может отображаться как часть типа в начале объявления или как часть декларатора для конкретной переменной или и того и другого, как в этом примере:
 byte[] rowvector, colvector, matrix[];
Это объявление эквивалентно:
byte rowvector[], colvector[], matrix[][];

Лично почти весь код Java, который я когда-либо видел, использует первую форму, что имеет большее значение, сохраняя всю информацию о типе переменной в одном месте. Я бы хотел, чтобы вторая форма была запрещена, если честно... но такова жизнь...

К счастью, я не думаю, что когда-либо видел этот (действительный) код:

String[] rectangular[] = new String[10][10];

Ответ 6

Две команды - одно и то же.

Синтаксис можно использовать для объявления нескольких объектов:

int[] arrayOne, arrayTwo; //both arrays

int arrayOne[], intOne; //one array one int

см. http://java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html

Ответ 7

Нет различий.

Цитата из Sun:

[] может отображаться как часть типа в начале объявления или как часть декларатора для конкретной переменной или обоих, как в этом примере: byte[] rowvector, colvector, matrix[];

Эта декларация эквивалентна: byte rowvector[], colvector[], matrix[][];

Ответ 8

Нет никакой реальной разницы; однако

double[] items = new double[10];

является предпочтительным, поскольку он явно указывает, что тип является массивом.

Ответ 9

Между ними нет никакой разницы; оба объявляют массив int s. Однако первый предпочтительнее, поскольку он сохраняет информацию о типе в одном месте. Последний поддерживается только в интересах программистов C/С++, перемещающихся на Java.

Ответ 10

Оба одинаково важны. Форма int puzzle[], однако, обескуражена, int[] puzzle является предпочтительным в соответствии с соглашениями об кодировании. См. Также официальный учебник по массивам Java:

Аналогично, вы можете объявлять массивы других типов:
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
Вы также можете поместить квадратные скобки после имени массива:
float anArrayOfFloats[]; // this form is discouraged
Однако конвенция препятствует этой форме; скобки идентифицируют тип массива и должны появляться с обозначением типа.

Обратите внимание на последний абзац.

Я рекомендую читать официальные учебники Sun/Oracle, а не некоторые сторонние. В противном случае вы рискуете оказаться в плохой практике.

Ответ 11

Это альтернативная форма, которая была заимствована из C, на которой основана Java.

Как любопытство, существует три способа определения допустимого метода main в java:

public static void main(String[] args)
public static void main(String args[])
public static void main(String... args)

Ответ 12

Нет никакой разницы, но Sun рекомендует помещать его рядом с типом, как описано здесь

Ответ 13

Наиболее предпочтительным вариантом является int[] a - потому что int[] - тип, а a - это имя. (ваш второй вариант совпадает с этим, с неуместным пространством)

Функционально нет никакой разницы между ними.

Ответ 14

В Java это просто разные синтаксические методы, говорящие одно и то же.

Ответ 15

Спецификация языка Java говорит:

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[][];

Таким образом, они приведут к точному одному и тому же байтовому коду.

Ответ 16

Нет никакой разницы в функциональности между обеими стилями объявления. Оба объявляют массив int.

Но int[] a сохраняет информацию о типе вместе и более подробный, поэтому я предпочитаю его.

Ответ 17

Они одинаковы, но между этими утверждениями существует важное различие:

// 1.
int regular, array[];
// 2.
int[] regular, array;

в 1. regular - это просто int, а не 2., где оба регулярных и массива являются массивами int.

Второе утверждение, которое у вас есть, поэтому предпочтительнее, поскольку это более понятно. Первая форма также обескуражена в соответствии с этим руководством по Oracle.

Ответ 18

Они одинаковы. Один из них более читабельен (для некоторых), чем другой.

Ответ 19

Они полностью эквивалентны. int [] array - предпочтительный стиль. int array[] предоставляется только как эквивалентный C-совместимый стиль.

Ответ 20

Оба имеют одинаковое значение. Однако существование этих вариантов также позволяет:

int[] a, b[];

что совпадает с:

int[] a;
int[][] b;

Однако это ужасный стиль кодирования и никогда не должен выполняться.

Ответ 21

Да, точно так же. Лично я предпочитаю

int[] integers;

потому что он сразу становится очевидным для любого, кто читает ваш код, что integers - это массив из int, а не

int integers[];

что не делает все это очевидным, особенно если у вас несколько объявлений в одной строке. Но опять же, они эквивалентны, поэтому это сводится к личным предпочтениям.

Ознакомьтесь с этой страницей на массивах в Java для более подробных примеров.

Ответ 22

Как уже было сказано, нет большой разницы (если вы объявляете только одну переменную на строку).

Обратите внимание, что SonarQube рассматривает ваш второй случай как небольшой запах кода:

Обозначения массива "[]" должны быть типа, а не переменной (squid: S1197)

Обозначения массива должны всегда располагаться на типе для лучшего кода читаемость. В противном случае разработчики должны смотреть как на тип, так и на имя переменной, чтобы узнать, является ли переменная массивом.

Несоответствующий пример кода
int matrix[][];   // Noncompliant
int[] matrix[];   // Noncompliant
Соответствующее решение
int[][] matrix;   // Compliant

Ответ 23

Оба в порядке. Я предлагаю выбрать один и придерживаться его. (Я делаю второй)

Ответ 24

Хотя решение int integers[] основывается на языке C (и поэтому может рассматриваться как "нормальный" подход), многие люди находят int[] integers более логичным, поскольку он запрещает создавать переменные разных типов (т.е. int и array) в одном объявлении (в отличие от объявления стиля C).

Ответ 25

при объявлении ссылки на один массив, между ними нет большой разницы. поэтому следующие два объявления одинаковы.

int a[];  // comfortable to programmers who migrated from C/C++
int[] a;  // standard java notation

при объявлении ссылок на несколько массивов мы можем найти разницу между ними. следующие два утверждения означают одно и то же. на самом деле, это зависит от программиста, за которым следуют. но рекомендуется стандартная нотация Java.

int a[],b[],c[]; // three array references
int[] a,b,c;  // three array references