Différence entre int [] array et int array []

https://stackoverflow.com/questions/129178

arrays
java

02-07-2019
|

Question

J'ai récemment réfléchi à la différence entre les deux façons de définir un tableau:

int [] array
int array []

Y a-t-il une différence?

La solution

Ils sont sémantiquement identiques. La syntaxe int array [] n'a été ajoutée que pour aider les programmeurs C à s'habituer à Java.

int [] array est préférable et moins source de confusion.

Autres conseils

Il existe une légère différence si vous déclarez plusieurs variables dans la même déclaration:

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

Notez qu'il s'agit d'un mauvais style de codage, bien que le compilateur capte très certainement votre erreur lorsque vous essayez d'utiliser d .

Il n'y a pas de différence.

Je préfère le format type [] nom . Il est clair que la variable est un tableau (moins de recherche pour savoir ce que c'est).

EDIT:

Oh, attendez, il y a une différence (j'ai oublié car je ne déclare jamais plus d'une variable à la fois):

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

Non, ce sont les mêmes. Cependant

byte[] rowvector, colvector, matrix[];

est équivalent à:

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

Extrait de la spécification Java . Cela signifie que

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

sont différents. Je ne recommanderais aucune de ces déclarations multiples. Le plus facile à lire serait (probablement):

int[] a;
int[] b;

De la section 10.2 de la spécification du langage Java :

Le [] peut apparaître en tant que partie du type au début de la déclaration, ou en tant que partie du déclarant d'une variable particulière, ou les deux, comme dans cet exemple:
 byte[] rowvector, colvector, matrix[];
Cette déclaration équivaut à:
byte rowvector[], colvector[], matrix[][];

Personnellement, presque tout le code Java que j'ai vu utilise le premier formulaire, ce qui est plus logique en conservant toutes les informations de type relatives à la variable au même endroit. Je souhaite que la seconde forme soit rejetée, pour être honnête ... mais telle est la vie ...

Heureusement, je ne pense pas avoir jamais vu ce code (valide):

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

Les deux commandes sont la même chose.

Vous pouvez utiliser la syntaxe pour déclarer plusieurs objets:

int[] arrayOne, arrayTwo; //both arrays

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

voir: http: //java.sun. com / docs / books / jls / seconde_edition / html / arrays.doc.html

Aucune différence.

Citation de Sun :

Le [] peut apparaître en tant que partie du type au début de la déclaration, ou en tant que partie du déclarateur d'une variable particulière, ou des deux, comme dans cet exemple: octet [] vecteur de ligne, vecteur de vecteur, matrice [];

Cette déclaration est équivalente à:    octet vecteur de rangée [], colvector [], matrice [] [];

Il n'y a pas de différence entre les deux. les deux déclarent un tableau de int s. Cependant, le premier est préférable car il conserve les informations de type au même endroit. Ce dernier n’est vraiment supporté que pour le bénéfice des programmeurs C / C ++ qui passent à Java.

Il n'y a pas de réelle différence. cependant,

double[] items = new double[10];

est préféré car il indique clairement que le type est un tableau.

Les deux sont également valables. La forme int puzzle [] est toutefois déconseillée, le int [] puzzle est préférable selon le conventions de codage . Voir également le didacticiel sur les tableaux Java :

De même, vous pouvez déclarer des tableaux d'autres types:
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
Vous pouvez également placer les crochets après le nom du tableau:
float anArrayOfFloats[]; // this form is discouraged
Cependant, la convention décourage cette forme; les crochets identifient le type de tableau et doivent apparaître avec la désignation du type.

Notez le dernier paragraphe.

Je vous recommande de lire les didacticiels officiels Sun / Oracle plutôt que ceux de tiers. Sinon, vous risqueriez de finir par apprendre de mauvaises pratiques.

Il s'agit d'une forme alternative empruntée à C , sur laquelle java est basé.

Par curiosité, il existe trois façons de définir une méthode principale valide en java:

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

Il n'y a pas de différence, mais Sun recommande de le placer à côté du type, comme expliqué ci-après. ici

L'option préférée est int [] a - car int [] correspond au type et à au nom. (votre deuxième option est la même que celle-ci, avec un espace mal placé)

Sur le plan fonctionnel, il n'y a pas de différence entre eux.

La Spécification du langage Java dit:

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

Ils se traduiront donc exactement par le même code d'octet.

En Java, ce sont simplement des méthodes syntaxiques différentes pour dire la même chose.

Ils sont les mêmes. L’un est plus lisible (pour certains) que l’autre.

Ils sont complètement équivalents. int [] array est le style préféré. int array [] est simplement fourni en tant que style équivalent compatible C.

Les deux ont la même signification. Cependant, l’existence de ces variantes permet également ceci:

int[] a, b[];

qui est identique à:

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

Cependant, c'est un style de code horrible et ne devrait jamais être fait.

Il n’existe aucune différence de fonctionnalité entre les deux styles de déclaration. Les deux déclarent un tableau d'int.

Mais int [] a conserve les informations de type ensemble et est plus détaillé, donc je la préfère.

Ce sont les mêmes, mais il y a une différence importante entre ces déclarations:

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

dans 1. regular est juste un int, par opposition à 2. où regular et array sont des tableaux d'int. "

La deuxième déclaration que vous avez est donc préférable, car elle est plus claire. Le premier formulaire est également déconseillé selon ce didacticiel sur Oracle .

Comme déjà indiqué, il n'y a pas beaucoup de différence (si vous déclarez une seule variable par ligne).

Notez que SonarQube traite votre deuxième cas comme une odeur de code mineure:

Indicateurs de tableau "[] " devrait être sur le type, pas la variable (calmar: S1197)

Les indicateurs de tableau doivent toujours être situés sur le type pour un meilleur code   lisibilité. Sinon, les développeurs doivent examiner à la fois le type et le   nom de variable pour savoir si une variable est un tableau ou non.

Exemple de code non conforme
int matrix[][];   // Noncompliant
int[] matrix[];   // Noncompliant
Solution conforme
int[][] matrix;   // Compliant

Oui, exactement la même chose. Personnellement, je préfère

int[] integers;

car il est immédiatement évident pour quiconque lisant votre code que des entiers est un tableau d'entiers, par opposition à

int integers[];

ce qui ne rend pas tout cela si évident, en particulier si vous avez plusieurs déclarations dans une ligne. Mais encore une fois, ils sont équivalents, cela revient donc à vos préférences personnelles.

Découvrez cette page sur des tableaux en Java pour des exemples plus détaillés.

lors de la déclaration d'une seule référence de tableau, il n'y a pas beaucoup de différence entre elles. les deux déclarations suivantes sont donc identiques.

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

lors de la déclaration de plusieurs références de tableau, nous pouvons trouver une différence entre elles. les deux déclarations suivantes ont la même signification. en fait, c'est au programmeur de choisir lequel est suivi. mais la notation standard Java est recommandée.

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

Les deux vont bien. Je suggère d'en choisir un et de s'en tenir à cela. (Je fais le second)

Alors que la solution int integers [] trouve ses racines dans le langage C (et peut donc être considérée comme l'approche "normale"), de nombreuses personnes trouvent int [] integers . plus logique car il ne permet pas de créer des variables de types différents (c'est-à-dire un int et un tableau) dans une déclaration (par opposition à la déclaration de style C).

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow