Différence entre un tableau int [] et un tableau int []

234

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

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

Y a-t-il une différence?

mslot
la source

Réponses:

282

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

int[] array est beaucoup préférable et moins déroutant.

skaffman
la source
55
Le [] fait partie du TYPE, pas du NOM. Pour moi, c'est la plus grande différence.
André Chalella
4
@Andre - et en C, le [] sa partie du déclarant, pas le spécificateur de déclaration, d'où la int array[]syntaxe. Aussi logique ... d'une manière tordue. :)
Kos
1
C joue à ce petit jeu :) Et je le trouve charmant :) Même avec des pointeurs comme ... La syntaxe c «correcte» pour les pointeurs est int * imAPointer. C'est idiot et net.
ScarletAmaranth
4
int array[]est plus logique pour moi. Que pensez-vous de cette déclaration? int[] x, y? Est-ce yun tableau ou non? Peut-être que oui, peut-être que non. Seuls les gourous de Java peuvent répondre en toute confiance ....
user1508893
24
Dans le cas de int[] x, y, yest un tableau (car []appartient au type), et dans le cas de int x[], y, yn'est pas un tableau ( []appartient à la variable).
Triang3l
172

Il y a 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 que c'est un mauvais style de codage, bien que le compilateur détecte presque certainement votre erreur au moment où vous essayez d'utiliser d.

Adam Rosenfield
la source
52

Il n'y a pas de différence.

Je préfère le type[] nameformat à c'est clair que la variable est un tableau (moins en regardant autour pour savoir ce que c'est).

ÉDITER:

Oh attends 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.
TofuBeer
la source
27

Non, ce sont les mêmes. toutefois

byte[] rowvector, colvector, matrix[];

est équivalent à:

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

Tiré de la spécification Java . Cela veut dire 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;
Ishtar
la source
3
Il est toutefois recommandé d'utiliser une seule déclaration par identifiant au lieu de déclarer plusieurs identifiants sur une seule ligne.
rsp
@rsp - Tout à fait d'accord, a édité une meilleure pratique dans. Pourtant, il est suggestif de ce qu'est une bonne pratique.
Ishtar
25

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

Le [] peut apparaître comme faisant partie du type au début de la déclaration, ou comme faisant partie du déclarant pour 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 jamais vu utilise le premier formulaire, ce qui est plus logique en conservant toutes les informations de type sur la variable en un seul endroit. J'aimerais que la deuxième forme soit refusé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];
Jon Skeet
la source
Merci, je me grattais la tête à ce sujet. Curieusement, en cherchant le titre de la question sur Google, je n'ai rien trouvé ...
Yoav
3
+1 Je suis d'accord pour interdire le deuxième formulaire. +1 aussi parce que je ne savais pas que vous pouviez mélanger des matchs comme int[] a[];- ça ne sera jamais clair ;-)
Bohème
13

Aucune différence.

Citant Sun :

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

Cette déclaration équivaut à: byte rowvector[], colvector[], matrix[][];

Yuval Adam
la source
11

Il n'y a aucune différence entre les deux; déclarent tous deux un tableau de ints. Cependant, le premier est préféré car il conserve les informations de type en un seul endroit. Ce dernier n'est vraiment pris en charge que pour les programmeurs C / C ++ qui migrent vers Java.

Luke Woodward
la source
11

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

double[] items = new double[10];

est préférable car elle indique clairement que le type est un tableau.

Aaron Maenpaa
la source
1
les éléments doubles [] sont vraiment là pour les programmeurs C
Steve Kuo
@Steve, Ce doit être la raison pour laquelle je continue de le faire de cette façon. :-)
Paul Tomblin
Un contre-argument peut être avancé selon lequel les éléments doubles [] indiquent clairement le type et plus tard que les éléments se trouvent être un tableau - tout dépend de ce que vous êtes à l'aise.
MetroidFan2002
7

Les deux sont également valables. La int puzzle[]forme est cependant déconseillée, la int[] puzzleest préférée selon les conventions de codage . Voir également le didacticiel officiel des 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 recommande de lire les didacticiels officiels Sun / Oracle plutôt que ceux de tiers. Sinon, vous risqueriez de finir par apprendre de mauvaises pratiques.

