List、Array的使用和Sort方法的使用

List

新建一个List

 		List<int> _list_int_0 = new List<int>();
        for (int i = 0; i < 5; i++)
        {
            _list_int_0.Add(i * 100 + 100);
        }

        foreach (var item in _list_int_0)
        {
            Debug.Log(item);
        }
        // Log 100,200,300,400,500

List .AddRange

List .AddRange()方法用于将指定集合的​​对象/元素添加到列表的末尾。

		 int[] _int_arr_0 = { 400, 500, 600 };
        _list_int_0.AddRange(_int_arr_0);

        List<int> _list_int_1 = new List<int>();
        _list_int_1.Add(50);
        _list_int_1.Add(60);
        _list_int_1.Add(70);
        _list_int_0.AddRange(_list_int_1);

        foreach (var item in _list_int_0)
        {
            Debug.Log(item);
        }
    }

输出元素

List.InsertRange(index, colliection)

从index开始插入指定对象colliection

List.ConvertAll

将列表中的元素转换为想要的类型

		List<string> _list_str_0 = _list_int_0.ConvertAll(t => Convert.ToString(t));

        foreach (var data in _list_str_0)
        {
            Debug.Log(data);
        }

输出元素

List.Reverse

翻转所有元素

List.RemoveRange(index, count)

移除从index位置开始count数量的元素

Array

Array 类提供了各种用于数组的属性和方法,可看作扩充了功能的数组但不等同数组

1. 新建3维数组

	void creatList3()
    {
        int x = 2;
        int y = 3;
        int z = 4;

        int[,,] arr3 = new int[x, y, z];
        for (int i = 0; i < x; i++)
        {
            for (int j = 0; j < y; j++)
            {
                for (int k = 0; k < z; k++)
                {
                    arr3[i, j, k] = i * j * k;
                    string str = string.Format("{0}-{1}-{2}:\t", i, j, k) + "<color=#00FF2E>" + arr3[i, j, k].ToString() + "</color>";
                    creatTxtMesh(str, new Vector3(i * 20, j * 10, k *10));
                }
            }
        }
    }

    void creatTxtMesh(string str, Vector3 pos)
    {
        TextMeshPro text = new GameObject().AddComponent<TextMeshPro>();
        text.text = str;
        text.alignment = TextAlignmentOptions.Center;
        text.transform.position = pos;
    }

数组如下:

2. Rank
获取数组的维度

		for (int i = 0; i < arr3.Rank; i++)
        {
            Debug.Log("GetUpperBound" + arr3.GetUpperBound(i));
            Debug.Log("GetLowerBound" + arr3.GetLowerBound(i));
        }

3. GetUpperBound(index)

   获取 Array 指定维度最后一个元素的索引

4. GetUpperBound（index）
   获取 Array 指定维度第一个元素的索引

5. Array.Clear(array, index, length)
   根据元素类型，将array中的元素范围(index开始,长度为length)设置为0，false或null

6. GetLength(dimension)/GetLongLength(dimension)
   获取一个32/64位整数，表示Array指定维度(dimension)的元素数。

	Debug.Log("Length:  " + arr3.GetLength(0));

Sort方法

不带参数的Sort方法

直接使用这个方法不能对List中的任何元素对象都可以进行排序，List中的元素对象必须继承IComparable接口，并且要实现IComparable接口中的CompareTo()方法，在CompareTo()方法中要自己实现对象的比较规则。
如，Int32和Double都是实现了IComparable接口并重载了CompareTo方法的结构

1. 对Int进行排序

 	void sortInt()
    {
        List<int> arr = new List<int>();
        for (int i = 0; i < 10; i++)
        {
            arr.Add(UnityEngine.Random.Range(0, 10));
        }

        string str = "";
        foreach (var item in arr)
        {
            str += (item + "-");
        }
        Debug.Log("str: " + str);
        arr.Sort();
        str = "";
        foreach (var item in arr)
        {
            str += (item + "-");
        }
        Debug.Log("sort: " + str);
    }

输出如下

对于官方未实现IComparable接口的类型，可通过实现IComparable接口重写CompareTo方法来排序。

实现IComparable接口并重写CompareTo

单一权重排序
新建参数类型

using System;

public class Props : IComparable<Props>
{
    public int id;
    public int quality;
    public int count;

    // 重写Compare方法
    public int CompareTo(Props props)
    {
        // 默认根据品质排序
        if (quality > props.quality)
            return -1;
        else
            return 1;
    }

    public Props()
    {
        id = 0;
        quality = 0;
        count = 0;
    }

    public Props(int _id, int qua, int cou)
    {
        id = _id;
        quality = qua;
        count = cou;
    }
}

进行排序

void initProps()
    {
        List<Props> props = new List<Props>();
        for (int i = 0; i < 10; i++)
        {
            Props item = new Props();
            item.id = i;
            item.quality = i / 3;
            item.count = (i > 7) ? 7 : i;
            props.Add(item);
        }
        Debug.Log("排序前");
        foreach (var item in props)
        {
            Debug.Log(string.Format("id: {0} \t quality: {1} \t count: {2}", item.id, item.quality, item.count));
        }
        props.Sort();
        Debug.Log("排序后");
        foreach (var item in props)
        {
            Debug.Log(string.Format("id: {0} \t quality: {1} \t count: {2}", item.id, item.quality, item.count));
        }
    }

输出结果如下

多权重排序
在参数类里增加多权重排序方法

	// 多权重排序
    public int CompareQua2Cou(Props a, Props b)
    {
        if (a.quality > b.quality)
            return -1;
        else if (a.quality == b.quality)
        {
            // 同品质按数量排序
            // a.count.CompareTo(b.count) * -1
            return -a.count.CompareTo(b.count);
        }
        else
            return 1;
    }

进行排序

		props.Sort((a, b) => a.CompareQua2Cou(a,b));
        Debug.Log("排序后");
        foreach (var item in props)
        {
            Debug.Log(string.Format("id: {0} \t quality: {1} \t count: {2}", item.id, item.quality, item.count));
        }

排序结果

使用匿名函数来实现Comparison

单一权重排序

		props.Sort((a, b) =>
        {
            return b.count - a.count;
        });
        Debug.Log("排序后");
        foreach (var item in props)
        {
            Debug.Log(string.Format("id: {0} \t quality: {1} \t count: {2}", item.id, item.quality, item.count));
        }

输出结果

多权重排序

 		props.Sort((a, b) =>
        {
            if (a.quality > b.quality)
            {
                return 1;
            }else if (a.quality == b.quality)
            {
                return a.count - b.count;
            }
            else
            {
                return -1;
            }
        });
        // 另一种写法
        //props.Sort((a, b) =>
        //{
        //    return a.quality.CompareTo(-b.count);
        //});

结果