Quando usare ArrayList oltre array[] in c#?

Question

Io uso spesso un ArrayList invece di un 'normale' array[].

Mi sento come se sto barare (o pigrizia) quando uso un ArrayList, quando è possibile utilizzare un ArrayList su un array?

Answer 1

Le matrici sono fortemente tipizzate e funzionano bene come parametri. Se conosci la lunghezza della tua raccolta ed è fissa, dovresti usare un array.

Le ArrayLists non sono fortemente tipizzate, ogni Insertion o Retrial avrà bisogno di un cast per tornare al tuo tipo originale. Se hai bisogno di un metodo per prendere un elenco di un tipo specifico, ArrayLists non è all'altezza perché potresti passare un ArrayList contenente qualsiasi tipo. Le matrici utilizzano una matrice che si espande dinamicamente internamente, quindi c'è anche un colpo per espandere la dimensione della matrice interna quando raggiunge la sua capacità.

Quello che vuoi veramente usare è un elenco generico come List<T>. Questo ha tutti i vantaggi di Array e ArrayLists. È fortemente tipizzato e supporta una lunghezza variabile di elementi.

Answer 2

Oltre alla risposta di Bob e Federico, vorrei sottolineare che mentre gli array hanno covarianza, gli elenchi generici no. Ad esempio, un array di tipo MyChildClass[] può essere facilmente convertito in MyParentClass[], mentre List<MyChildClass> non può essere trasmesso in List<MyParentClass>, almeno non direttamente.

Se hai bisogno di covarianza, usa gli array, usa il metodo Cast () di LINQ o qualche altro mezzo per lanciare ogni elemento singolarmente o attendere C # 4 .

Answer 3

Un altro pensiero qui è la mutazione; un array (T[]) è completamente mutabile e non può essere protetto. List<T> non fornisce alcun utile punto di estensione, ma elementi come Collection<T> (o molte altre IList<T> implementazioni) consentono di aggiungere codice, ad esempio, per controllare gli elementi prima che vengano aggiunti; allo stesso modo, puoi avere params implementazioni di sola lettura, il che è utile per la sicurezza dei thread dove è desiderabile l'immutabilità.

Tendo a usare le matrici sia nella logica del metodo interno (forse come variabile locale), come <=> argomenti, o in alcuni casi altamente ottimizzati in cui conosco la lunghezza degli elementi e conosco il codice sceglie di non modificarlo (come campo privato). Oltre a ciò, <=> ecc. Tendono ad essere più comuni, in quanto hanno un sovraccarico molto minore quando si aggiungono / rimuovono elementi.

Answer 4

A meno che quella parte del codice non sia assolutamente critica per le prestazioni, l'utilizzo di ArrayList va benissimo.

Answer 5

Meglio ancora, ovunque tu usi ArrayList, usa invece la List<T> collezione generica. È più fortemente tipizzato rispetto al primo.

Answer 6

Sto rispondendo a questa da un Java prospettiva, ma il problema di base.Non si dovrebbe sentire in colpa l'utilizzo di una maggiore astrazioni.Dopo tutto, si sta utilizzando Stringinvece di char[], o anche byte[]?Vorrei anche suggerire di fare un passo ulteriore e di utilizzare il List interfaccia in cui è possibile.L'unico motivo per fare un passo in giù è per motivi di prestazioni.

Usando la frequenza di raccolta astrazione presenta molti vantaggi.È possibile aggiungere decoratori a fare l'Elenco di sola lettura, rendono dimensione fissa, verificare gli elementi che entrano o lasciano la raccolta o l'utilizzo di visualizzazione (vedere GetRange in C# e subList in Java.)

A proposito, un ArrayList deve sempre essere basata su una primitiva matrice, altrimenti il nome è sbagliato.Le operazioni sono di solito implementato proprio come ci si aspetterebbe quando si utilizza una primitiva matrice.Se una lista collegata è utilizzato di solito è chiamato solo che -- LinkedList.Questo è anche un vantaggio di utilizzare l'interfaccia:Si può cambiare idea sull'utilizzo di attuazione in seguito.

Ci sono un paio di cose che rendono l'uso di collezioni goffo.Un avvertimento è che le collezioni sono di solito basato su oggetti, e le lingue hanno un divario considerevole tra i primitivi e tipi di oggetto.La limitata generics non aiutano più di tanto.Ancora, mi raccomando le collezioni su matrici a meno che non ci sia un buon motivo contrario.

Per i valori di base si può anche considerare l'utilizzo di una primitiva di raccolta (per esempio in biblioteca GNU Tesoro.Non so se c'è qualcosa di simile per C#, però.

Answer 7

Fabulous Adventures In Coding ha scritto un pezzo Array considerati in qualche modo dannosi . È una lettura davvero interessante.

Answer 8

Bene, per uno, se hai intenzione di gestire solo un tipo specifico, non dovresti usare una ArrayList. Ad esempio, se ti aspetti solo un array di byte, dovresti accettare solo un array di byte.

Solo il tempo in cui potrei pensare che potresti persino pensare di usare una ArrayList invece di Elenco.

Answer 9

La dimensione dell'array è statica, quindi se si conosce la dimensione in fase di progettazione, utilizzare l'array. Dovrebbe funzionare più velocemente, ma non l'ho provato da solo. Se devi modificare frequentemente il conteggio degli oggetti (aggiungendo o rimuovendo oggetti dalla raccolta) usa ArrayList o meglio l'Elenco generico da .NET 2. È anche più facile da usare, quindi se le prestazioni non sono cruciali, puoi sempre usare Elenco.

Answer 10

Se hai bisogno di una matrice di tipi primitivi usa Array per prestazioni migliori in quanto eviterà l'autoboxing e unboxing. Ma solo se conosci le dimensioni che desideri in anticipo.

Answer 11

È così.

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(); 
        }
    }
}