The difference between arrays, ArrayList, and list in C #

 

In C # arrays, Arraylist,list can store a set of objects, so what is the difference between the three?

Array

Arrays are first seen in C #. is stored continuously in memory, so its index is very fast, and the assignment and modification elements are simple.

[CSharp]View PlainCopy

1. Array
2. String[] s=new string[2];
4. Assign value
5. s[0]="a";
6. s[1]="B";
7. Modify
8. s[1]="A1";
9. </span>

But there are some deficiencies in the array. Inserting data between the two data in an array is cumbersome, and when declaring an array, you must specify the length of the array, the length of the array is too long, and the memory is wasted, which can cause data overflow errors. If we do not know the length of the array when declaring an array, it becomes cumbersome.

For these drawbacks of arrays, ArrayList objects are first provided in C # to overcome these drawbacks.

ArrayList

ArrayList is part of the namespace System.Collections and must be referenced when using the class, inheriting the IList interface, providing data storage and retrieval. The size of the ArrayList object is dynamically expanded and shrunk according to the data stored in it. Therefore, you do not need to specify the length of the ArrayList object when declaring it.

[CSharp]View PlainCopy

1. //arraylist  
2. arraylist list1 = new arraylist ();   
3.   
4. //new data   
5. list1. ADD (
6. List1. ADD (5678);   
7. &NBSP;&NBSP;
8. //modify data   
9. LIST[2]&NBSP;=&NBSP;34;&NBSP;&NBSP;
10.   
11. //remove data   
12. list. RemoveAt (0);   
13. &NBSP;&NBSP;
14. //insert data   
15. list. Insert (0, 
16. </span>  

From the above example, ArrayList seems to solve all the shortcomings in the array, and why is there a list?

As we see from the above example, in list, we not only inserted the string CDE, but also inserted the number 5678. This allows the insertion of different types of data in the ArrayList. Because ArrayList will treat all of the data inserted as object types, when we use ArrayList to process data, it is possible to report a type mismatch error, that is, ArrayList is not type-safe. Boxing and unboxing operations typically occur when a value type is stored or retrieved, resulting in significant performance wear and tear.

Concept of packing and unpacking:
To put it simply:
Boxing: is to package data of a value type into an instance of a reference type
For example, assigning the value ABC of string type to the object obj

[CSharp]View PlainCopy

1. String i= "ABC";
2. Object Obj= (object) i;
3. </span>

Unpacking: Extracting value types from reference data
For example, assigning the value of the object obj to the variable I of type string

[CSharp]View PlainCopy

1. Object obj= "ABC";
2. String i= (string) obj;
3. </span>

The process of packing and unpacking is very lossy.

Generic List

The concept of generics occurs because ArrayList has the disadvantage of unsafe types and packing unboxing. The list class is a generic equivalent class of the ArrayList class, and most of its usage is similar to ArrayList, because the list class inherits the IList interface as well. The key difference is that when declaring a list collection, we also need to declare the object type for the data in the list collection.

Like what:

[CSharp]View PlainCopy

1. list<string> list = new list<string> ();
3. New data
4. List. ADD ("abc");
6. modifying data
7. List[0] = "Def";
9. removing data
10. List. RemoveAt (0);
11. </span>

In the example above, if we insert an int array into the list collection 123,ide will report an error and cannot be compiled. This avoids the previously mentioned type-safety issues and the performance issues of packing unboxing.

Summarize:

The capacity of an array is fixed, you can only get or set the value of one element at a time, and the capacity of ArrayList or list<t> can automatically expand, modify, delete, or insert data as needed.

An array can have multiple dimensions, and ArrayList or list< t> always have only one dimension. However, you can easily create lists of array lists or lists. The performance of arrays of specific types (except Object) is better than ArrayList. This is because the elements of ArrayList are of type Object, so boxing and unboxing operations typically occur when a value type is stored or retrieved. However, when redistribution is not required (that is, the initial capacity is very close to the maximum capacity of the list),list< t> has the same performance as an array of the same type.

When deciding whether to use List<t> or the ArrayList class, which has similar functionality, remember that the List<t> class performs better and is type-safe in most cases. If you use a reference type for type T of the list< t> class, the behavior of the two classes is exactly the same. However, if you use value types for type T, you need to consider implementation and boxing issues.

The difference between arrays, ArrayList, and list in C #