列表+泛型

列表List：

1,创建列表(列表可以存储任何类型的数据，在创建列表对象的时候首先要指定你要创建的这个列表要存储什么类型的)（泛型）

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

new List<int>(){1,2,3}

new List<string>(){"one","two"}

var scoreList = new List<int>();

2,往列表中插入数据

scoreList.Add(12);

scoreList.Add(45);

3,如何取得列表中的数据？列表中的数据跟数组有点相似，索引从0开始 ，可以通过索引来访问

scoreList[0] //访问添加到列表中的第一个数据

关于List更多：

1,列表内部数据是使用数组进行的存储，一个空的列表内部会有一个长度为0的数组，当给列表中添加元素的时候，列表的容量会扩大为4，如果添加第5个的时候，列表的大小会重新设置为8，如果添加第9个元素，列表容量会扩大为16，依次增加。当列表的中的容量发生改变的时候，它会创建一个新的数组，使用Array.Copy()方法将旧数组中的元素复制到新数组中。为了节省时间，如果事先知道要存储的数据的个数，就可以利用列表的构造函数指定列表的容量大小，比如下面的 List<int> intlist = new List<int>(10);创建了一个初始容量为10的列表，当容量不够用的时候，每次都会按照原来容量的2倍进行扩容。 我们可以通过Capacity属性获取和设置容量 intList.Capacity = 100;

2,注意容量和列表中元素个数的区别，容量是列表中用于存储数据的数组的长度通过Ｃａｐａｃｉｔｙ获取，列表中的元素是我们添加进去需要管理的数据，通过Count获取

列表的遍历：

遍历列表有两种方式：

1,for循环，遍历所有的索引，通过索引访问列表中的元素

for(int i=0;i<list.Count;i++){
            //循环体list[i]
        }

2,foreach遍历

foreach(int temp in list){ //依次取得list中的每一个元素赋值给temp，并执行循环体
            //循环体 temp
        }

操作列表的属性和方法：

1,Capacity获取容量大小

2,Add()方法添加元素

3,Insert()方法插入元素

4,[index]访问元素

5,Count属性访问元素个数

6,RemoveAt()方法移除指定位置的元素

7,IndexOf()方法取得一个元素所在列表中的索引位置

LastIndexOf()上面的方法是从前往后搜索，这个是从后往前搜索，搜索到满足条件的就停止

上面的两个方法，如果没有找到指定元素就返回-1

8,Sort()对列表中是元素进行从小到大排序

泛型概念：通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用。

泛型类定义：

  定义一个泛型类就是指的是，定义一个类，这个类中某些字段的类型是不确定的，这些类型可以在类构造的时候确定下来,举例: 创建一个类处理int类型和double类型的相加

class ClassA<T>{
    private T a;
    private T b;
    public ClassA(T a,T b){
        this.a = a ;this.b = b;
    }
    public T GetSum(){
        return a+“”+b;
    }
}

泛型方法：

定义泛型方法就是定义一个方法，这个方法的参数的类型可以是不确定的，当调用这个方法的时候再去确定方法的参数的类型。 实现任意类型组拼成字符串的方法

public static T GetSum<T>(T a,T b){
        return a+""+b;
    }

    GetSum<int>(23,12);    
        GetSum<double>(23.2,12);

使用泛型和索引器来实现一个我们自己的集合类MyList：

有下面的方法和属性

1,Capacity获取容量大小
2,Add()方法添加元素
3,Insert()方法插入元素
4,[index]访问元素(索引器)
5,Count属性访问元素个数
6,RemoveAt()方法移除指定位置的元素
7,IndexOf()方法取得一个元素所在列表中的索引位置
   LastIndexOf()上面的方法是从前往后搜索，这个是从后往前搜索，搜索到满足条件的就停止
    上面的两个方法，如果没有找到指定元素就返回-1
8,Sort()对列表中是元素进行从小到大排序

索引器：通过[index]这种形式去访问数据，就是索引器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _019_使用泛型和索引器来实现一个我们自己的集合类MyList {
    class MyList<T> where T:IComparable //表示T类型要继承自IComparable接口
    {
        private T[] array;
        private int count=0;//表示当前添加的元素的个数

        public MyList(int size)
        {
            if (size >= 0)
            {
                array = new T[size];
            }
        }

        public MyList()
        {
            array = new T[0];
        }

        public int Capacity
        {
            get { return array.Length; }
        }

        public int Count
        {
            get { return count; }
        }

        public void Add(T item )
        {
            if (Count == Capacity) //判断元素个数跟列表容量大小是否一样大，如果一样大，说明数组容量不够，需要创建新的数组
            {
                if (Capacity == 0)
                {
                    array = new T[4];//当数组长度为0的时候，创建一个长度为4的数组
                }
                else
                {
                    var newArray = new T[Capacity*2];//当长度不为0的时候，我们创建一个长度为原来2倍的数组
                    Array.Copy(array,newArray,Count);//把旧数组中的元素复制到新的数组中 ， 复制前count个  array-->newArray
                    array = newArray;
                }
            }
            array[Count] = item;
            count++;//元素个数自增
        }

        public T GetItem(int index)
        {
            if (index >= 0 && index <= count - 1)
            {
                return array[index];
            }
            else
            {
                //Console.WriteLine("所以超出了范围");
                throw new Exception("索引超出了范围");
            }
        }

        public T this[int index]
        {
            get//当我们通过索引器取值的时候，会调用get块
            { return GetItem(index); }
            set//当我们通过索引器设置值的时候，会调用set块
            {
                if (index >= 0 && index <= count - 1)
                {
                    array[index] = value;
                } else {
                    //Console.WriteLine("所以超出了范围");
                    throw new Exception("索引超出了范围");
                }
            }
        }

        public void Insert(int index, T item)
        {
            if (index >= 0 && index <= count - 1)
            {
                if (Count == Capacity)//容量不够 进行扩容
                {
                    var newArray = new T[Capacity*2];   
                    Array.Copy(array,newArray,count);
                    array = newArray;
                }
                for (int i = count-1; i >=index; i--)
                {
                    array[i + 1] = array[i];//把i位置的值放在后面，就是向后移动一个单位

                }
                array[index] = item;
                count++;
            }
            else
            {
                throw new Exception("所以超出范围");
            }
        }

        public void RemoveAt(int index)
        {
            if (index >= 0 && index <= count - 1)
            {
                for (int i = index + 1; i < count; i++)
                {
                    array[i - 1] = array[i];
                }
                count--;
            }
            else
            {
                throw new Exception("所以超出范围");
            }
        }

        public int IndexOf(T item)
        {
            for (int i = 0; i < count; i++)
            {
                if (array[i].Equals(item))
                {
                    return i;
                }
            }
            return -1;
        }

        public int LastIndexOf(T item)
        {
            for (int i = Count-1; i >=0; i--) {
                if (array[i].Equals(item)) {
                    return i;
                }
            }
            return -1;
        }

        public void Sort()
        {
            for (int j = 0; j < Count-1; j++)
            {
                for (int i = 0; i < Count - 1 - j; i++) {
                    if (array[i].CompareTo(array[i + 1]) > 0) {
                        T temp = array[i];
                        array[i] = array[i + 1];
                        array[i + 1] = temp;
                    }
                }
            }
           
        }
    }
}