Unity Basics Course: List Declaration

1. Introduction

Unity is a powerful platform for game development that provides various features to help developers unleash their creativity. In this tutorial, we will learn how to declare and use lists in Unity. Lists are very useful data structures for collecting and managing data, providing the ability to dynamically store and process multiple types of data.

2. What is a List?

A list is a collection of data that stores data in a specific order. The greatest advantage of a list is that it allows for easy addition, removal, and sorting of data. In C#, the System.Collections.Generic namespace is used to work with lists. Lists are more flexible than arrays and are useful because their size can be adjusted dynamically.

• Dynamic resizing: The size of the list is automatically adjusted as needed.
• Random access: You can directly access specific elements of the list through indices.
• Variety of methods: Lists provide various methods for adding, deleting, sorting, and searching for elements.

3. Declaring and Initializing a List

To use a list, you must first declare and initialize it. In C#, you can declare a list as follows:

using System.Collections.Generic;

// List declaration
List<Type> listName = new List<Type>();

3.1. Example: Declaring an Integer List

using System.Collections.Generic;

List<int> integerList = new List<int>();

3.2. Initialization and Adding Data

After declaring a list, you can initialize it and add data as needed. Here’s how to add data to a list:

integerList.Add(1);
integerList.Add(2);
integerList.Add(3);

This will sequentially add 1, 2, and 3 to the integer list.

4. Key Methods of a List

Lists provide various methods to facilitate data manipulation. Here are some commonly used methods:

4.1. Add() Method

Used when adding a new element to the list:

integerList.Add(4); // Add 4 to the list

4.2. Remove() Method

Used when removing a specific element from the list:

integerList.Remove(2); // Remove 2 from the list

4.3. Count Property

Returns the number of elements in the list:

int count = integerList.Count; // Current number of elements in the list

4.4. Accessing via Indexer

You can directly access an element at a specific index:

int firstElement = integerList[0]; // Access the first element

The above code retrieves the first element of the integer list.

5. Iterating Through a List

You can use the foreach statement or for loop to iterate through all the elements in a list. Here’s an example of printing all the elements of a list:

foreach (int number in integerList)
{
    Debug.Log(number);
}

5.1. Accessing Using a For Loop

for (int i = 0; i < integerList.Count; i++)
{
    Debug.Log(integerList[i]);
}

The above codes print all elements of the integer list to the console.

6. Using Lists with Polymorphism

Lists can accommodate various data types. For example, you can also add strings or instances of user-defined classes to a list.

6.1. Example of a String List

List<string> stringList = new List<string>();
stringList.Add("Hello");
stringList.Add("Unity");
stringList.Add("List");

6.2. Example of a User-Defined Class List

Here’s how to create a user-defined class and add its instance to a list:

class Player
{
    public string name;
    public int level;

    public Player(string name, int level)
    {
        this.name = name;
        this.level = level;
    }
}

List<Player> playerList = new List<Player>();
playerList.Add(new Player("User1", 1));
playerList.Add(new Player("User2", 2));

7. Conclusion

In this tutorial, we learned how to declare and use lists in Unity. Lists are important data structures for dynamically managing various data types, and they can be extensively used in game development. By utilizing various methods and properties, lists can be easily manipulated and applied, so it is recommended to use them actively.

Lists may feel simple at first, but understanding how to use them in various situations and the lower-level data structures is very important. Furthermore, by utilizing various collections like sets and dictionaries along with lists, you can significantly enhance programming efficiency.