Differenza tra int [] array e int array []

Di recente ho pensato alla differenza tra i due modi di definire un array:

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

C'è una differenza?

Sono semanticamente identici. La int array[]sintassi è stata aggiunta solo per aiutare i programmatori C ad abituarsi a Java.

int[] array è molto preferibile e meno confuso.

C'è una leggera differenza, se ti capita di dichiarare più di una variabile nella stessa dichiarazione:

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

Si noti che questo è un cattivo stile di codifica, sebbene il compilatore quasi sicuramente rileverà il tuo errore nel momento in cui proverai a usarlo d.

Non c'è differenza.

Preferisco il type[] name formato sia chiaro che la variabile è un array (meno guardandosi intorno per scoprire di cosa si tratta).

MODIFICARE:

Oh aspetta c'è una differenza (ho dimenticato perché non dichiaro mai più di una variabile alla volta):

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

No, sono uguali. però

byte[] rowvector, colvector, matrix[];

è equivalente a:

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

Tratto dalle specifiche Java . Ciò significa che

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

sono diversi. Non consiglierei nessuna di queste dichiarazioni multiple. Il più facile da leggere sarebbe (probabilmente):

int[] a;
int[] b;

Dalla sezione 10.2 della specifica del linguaggio Java :

[] Può apparire come parte del tipo all'inizio della dichiarazione o come parte del dichiaratore per una particolare variabile o entrambi, come in questo esempio:

 byte[] rowvector, colvector, matrix[];

Questa dichiarazione equivale a:

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

Personalmente quasi tutto il codice Java che abbia mai visto utilizza il primo modulo, il che ha più senso mantenendo tutte le informazioni sul tipo della variabile in un unico posto. Vorrei che la seconda forma fosse vietata, a dire il vero ... ma tale è la vita ...

Fortunatamente non credo di aver mai visto questo codice (valido):

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

I due comandi sono la stessa cosa.

È possibile utilizzare la sintassi per dichiarare più oggetti:

int[] arrayOne, arrayTwo; //both arrays

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

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

Nessuna differenza.

Citando da Sun :

Il []simbolo può apparire come parte del tipo all'inizio della dichiarazione o come parte del dichiaratore per una particolare variabile o entrambi, come in questo esempio:byte[] rowvector, colvector, matrix[];

Questa dichiarazione equivale a: byte rowvector[], colvector[], matrix[][];

Non c'è alcuna differenza tra i due; entrambi dichiarano un array di ints. Tuttavia, il primo è preferito poiché conserva le informazioni sul tipo in un unico posto. Quest'ultimo è davvero supportato solo a vantaggio dei programmatori C / C ++ che si spostano su Java.

Non c'è vera differenza; però,

double[] items = new double[10];

è preferito poiché indica chiaramente che il tipo è un array.

Entrambi sono ugualmente validi. La int puzzle[]forma è comunque scoraggiata, int[] puzzleè preferita secondo le convenzioni di codifica . Vedi anche il tutorial ufficiale sulle matrici Java :

Allo stesso modo, puoi dichiarare matrici di altri tipi:

byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;

Puoi anche posizionare le parentesi quadre dopo il nome dell'array:

float anArrayOfFloats[]; // this form is discouraged

Tuttavia, la convenzione scoraggia questa forma; le parentesi identificano il tipo di array e devono apparire con la designazione del tipo.

Nota l'ultimo paragrafo.

Consiglio di leggere i tutorial ufficiali Sun / Oracle piuttosto che quelli di terze parti. Altrimenti rischieresti di imparare cattive pratiche.

È una forma alternativa, da cui è stata presa in prestito C, su cui si basa Java.

Come curiosità, ci sono tre modi per definire un mainmetodo valido in java:

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

Non c'è alcuna differenza, ma Sun consiglia di metterlo accanto al tipo come spiegato qui

L'opzione più preferita è int[] a- poiché int[]è il tipo ea è il nome. (la tua seconda opzione è la stessa di questa, con spazio fuori posto)

Funzionalmente non c'è differenza tra loro.

Le specifiche del linguaggio Java dicono:

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

Pertanto si tradurranno esattamente nello stesso codice byte.

In Java, questi sono semplicemente diversi metodi sintattici per dire la stessa cosa.

Sono uguali Uno è più leggibile (per alcuni) dell'altro.

Sono completamente equivalenti. int [] arrayè lo stile preferito. int array[]viene fornito solo come stile equivalente compatibile con C.

Entrambi hanno lo stesso significato. Tuttavia, l'esistenza di queste varianti consente anche questo:

int[] a, b[];

che è lo stesso di:

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

Tuttavia, questo è uno stile di programmazione orribile e non dovrebbe mai essere fatto.

Non c'è differenza nella funzionalità tra entrambi gli stili di dichiarazione. Entrambi dichiarano array di int.

Ma int[] a tiene insieme le informazioni sul tipo ed è più dettagliato quindi le preferisco.

Sono gli stessi, ma c'è una differenza importante tra queste affermazioni:

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

in 1. regular è solo un int, al contrario di 2. dove sia regular che array sono array di int.

La seconda affermazione che hai è quindi preferita, poiché è più chiara. Il primo modulo è anche scoraggiato secondo questo tutorial su Oracle .

Come già detto, non c'è molta differenza (se si dichiara solo una variabile per riga).

Si noti che SonarQube considera il secondo caso come un odore di codice minore :

I designatori di array "[]" dovrebbero essere sul tipo, non sulla variabile (calamari: S1197)

I designatori di array devono sempre trovarsi sul tipo per una migliore leggibilità del codice. Altrimenti, gli sviluppatori devono esaminare sia il tipo che il nome della variabile per sapere se una variabile è o meno un array.

Esempio di codice non conforme

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

Soluzione conforme

int[][] matrix;   // Compliant

Sì, esattamente lo stesso. Personalmente, preferisco

int[] integers; 

perché rende immediatamente ovvio a chiunque legga il tuo codice che numeri interi sono un array di int, al contrario di

int integers[];

il che non rende tutto così ovvio, in particolare se hai più dichiarazioni in una riga. Ma, di nuovo, sono equivalenti, quindi dipende dalle preferenze personali.

Dai un'occhiata a questa pagina sugli array in Java per esempi più approfonditi.

quando si dichiara un riferimento ad un singolo array, non c'è molta differenza tra loro. quindi le seguenti due dichiarazioni sono uguali.

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

quando dichiariamo più riferimenti di array, possiamo trovare delle differenze tra di loro. le seguenti due affermazioni significano lo stesso. in effetti, spetta al programmatore quale si segue. ma si consiglia la notazione java standard.

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

Entrambi sono ok. Suggerisco di sceglierne uno e attenersi ad esso. (Faccio il secondo)

Mentre la int integers[]soluzione affonda nel linguaggio C (e può quindi essere considerata l'approccio "normale"), molte persone trovano int[] integerspiù logico in quanto non consente di creare variabili di diversi tipi (cioè un int e un array) in una dichiarazione (al contrario di la dichiarazione in stile C).