BalusC
la source
6

C'est une forme alternative, qui a été empruntée C, sur laquelle Java est basé.

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

  • public static void main(String[] args)
  • public static void main(String args[])
  • public static void main(String... args)
Bohème
la source
1
Avec tout le respect que je vous dois, mais cette question est-elle la question !!!!! Est-ce que le troisième formulaire, spécifié, doit réellement faire quoi que ce soit, avec ce qui est demandé dans le message d'origine. Les deux premiers arguments sont des tableaux de la méthode principale, bien que la troisième entité soit un argument variable (qui n'est pas identique à un tableau). Si la définition de la méthode principale est la question, alors on peut ajouter un autre formulaire pour définir également une méthode principale, comme public static void main ( String \u005B \u005D args ), c'est une autre variante aussi.
nIcE cOw
2
@nIcEcOw un paramètre varargs, par exemple String... param, est un tableau
Bohème
Un simple doute se pose, si les deux sont des tableaux, c'est-à-dire String [] et String ... , then why it is not possible to call a method like say someMethod (1, 2) `si l'on définit someMethodas someMethod ( int[] numbers ). Cependant, les tableaux exigent que l'argument, qui doit provenir d'un emplacement de mémoire contigu, crée d'abord varargsun tableau à partir des arguments fournis. De plus, a varargsne peut être que l'argument final d'une méthode, bien qu'il n'en soit pas de même pour un tableau.
nIcE cOw
2
@nIcEcOw mais vous pouvez appeler un varargs avec un tableau, c'est à dire meth(int... a)peut être appelé comme meth(1, 2)ou meth(new int[] {1, 2}). Varargs est un sucre syntaxique qui transforme la première version en deuxième version. Le type réel (bytecode) du paramètre est un type tableau. Quant à être le dernier, si vous y réfléchissez, il n'y a pas d'autre choix sensé.
Bohème
5

Il n'y a pas de différence, mais Sun recommande de le mettre à côté du type comme expliqué ici

André
la source
3

L'option la plus préférée est int[] a- car int[]est le type et ale nom. (votre 2e option est la même que celle-ci, avec un espace mal placé)

Fonctionnellement, il n'y a aucune différence entre eux.

Bozho
la source
3

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

Ainsi, ils donneront exactement le même code d'octet.

Kdeveloper
la source
2

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

Zach Lute
la source
2

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

basszero
la source
2

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

Parc Derek
la source
2

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

int[] a, b[];

ce qui équivaut à:

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

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

Michael Borgwardt
la source
vous voulez dire, int [] a, b []; b devient un tableau multidimensionnel
sadananda salam
2

Il n'y a 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 verbeux, donc je le préfère.

YoK
la source
2

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, contrairement à 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 tutoriel sur Oracle .

Patrick
la source
Merci à tous! J'irai avec le second et je m'en tiendrai.
Espen
2

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 mineur :

Les désignateurs de tableau "[]" doivent être sur le type, pas sur la variable (squid: S1197)

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

Exemple de code non conforme

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

Solution conforme

int[][] matrix;   // Compliant
Robert Hume
la source
1

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

int[] integers; 

car il est immédiatement évident pour quiconque lit votre code que les entiers sont un tableau d'int

int integers[];

ce qui ne rend pas tout cela évident, en particulier si vous avez plusieurs déclarations sur une seule ligne. Mais encore une fois, ils sont équivalents, il s'agit donc de préférences personnelles.

Consultez cette page sur les tableaux en Java pour des exemples plus détaillés.

David Watson
la source
1

lors de la déclaration d'une seule référence de tableau, il n'y a pas beaucoup de différence entre elles. donc les deux déclarations suivantes sont 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 signifient la même chose. en fait, c'est au programmeur que l'on doit suivre. mais la notation java standard est recommandée.

int a[],b[],c[]; // three array references
int[] a,b,c;  // three array references
PoornaChandra
la source
0

Les deux sont bons. Je suggère d'en choisir un et de le respecter. (Je fais le second)

Albert
la source
0

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

Kos
la source