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

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?

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.

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.

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.

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;

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

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/second_edition/html/arrays.doc.html

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

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.

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.

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.

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)

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

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.

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.

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

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

Ils sont complètement équivalents. int [] arrayest 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[];

ce qui équivaut à:

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

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

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.

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 .

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

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.

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

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

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