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

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

1. int[] array
2. int array[]

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

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

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

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

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.

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

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

РЕДАКТИРОВАТЬ:

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

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

Нет, это одно и то же. тем не мение

byte[] rowvector, colvector, matrix[];

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

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

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

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

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

int[] a;
int[] b;

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

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

 byte[] rowvector, colvector, matrix[];

Эта декларация эквивалентна:

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

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

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

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

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

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

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

Нет разницы.

Цитата из Солнца :

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

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

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

Здесь нет никакой разницы; тем не мение,

double[] items = new double[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, а не некоторые сторонние. В противном случае вы рискуете получить плохую практику.

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

Любопытно, что есть три способа определения допустимого mainметода в Java:

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

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

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

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

Спецификация языка 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[][];

Таким образом, они приведут к абсолютно одинаковому байт-коду.

В Java это просто разные синтаксические способы сказать одно и то же.

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

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

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

int[] a, b[];

что так же, как:

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

Тем не менее, это ужасный стиль кодирования и никогда не должно быть сделано.

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

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

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

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

в 1. регулярный - просто целое число, в отличие от 2. где регулярный и массив - это массивы целых чисел.

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

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

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

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

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

Пример несовместимого кода

int matrix[][];   // Noncompliant
int[] matrix[];   // Noncompliant

Совместимое решение

int[][] matrix;   // Compliant

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

int[] integers; 

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

int integers[];

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

Проверьте эту страницу о массивах в Java для более подробных примеров.

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

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

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

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