Les avantages de tableaux

Comme je le vois, les avantages d'une liste sur un tableau sont assez évidentes:

  • Génériques fournir plus précis tapant: List<Integer>, List<? extends Number>, List<? super Integer>.
  • Une Liste de l'interface a un tas méthodes utiles: addAll, remove etc. Tandis que pour les tableaux de toutes les opérations standard à l'exception get/set doit être effectuée dans une procédure de manière en passant d'une méthode statique.
  • Collections proposent différentes implémentations comme ArrayList, LinkedList, unmodifieable et la synchronisation des listes, ce qui peut être caché sous une Liste commune de l'interface.
  • OOB contrôle de la longueur.

Que des inconvénients, je ne peux que parler de l'absence de sucre syntaxique et à l'exécution, vérification de type. Dans le même temps, l'appui de deux structures nécessite souvent l'aide de asList et toArray méthodes, ce qui rend le code moins lisible. Donc, je suis curieux de savoir s'il y a des avantages importants de l'utilisation des tableaux que je m'ennuie.

InformationsquelleAutor Vitalii Fedorenko | 2010-05-16
  1. 20

    Tableaux sont plus efficaces, à la fois en termes de temps de traitement et la mémoire de l'empreinte. Ceci s'applique en particulier si vous êtes d'exploitation sur les types primitifs, tels que int ou long, depuis List exige de tous les éléments pour être enveloppé dans un Object (comme Integer ou Long). Alors que le l'autoboxing fonctionnalités introduites par Java 5 réduit la quantité de code que vous avez besoin pour un tel emballage et de déballage, il ne supprime pas les problèmes de performances, comme wrapper objets sont encore en cours de création.

    Cependant, la plupart des applications n'ont probablement pas toutes les goulots d'étranglement des performances liées à ces problèmes, de sorte que dans la plupart des cas, List et d'autres collections devraient faire amende. Dans ces cas, la facilité de programmation l'emporte sur l'augmentation de la mémoire ou de l'utilisation de l'UC, et List est le bon choix.

    • +1: les Tableaux sont plus efficaces, mais vous n'avez généralement pas besoin de ça. Dans toutes les applications d'entreprise que j'ai écrit, il n'a jamais été un problème de performance qui pourrait être résolu par le remplacement des collections avec des tableaux. Seulement dans de nombreux calculs outils ai-je vu de la nécessité d'éviter d'emballage primitives et, par conséquent, le besoin de coller avec les tableaux.
    • D'accord, dans la plupart des situations, les collections de faire tout aussi bien.
    • Une grosse faille de java génériques est le manque de soutien pour les primitives. Au moins la troisième partie de la bibliothèque de mettre en œuvre les classes de collection pour les types primitifs, qui enlève au moins la surcharge de boxing et unboxing.
    • Les tableaux sont également mises en oeuvre directement dans le matériel sur de nombreux systèmes.
    InformationsquelleAutor markusk
  2. 12

    Si votre liste ne change pas souvent, les Listes d'ajouter beaucoup de poids supplémentaire à l'objet que vous n'utilisez jamais. Lorsque vous essayez d'exécuter quelque chose qui doit être optimisé, ce qui est utile. Ce poids supplémentaire rend aussi les choses plus lentement qu'ils ne le seraient avec juste des tableaux. Toutefois, sauf si vous savez que vous avez besoin de gains de matrices de vous donner, vous devez juste être à l'aide de Listes.

    • Je suppose que cela pourrait être résumée comme suit: Lorsque vous avez besoin de manipuler un groupe de nettement liées à des objets, utiliser des collections, sinon utiliser des tableaux.
    InformationsquelleAutor unholysampler
  3. 7

    Une chose que je n'ai pas vu mentionné ici: les tableaux peuvent avoir à N dimensions alors que les listes sont limités à un seul. Vous pouvez utiliser des listes de listes, mais la syntaxe (List<List<...>>) est beaucoup plus encombrant que le [][]

    InformationsquelleAutor Guillaume
  4. 5

    Vitesse. Les Collections sont un peu plus lentes que de simples tableaux: en interne, plus encore utiliser des tableaux, mais ont des couches supplémentaires de code autour de ceux-ci. Bien sûr, sauf si vous avez un besoin spécifique pour plus de performances, vous devez toujours utiliser des collections.

    Un autre petit avantage de tableaux, c'est qu'il pourrait être plus facile d'appeler variadic méthodes avec des tableaux. Cela ne devrait jamais être une raison principale pour en choisir un plus qu'un autre bien.

    InformationsquelleAutor doublep
  5. 4

    S'il y a des avantages importants de l'utilisation des tableaux que j'ai raté?

    Constante de temps d'accès à tout élément avec une très faible constante. Pour accéder à un élément de tableau en toute sécurité et ne prend que quelques instructions: un couple de charges, à comparer, et une branche. La branche est généralement près de 100% du temps, donc du matériel moderne, fait un excellent travail de prédiction.

    • J'aimerais mieux comprendre les instructions qui sont mentionnées ici, pourriez-vous suggérer une source pour moi de check-out? Merci.
    InformationsquelleAutor Norman Ramsey
  6. 2

    Je suppose que la réponse théorique est de ce tableau sont censés avoir de meilleures performances, car Générique collections ont des couches supplémentaires de l'abstraction. Personnellement, dans une application d'entreprise, je vois très peu de valeur à l'aide de Tableaux sur générique collections.

    InformationsquelleAutor Doobi
  7. 2

    En plus pour les autres réponses, il y a une subtile propriété de tableaux qui peuvent être considérés comme un avantage sur les listes. Il peut être illustré par le code suivant:

    //This works
