Differenza tra int [] array e int array []

https://stackoverflow.com/questions/129178

arrays
java

02-07-2019
|

Domanda

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

int [] array
int array []

C'è una differenza?

Soluzione

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

int [] array è molto preferibile e meno confuso.

Altri suggerimenti

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 è un cattivo stile di codifica, sebbene il compilatore quasi sicuramente rileverà il tuo errore nel momento in cui provi a usare d .

Non c'è differenza.

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

EDIT:

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. Tuttavia

byte[] rowvector, colvector, matrix[];

è equivalente a:

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

Tratto da 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 :

Il [] 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 usa il primo modulo, 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 penso di aver mai visto questo codice (valido):

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

I due comandi sono la stessa cosa.

Puoi usare la sintassi per dichiarare più oggetti:

int[] arrayOne, arrayTwo; //both arrays

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

vedi: http: //java.sun. com / docs / libri / JLS / second_edition / html / arrays.doc.html

Nessuna differenza.

Citando da Sun :

Il [] 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 int . 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; tuttavia,

double[] items = new double[10];

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

Entrambi sono ugualmente validi. Il modulo int puzzle [] è comunque sconsigliato, il int [] puzzle è preferito secondo convenzioni di codifica . Vedi anche il tutorial 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 questo modulo; 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, 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)
vuoto statico pubblico principale (String args [])
vuoto statico pubblico principale (String ... args)

Non c'è alcuna 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 di questa, con spazio fuori posto)

Funzionalmente non c'è alcuna 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 tradurranno esattamente nello stesso codice byte.

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

Sono gli stessi. Uno è più leggibile (per alcuni) rispetto all'altro.

Sono completamente equivalenti. int [] array è lo stile preferito. int array [] è appena fornito come equivalente, compatibile con lo stile 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 mantiene insieme le informazioni sul tipo ed è più dettagliato quindi le preferisco.

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 regular che array sono array di int.

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

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

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

Designatori di array " [] " dovrebbe essere sul tipo, non sulla variabile (calamari: S1197)

I designatori di array devono sempre trovarsi sul tipo per un codice migliore   leggibilità. 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[];

che non lo rende tutto così ovvio, in particolare se hai più dichiarazioni in una riga. Ma, di nuovo, 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 singolo riferimento di array, non c'è molta differenza tra loro. quindi le seguenti due dichiarazioni sono le stesse.

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 soluzione int interi [] affonda nel linguaggio C (e può quindi essere considerata l'approccio "normale"), molte persone trovano int [] interi più logico in quanto non consente di creare variabili di diversi tipi (cioè un int e un array) in una dichiarazione (rispetto alla dichiarazione di tipo C).

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow