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 syntax int array[] 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 

Nota che questo è uno stile di codifica errato, anche se il compilatore quasi sicuramente colpirà il tuo errore nel momento in cui proverai a usare d .

Non c’è differenza.

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

MODIFICARE:

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

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

No, questi sono gli stessi. però

 byte[] rowvector, colvector, matrix[]; 

è equivalente a:

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

Tratto da specifica Java . Ciò significa che

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

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

 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 è equivalente a:

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

Personalmente quasi tutto il codice Java che ho visto utilizza la prima forma, che ha più senso mantenendo tutte le informazioni sul tipo della variabile in un unico punto. Vorrei che la seconda forma fosse respinta, a dire il vero … ma tale è la vita …

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

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

I due comandi sono la stessa cosa.

È ansible utilizzare la syntax per dichiarare più oggetti:

 int[] arrayOne, arrayTwo; //both arrays int arrayOne[], intOne; //one array one int 

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

Nessuna differenza.

Citando da Sun :

[] 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 è equivalente a: byte rowvector[], colvector[], matrix[][];

Non c’è una vera differenza; però,

 double[] items = new double[10]; 

è preferito in quanto indica chiaramente che il tipo è un array.

Non c’è alcuna differenza tra i due; entrambi dichiarano una matrice di int s. Tuttavia, il primo è preferito in quanto mantiene tutte le informazioni sul tipo in un’unica posizione. Quest’ultimo è supportato solo a beneficio dei programmatori C / C ++ che si spostano su Java.

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

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

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

Entrambi sono ugualmente validi. La forma di int puzzle[] è tuttavia scoraggiata, l’ int[] puzzle è preferito secondo le convenzioni di codifica . Vedi anche il tutorial ufficiale sugli array 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 matrice e dovrebbero apparire con la designazione del tipo.

Nota l’ultimo paragrafo.

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

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

L’opzione più preferita è int[] a – perché int[] è il tipo e a è il nome. (la tua seconda opzione è la stessa, con spazio fuori posto)

Funzionalmente non c’è differenza tra loro.

La specifica del linguaggio Java dice:

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

In questo modo si otterrà esattamente lo stesso codice byte.

Sono uguali, 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 normale 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 .

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

Non c’è differenza di funzionalità tra entrambi gli stili di dichiarazione. Entrambi dichiarano la matrice di int.

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

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

Nota che SonarQube tratta il tuo secondo caso come un odore di codice minore :

I designatori di matrice “[]” dovrebbero essere sul tipo, non sulla variabile (calamaro: S1197)

I designatori di array devono essere sempre posizionati sul tipo per una migliore leggibilità del codice. In caso contrario, gli sviluppatori devono cercare sia il tipo che il nome della variabile per sapere se una variabile è o meno una matrice.

Esempio di codice non conforms

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

Soluzione conforms

 int[][] matrix; // Compliant 

Sono uguali. Uno è più leggibile (per alcuni) rispetto agli altri.

Sono completamente equivalenti. int [] array è lo stile preferito. int array[] è appena fornito come equivalente, stile 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 codice orribile e non dovrebbe mai essere fatto.

Sì, esattamente lo stesso. Personalmente, preferisco

 int[] integers; 

perché rende immediatamente ovvio a chiunque legge il tuo codice che gli interi sono una matrice di int, al contrario di

 int integers[]; 

che non rende tutto così ovvio, in particolare se si hanno più dichiarazioni in una riga. Ma ancora, sono equivalenti, quindi si tratta di preferenze personali.

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

quando si dichiara un riferimento a un solo 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 differenze tra loro. le seguenti due affermazioni significano lo stesso. infatti, spetta al programmatore qual è il seguito. ma è raccomandata 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 di seguirlo. (Faccio il secondo)

Mentre la radice int integers[] radica nel linguaggio C (e può quindi essere considerato l’approccio “normale”), molte persone trovano int[] integers più logici in quanto non consente di creare variabili di tipi diversi (cioè un int e un array ) in una dichiarazione (al contrario della dichiarazione in stile C).