Integer[] ints = new Integer[4];
Number[] nums = ints;
//This doesn't work
List<Integer> intList = new ArrayList<Integer>();
List<Number> numList = intList; //Does not compile
List<Number> numList2 = (List<Number>)intList; //Does not compile either

    Tout en un tableau d'une sous-classe EST un tableau de la super-classe, les listes de sous-classes ne sont PAS des listes de super-classes (et il y a une bonne raison à cela - les génériques aurait un type safery faille si c'était autorisé).

    • Et en fait, les tableaux ont un type de faille de sécurité, parce que c'est autorisé, mais la faille est détectée lors de l'exécution, pas le temps de compilation. J'ai pu suivre votre code avec nums[0] = new Double(8.9) et de dresser. Seulement au moment de l'exécution en serait-il de lever une exception.
    • Vous ne pouvez pas stocker toute instance de la super-classe de la classe array. Par conséquent, un tableau d'une sous-classe n'EST PAS un tableau d'une super-classe en fonction de la Principe de Substitution de Liskov. Mais ce n'est détectée lors de l'exécution, comme @Daniel a été noté.
    • Bien sûr. Les limitations dans le générique de code est conçu pour protéger contre les imprévus ClassCastException, tandis que les tableaux ne protègent pas contre les ArrayStoreException. Mais à partir du compilateur, point de vue, Integer[] EST un Nombre[], et le casting est autorisé, en supposant que le programmeur est conscient de la réelle type de tableau.
    • Liste<Integer> intList = new ArrayList<Integer>(); List<? s'étend Nombre> numList = intList; //fonctionne bien
    • Ah, mais c'est bien parce que, après que numList.add(new Double(8.9)) ne compile pas.
    • Voir les commentaires ci-dessus. Elle compile, mais jeter ArrayStoreException au moment de l'exécution. Les tableaux imposer moins de compiler des restrictions de temps (d'où l'apparente "avantage"), mais au prix d'une perte de runtime type de sécurité.
    • Je répond avec mon "ne compile pas" commentaire de Robert commentaire avec List<? extends Number>.

    InformationsquelleAutor Eyal Schneider
  8. 1

    Les tableaux sont mieux dans les situations suivantes:

    • vous savez que vous allez travailler avec un nombre fixe d'éléments dans le tableau
    • vous n'avez pas besoin de changer la taille de la matrice

    Tableaux sont:

    • plus vite que n'importe quelle Collection

    Collections semblable à la Matrice:

    • ArrayList - vitesse de lecture et d'ajouter à la fin de la List. Utilise en interne tableau. Lent si vous devez augmenter la taille de la List
    • LinkedList - rapide ajouter aux deux côtés de la List. Dynamique rapide taille augmenter/diminuer. Ne pas utiliser en interne de la matrice de

    Conclusion:

    Je vous recommande d'utiliser la fonction de votre scénario de Collecte. Ne lutte pas avec Array [] parce que le Collections offre très confortable API comme add(), addAll() etc.

    De référence:
    Vous pouvez trouver une comparaison plus détaillée ici -> Des "tableaux vs ArrayList vs LinkedList vs..."

    InformationsquelleAutor Leni Kirilov
  9. 0

    Cela dépend vraiment de la situation. Les tableaux sont incroyablement rapides, mais ils sont d'une taille fixe et ils ne peuvent pas être approprié si la quantité de données que vous avez besoin de processus est très grand. Collections, d'autre part, ont des degrés variables de performances, selon la sous-classe donnée. La liste de tableaux, par exemple, est la plupart du temps juste un wrapper autour d'un tableau et donc devraient avoir le même itération de la vitesse et de mémoire. Pour moi, je l'utilise généralement l'objet iterable<T> interface dans la mesure du possible, depuis que donne le plus de souplesse pour mon code, permettant de traiter en-résident en mémoire des tableaux ainsi que des listes de données qui sont récupérées à partir d'un fichier ou sur un réseau en utilisant un custom itératif/classe iterator. Quand il est temps d'en instancier l'objet Itérable que je passe en, qui dépend de la situation spécifique; si je sais que la taille et s'adaptera en mémoire à la fois, puis-je simplement utiliser un tableau, alors que si il va peut-être pousser, alors je vais utiliser une ArrayList, et si elle a besoin rapide d'insertion à deux extrémités, puis je vais utiliser une LinkedList.

    InformationsquelleAutor Michael Aaron Safyan