Quand utiliser ArrayList sur array [] en c #?

Question

J'utilise souvent un ArrayList au lieu d'un "normal" array[].

J'ai l'impression de tricher (ou d'être paresseux) lorsque j'utilise un <=>, quand puis-je utiliser un <=> sur un tableau?

Answer 1

Les tableaux sont fortement typés et fonctionnent bien comme paramètres. Si vous connaissez la longueur de votre collection et que celle-ci est corrigée, vous devez utiliser un tableau.

Les listes de tableaux ne sont pas fortement typées, chaque insertion ou nouvelle tentative nécessitera un transtypage pour revenir à votre type d'origine. Si vous avez besoin d'une méthode pour prendre une liste d'un type spécifique, ArrayLists est insuffisant car vous pouvez transmettre une ArrayList contenant n'importe quel type. ArrayLists utilise un tableau à expansion dynamique en interne. Il existe donc un hit pour augmenter la taille du tableau interne quand il atteint sa capacité.

Ce que vous voulez vraiment utiliser est une liste générique telle que List<T>. Cela présente tous les avantages de Array et ArrayLists. Il est fortement typé et prend en charge une longueur variable d'éléments.

Answer 2

En plus de la réponse de Bob et Frederick, je voudrais préciser que, bien que les tableaux aient une covariance, les listes génériques n'en ont pas. Par exemple, un tableau de type MyChildClass[] peut être facilement converti en MyParentClass[], tandis que List<MyChildClass> ne peut pas être converti en List<MyParentClass>, du moins pas directement.

Si vous avez besoin de covariance, utilisez des tableaux, utilisez la méthode Cast () de LINQ ou un autre moyen de convertir chaque élément individuellement ou attendez C # 4 .

Answer 3

Une autre pensée ici est la mutation; un tableau (T[]) est totalement modifiable et ne peut pas être protégé. List<T> ne fournit pas de points d'extension utiles, mais des éléments tels que Collection<T> (ou de nombreuses autres IList<T> implémentations) vous permettent d'ajouter du code, par exemple, pour vérifier les éléments avant leur ajout. De même, vous pouvez avoir des params implémentations en lecture seule, ce qui est utile pour la sécurité des threads où l'immuabilité est souhaitable.

J'ai tendance à utiliser des tableaux dans la logique de méthode interne (peut-être en tant que variable locale), sous forme d'arguments <=> ou dans quelques cas très optimisés où je connais la longueur des éléments et le code choisit de ne pas le muter (en tant que champ privé). En dehors de cela, <=> etc. ont tendance à être plus courants, car ils nécessitent beaucoup moins de temps système lors de l'ajout / la suppression d'éléments.

Answer 4

À moins que cette partie du code ne soit absolument critique en termes de performances, l'utilisation de ArrayList convient parfaitement.

Answer 5

Mieux encore, où que vous soyez ArrayList, utilisez plutôt la List<T> collection générique. Il est plus typé que l'ancien.

Answer 6

Je réponds à cela du point de vue de Java, mais c'est le même problème de base. Vous ne devriez pas vous sentir coupable en utilisant des abstractions plus élevées. Après tout, vous utilisez String s au lieu de char[], ou même byte[]? Je suggérerais même d'aller un peu plus loin et d'utiliser l'interface List si possible. La seule raison pour laquelle il faut descendre un cran est pour des raisons de performance.

L'utilisation de l'abstraction de collection supérieure présente de nombreux avantages. Vous pouvez ajouter des décorateurs pour rendre la liste en lecture seule, la fixer à une taille fixe, vérifier les éléments qui entrent ou sortent de la collection ou utiliser des vues (voir GetRange en C # et subList en Java.)

Au fait, un ArrayList devrait toujours être basé sur un tableau primitif, sinon le nom est incorrect. Les opérations sont généralement mises en œuvre exactement comme vous le souhaitez lorsque vous utilisez un tableau primitif. Si une liste chaînée est utilisée, elle ne porte généralement que le nom - LinkedList. C’est aussi un avantage de l’interface: vous pourrez changer d’avis sur l’implémentation utilisée plus tard.

Certains éléments rendent l’utilisation des collections difficile. Un inconvénient est que les collections sont généralement basées sur des objets et que les langages ont un écart considérable entre les types primitif et type d'objet. Les génériques limités n'aident pas beaucoup non plus. Néanmoins, je recommande les collections sur les tableaux sauf indication contraire.

Pour les valeurs primitives, vous pouvez également utiliser une bibliothèque de collections primitive, par exemple GNU Trove . Je ne sais pas s'il existe quelque chose de similaire pour C #, cependant.

Answer 7

Fabulous Adventures In Coding a écrit une pièce Les tableaux sont considérés comme quelque peu nuisibles . C'est une lecture vraiment intéressante.

Answer 8

Eh bien, si vous avez seulement l'intention de gérer un type spécifique, vous ne devriez pas utiliser ArrayList. Par exemple, si vous attendez seulement un tableau d'octets, vous ne devez accepter qu'un tableau d'octets.

Seul le temps, je pense que vous pourriez même penser à utiliser un ArrayList est à la place de la liste.

Answer 9

La taille du tableau est statique. Si vous connaissez la taille au moment de la conception, utilisez array. Il est supposé fonctionner plus vite, mais je ne l’ai pas testé moi-même. Si vous devez modifier fréquemment le nombre d'objets (ajouter ou supprimer des objets de la collection), utilisez ArrayList ou une version améliorée de la liste générique de .NET 2. Il est également plus facile à utiliser. Par conséquent, si les performances ne sont pas cruciales, vous pouvez toujours utiliser List.

Answer 10

Si vous avez besoin d’un tableau de types primitifs, utilisez Array pour obtenir de meilleures performances, car il évitera la création automatique de boîtes aux lettres et la décompression. Mais seulement si vous connaissez la taille souhaitée à l'avance.

Answer 11

C'est comme ça.

using System;
using System.Collections;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            //ArrayList
            /*
             An ArrayList doesn't use a LinkedList as the internal data structure! .we can store any type of objects      
             */
            ArrayList list = new ArrayList();
            list.Add("1"); // not strongly type,you can enter any object types (int,string decimals, etc..)
            list.Add(1);
            list.Add(1.25);

            //Array
            /*
             must declare length.
             */
            string[] array = new string[3]; // you must declare object types
            array[0] = "1";
            //array[1] = 1; this get error becoz array is storngly typed. // this print empty value when you run it
            array[2] = "stongly typed";
            Console.WriteLine("------- ARRAYLIST ITEMS ---------");
            foreach (var i in list) {
                Console.WriteLine(i);
            }

            Console.WriteLine("--------- ARRAY ITEMS -----------");
            foreach (var i in array)
            {
                Console.WriteLine(i);
            }

            Console.ReadKey(); 
        }
    }
}