列表+泛型

列表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,注意容量和列表中元素个数的区别,容量是列表中用于存储数据的数组的长度通过Capacity获取,列表中的元素是我们添加进去需要管理的数据,通过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;
                    }
                }
            }

        }
    }
}
时间: 2024-10-25 17:26:47

列表+泛型的相关文章

Java——类的封装、继承与多态

一.类和对象 1.类 类是数据以及对数据的一组操作的封装体. 类声明的格式: 类声明 { 成员变量的声明: 成员方法的声明及实现: } 1.1 声明类 [修饰符] class 类<泛型> [extends 父类] [implements 接口列表] <泛型>——类的参数,带有参数的类成为泛型类. 1.2 声明成员变量和成员方法 成员变量声明格式:[修饰符] 数据类型 变量[=表达式]{,变量[=表达式]}: 成员方法——用来描述对成员变量进行的操作,格式:[修饰符] 返回值类型 方

Java5的新特性

原文出处:xixicat 序 这是Java语言特性系列的第一篇,从java5的新特性开始讲起.初衷就是可以方便的查看语言的演进历史. 特性列表 泛型 枚举 装箱拆箱 变长参数 注解 foreach循环 静态导入 格式化 线程框架/数据结构 Arrays工具类/StringBuilder/instrument 1.泛型 所谓类型擦除指的就是Java源码中的范型信息只允许停留在编译前期,而编译后的字节码文件中将不再保留任何的范型信息.也就是说,范型信息在编译时将会被全部删除,其中范型类型的类型参数则

Java5~11新特性

Java5~11版本新特性 Java5 Java6 Java7 Java8 Java9 Java10 Java11 Java5 Java5开发代号为Tiger(老虎),于2004-09-30发行 特性列表 泛型 枚举 自动装箱拆箱 可变参数 注解 foreach循环(增强for.for/in) 静态导入 格式化(System.out.println 支持%s %d等格式化输出) 线程框架/数据结构 JUC Arrays工具类/StringBuilder/instrument 1.泛型 所谓类型擦

C#泛型列表List&lt;T&gt;基本用法总结

http://space.itpub.net/14466241/viewspace-624132 示例代码如下: namespace SampleListT{  class Program  {      static void Main(string[] args)      {          //using System.Collections.Generic; 命名空间中的List<T>          //using System.Collections; 命名空间中的Array

泛型数组列表 ArrayList

为什么使用泛型数组列表而不使用普通数组? 1.普通数组经常会发生容量太大以致浪费的情况 2.普通数组无法动态更改数组 基本概念: 1.采用[类型参数]的[类]---->[泛型类] 2.[泛型类型]就是类型参数的类型 对泛型数组列表的操作: 1.添加元素,add方法,默认在尾部添加,变化参数可以插入到中间.删除元素 2.初始化容量(ensurecapacity或是把初始容量传递给构造器) 3.回收多余的存储空间(trimToSize) 4.访问数组元素 get(i) 5.转化为数组 toArray

关于C#泛型列表List&lt;T&gt;的基本用法总结

//示例代码如下:using System;using System.Collections.Generic;using System.Collections.ObjectModel;namespace linqs{    class Program    {        static void Main(string[] args)        {            //using System.Collections.Generic; 命名空间中的List<T>          

基于泛型的数组列表

在<数组和数组列表>那篇随笔里我们定义了一个int类型的数组列表,但是这样实际上是有问题的,在日后的开发中我们使用的数组列表实际上并不一定是int类型的,甚至于,还不一定会是基本数据类型的.那这个时候,按照原来的方法,我们在开发中每要定义一个数组列表,我们就要重写一遍,这样做实际上是非常不友好的.那么有什么方法来解决这一问题呢,这样我们便引出了泛型这个概念 泛型 什么是泛型?泛型简单来理解实际上就是一个类类型,它是表示一个类的类型,而不具体表示某一个对象.由于在此重点是数组列表,关于泛型的其他

java-基础入门-泛型数组列表-解决运行时动态更改数组的问题

泛型数组列表,主要是为了解决运行时动态更改数组的问题 平常我们会定义一个部门里面的人员的一个数组, 但是在实际业务当中,这个数组的大小往往是不确定的, 如果定义过大,那么会浪费空间,定义过小,又不够用, 因为为了解决运行时动态更改数组的问题,我们提出下面的解决方案. package com.ray.object; import java.util.ArrayList; /** * 泛型数组列表 ,解决运行时动态更改数组的问题 * * @author ray * @since 2015-05-04

泛型容器单元(Generics.Collections)[2]: TQueue&lt;T&gt; 队列列表

TQueue 和 TStack, 一个是队列列表, 一个是堆栈列表; 一个是先进先出, 一个是先进后出. TQueue 主要有三个方法.一个属性:Enqueue(入列).Dequeue(出列).Peek(查看下一个要出列的元素);Count(元素总数). 本例效果图: 代码文件: unit Unit1; interface uses   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,   Dia