泛型集合

最新推荐文章于 2024-05-10 18:01:03 发布
最新推荐文章于 2024-05-10 18:01:03 发布
阅读量232 收藏
点赞数
文章标签： class string equals object list pair
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangyiliude/article/details/6343387
版权

日志

泛型集合

刘德 2011年03月27日 23:52 阅读(0) 评论(0) 分类：个人日记 权限: 公开


    //用来统计单词的个数
     //泛型类型包括(类,接口,委托和结构---没有泛型枚举)和泛型方法
    //用来统计单词的个数
class DictionaryDemo
    {
        static Dictionary<string,int> CountWords(string text)
        {
            Dictionary<string,int> frequencies;
            frequencies = new Dictionary<string,int>();
               
            string[] words = Regex.Split(text, @"/W+"); //将文本分解成单词
               
            foreach (string word in words)
            {
                if (frequencies.ContainsKey(word))
                {
                    frequencies[word]++;
                }
                else
                {
                    frequencies[word] = 1;
                }
            }
            return frequencies;
        }

        static void Main()
        {
            string text = @"Do you like green eggs and ham?
                            I do not like them, Sam-I-am.
                            I do not like green eggs and ham.";

            Dictionary<string, int> frequencies = CountWords(text);
            foreach (KeyValuePair<string, int> entry in frequencies)
            {
                string word = entry.Key;
                int frequency = entry.Value;// 若用c#1的HASHTABLE的相似的键和值属性的非返型dictionaryentry,但是word和frequency需要强制类型转换:因为Key,Value都是以object类型返回的
                Console.WriteLine("{0}: {1}", word, frequency);
            }
        }
    }


 //泛型方法: 虽然dictionary<tkey,tvalue>没有泛型方法,但它的近亲list<T>有的
    class ListConvertAll
    {
        static double TakeSquareRoot(int x)
        {
            return Math.Sqrt(x);
        }

        static void Main()
        {
            List<int> integers = new List<int>();
            integers.Add(1);
            integers.Add(2);
            integers.Add(3);
            integers.Add(4);

            // Converter Represents a method that converts an object from one type to another type.
            Converter<int, double> converter = TakeSquareRoot;
            List<double> doubles = integers.ConvertAll<double>(converter); //泛型类型中的泛型方法
            foreach (double d in doubles)
            {
                Console.WriteLine(d);
            }
        }
    }




 //  在非泛型类型中实现泛型方法:

 class GenericMethodDemo
    {
        static List<T> MakeList<T> (T first, T second)
        {
            List<T> list = new List<T>();
            list.Add (first);
            list.Add (second);
            return list;
        }

        static void Main()
        {
            List<string> list = MakeList<string>("Line 1", "Line 2");  //  在非泛型类型中实现泛型方法:

            foreach (string x in list)
            {
                Console.WriteLine(x);
            }
        }
    }



//  类型约束:

   1: 引用类型约束:   T:class  用于确保使用的类型实参是引用类型:

   2:值类型约束:   T:struct  用于确保使用的类型实参是值类型:将包括枚举,但是它将可空类型排除在外:

   3:  构造函数类型约束:  表示为T: new();  必须是所有引用类型参数的最后一个约束,仅核对所有的类型实参有一个
      无参数构造函数,这个构造函数可用于创建类型的实例:


   4: 派生类型的约束: (有点难以理解)
   
   5.组合约束:

//泛型方法类型实参的判断:
        调用泛型方法时,指定类型的实参常常会显得多余的,根据向方法传递的实参,很容易看出传递的类型实参
应该是什么:在调用方法的时候,不需要显式声明类型实参,:必须强调: 类型推断只适用于泛型方法,不适用于类型,

  比如上句:
     List<string> list = MakeList<string>("Line 1", "Line 2");


 可以简单写成:  List<string> list = MakeList("Line 1", "Line 2");



 //以泛型方式将一个给定的值和默认值进行比较:  给出的类型判断和派生类型约束的实例:

    class DefaultValueComparison
    {
        static int CompareToDefault<T>(T value)
            where T : IComparable<T>
        {
            return value.CompareTo(default(T));
        }
   
        static void Main()
        {
            Console.WriteLine(CompareToDefault("x"));
            Console.WriteLine(CompareToDefault(10));
            Console.WriteLine(CompareToDefault(0));
            Console.WriteLine(CompareToDefault(-10));
            Console.WriteLine(CompareToDefault(DateTime.MinValue));
        }
    }

    // // 如果一个类型参数被约束成值类型,就完全不能为它使用==和!=,如果被约束成引用类型,那么具体执行的比较完全
   //取决于类型参数被约束成什么类型,如果它只是一个引用类型,那么执行的是简单的引用比较,
    //如果它进一步约束成一个重载了==和!=操作符指定的特定的类型派,就会使用重载的操作符
        // 但要注意的是: 假如调用者指定的类型实参恰巧也进行了重载,那些额外的重载符号是不会使用的:
//    用==和!=进行引用比较


    class OperatorOverloading
    {
        static bool AreReferencesEqual<T>(T first, T second)
            where T : class
        {
            return first == second;
        }

        static void Main()
        {
            string name = "Jon";
            string intro1 = "My name is " + name;
            string intro2 = "My name is " + name;
            Console.WriteLine(intro1 == intro2);
            Console.WriteLine(AreReferencesEqual(intro1, intro2));
        }
    }



----作为实现泛型:
//  作为了“实现泛型”（实际上实现了中级泛型）这一主题结束，先面给出一个的例子：
    //它实现了有用的泛型类型
    [Description("Listing 3.06")]
    //需要对值进行比较时,有两个相当的有用的类,分别是: EqualityComparer:(适合对字典进行比较和哈希处理)和
    // IComparer<T>(适合于排序)
        //这两个类的default属性能返回一个实现,该实现都能为特定的类型采取正确的(比较操作)
    //  EqualityComparer<T>的例子:
    public sealed class Pair<TFirst, TSecond> : IEquatable<Pair<TFirst, TSecond>>  // IEquatable<Pair<TFirst, TSecond>>支持排序
    {
        private static readonly IEqualityComparer<TFirst> FirstComparer =
           EqualityComparer<TFirst>.Default;
        private static readonly IEqualityComparer<TSecond> SecondComparer =
           EqualityComparer<TSecond>.Default;

        private readonly TFirst first;
        private readonly TSecond second;

        public Pair(TFirst first, TSecond second)
        {
            this.first = first;
            this.second = second;
        }

        public TFirst First { get { return first; } }

        public TSecond Second { get { return second; } }

        public bool Equals(Pair<TFirst, TSecond> other)
        {
            return other != null &&
               FirstComparer.Equals(this.First, other.First) &&
               SecondComparer.Equals(this.Second, other.Second);
        }
        public override bool Equals(object o)
        {
            return Equals(o as Pair<TFirst, TSecond>);
        }
        public override int GetHashCode()
        {
            return FirstComparer.GetHashCode(first) * 37 +
               SecondComparer.GetHashCode(second);
        }
    }

    public static class Pair
    {
        public static Pair<TFirst, TSecond> Of<TFirst, TSecond>(TFirst first, TSecond second)
        {
            return new Pair<TFirst, TSecond>(first, second);
        }
    }
}



//高级泛型:
   //静态字段和静态构造函数：
    //   若在someclass中静态字段x:不管创建多少个someclass实例，也不管派生多个类型，都只型号有一个someclass.x字段：
//它如何映射到泛型：

        //不同的泛型都有它自己的静态字段集
    class StaticFieldPerClosedType
    {
        class TypeWithField<T>
        {
            public static string field;

            public static void PrintField()
            {
                Console.WriteLine(field + ": " + typeof(T).Name);
            }
        }

        static void Main()
        {
            TypeWithField<int>.field = "First";
            TypeWithField<string>.field = "Second";
            TypeWithField<DateTime>.field = "Third";

            TypeWithField<int>.PrintField();
            TypeWithField<string>.PrintField();
            TypeWithField<DateTime>.PrintField();
        }
    }

 //静态字段和静态构造函数：
    //   若在someclass中静态字段x:不管创建多少个someclass实例，也不管派生多个类型，都只型号有一个someclass.x字段：
//它如何映射到泛型：

        //不同的泛型都有它自己的静态字段集
    class StaticFieldPerClosedType
    {
        class TypeWithField<T>
        {
            public static string field;

            public static void PrintField()
            {
                Console.WriteLine(field + ": " + typeof(T).Name);
            }
        }

        static void Main()
        {
            TypeWithField<int>.field = "First";
            TypeWithField<string>.field = "Second";
            TypeWithField<DateTime>.field = "Third";

            TypeWithField<int>.PrintField();
            TypeWithField<string>.PrintField();
            TypeWithField<DateTime>.PrintField();
        }
    }


// 基本规则：  每个封闭类型有一个静态字段”同样的规则： 也适用于静态初始化程序：
   //和静态构造函数

        //--嵌套泛型类型的静态构造函数：

    class StaticConstructors
    {
        class Outer<T>
        {
            public class Inner<U, V>
            {
                static Inner()
                {
                    Console.WriteLine("Outer<{0}>.Inner<{1},{2}>",
                                      typeof(T).Name,
                                      typeof(U).Name,
                                      typeof(V).Name);
                    Console.ReadLine();
                }

                Inner()
            {


                Console.Write("执行构造函数的时候是不会执行构造函数");
                Console.ReadLine();
            }

                public static void DummyMethod()
                {
                    Console.WriteLine("print  some  th");
                    Console.ReadLine();
                }
            }
        }

        static void Main()
        {
            Outer<int>.Inner<string, DateTime>.DummyMethod();
            Outer<string>.Inner<int, int>.DummyMethod();
            Outer<object>.Inner<string, object>.DummyMethod();
            Outer<string>.Inner<string, object>.DummyMethod();
            Outer<object>.Inner<object, string>.DummyMethod();
            Outer<string>.Inner<int, int>.DummyMethod();
        }
    }
}

//和任何类型一样,静态构造函数只执行一次:


泛型迭代:

 class CountingEnumerableExample
    {
        class CountingEnumerable : IEnumerable<int>
        {
            public IEnumerator<int> GetEnumerator() //  隐式实现”
            {
                return new CountingEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator() //IEnumerable.GetEnumerator：  IEnumerable接口名： 实现接口所规定的方法和属时附加接口名作为前缀，即称为”显式接口实现“---
            {
                return GetEnumerator();
            }
        }

        class CountingEnumerator : IEnumerator<int>
        {
            int current = -1;

            public bool MoveNext()
            {
                current++;
                return current < 10;
            }

            public int Current  //隐式实现Current
            {
                get { return current; }
            }

            object IEnumerator.Current  //IEnumerator.Current 显式实现：
            {
                get { return Current; }
            }

            public void Reset()
            {
                throw new NotSupportedException();
            }

            public void Dispose()
            {
            }
        }

        static void Main()
        {
            CountingEnumerable counter = new CountingEnumerable();
            foreach (int x in counter)
            {
                Console.WriteLine(x);
            }
        }



//
反射泛型方法:
//反射泛型方法:
    class GenericMethodReflection
    {
        public static void PrintTypeParameter<T>()
        {
            Console.WriteLine (typeof(T));
        }

        static void Main()
        {
            Type type = typeof(GenericMethodReflection);
            MethodInfo definition = type.GetMethod("PrintTypeParameter");       
            MethodInfo constructed;
            constructed = definition.MakeGenericMethod(typeof(string));      
            constructed.Invoke(null, null);
        }
    }

   




.net2.0中的泛型集合类:
list<T>


dictionary<tkey,tvalue>

queue<t> 

stact<t>


linkedlist<t>




协变性和逆变性的缺乏:
   

缺乏操作符约束或者"数值"约束:

景爸爸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
泛型集合泛型集合泛型集合
06-26
泛型集合解释的非常好泛型集合泛型集合泛型集合解释的非常好泛型集合泛型集合泛型集合解释的非常好泛型集合泛型集合泛型集合解释的非常好泛型集合泛型集合
Java——泛型集合
weixin_30568591的博客
08-17 35
　　Java 集合有一个缺点——把一个对象 “丢进” 集合里之后，集合就会 “忘记” 这个对象的数据类型,当再次取出该对象时,该对象的编译类型就变成了 Object 类型(其运行时类型没变)。集合对元素类型没有任何限制，这样可能引发一些问题。例如，想创建一个只想保存Dog 对象的集合，但程序也可以轻易的将字符串类型数据“丢” 进集合当中。 Dog ououDog=new Dog("...
Java入门系列-19-泛型集合
weixin_30770783的博客
10-23 130
集合 如何存储每天的新闻信息？每天的新闻总数是不固定的，太少浪费空间，太多空间不足。 如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象，可以使用Java集合框架。 Java 集合框架提供了一套性能优良、使用方便的接口和类，位于 java.util 包中。 接口 Collection 存储一组不唯一，无序的对象，它有两个子接口 List和Set。List 接口存储一组不唯一，有序(插...
C#读取数据库返回泛型集合详解(DataSetToList)
09-04
本篇文章主要是对C#读取数据库返回泛型集合(DataSetToList)进行了介绍，需要的朋友可以过来参考下，希望对大家有所帮助
编写高质量代码改善C#程序——使用泛型集合代替非泛型集合(建议20)
01-19
建议20：使用泛型集合代替非泛型集合 在建议1中我们知道，如果要让代码高效运行，应该尽量避免装箱和拆箱，以及尽量减少转型。很遗憾，在微软提供给我们的第一代集合类型中没有做到这一点，下面我们看ArrayList这个...
自定义泛型集合
08-02
NULL 博文链接：https://zxlyecf2.iteye.com/blog/1977926
C#泛型集合与非泛型集合
10-06
在.NET FCL为我们提供了很多...结论：如果在C#2.0版本以上，尽量使用泛型集合类，而不使用非泛型集合类。因为，1. 泛型编程是从c#2.0开始才被.net支持的。2.泛型集合在性能和类型安全方面优于非泛型集 合。 。。。。
C#中Dictionary泛型集合7种常见的用法
09-02
本文主要介绍了Dictionary集合的7种最基础的用法，包括创建、添加、查找、遍历、删除等方法，程序都是由简入繁，希望能通过阅读简单的示例，给大家一些启发。
集合【泛型】
qq_48336929的博客
08-10 486
泛型 泛型部分知识思维导图 1、泛型介绍 1.1、为什么会出现泛型？ 集合中是可以存放任意对象的，只要把对象丢尽集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。 但是由于集合中什么类型的元素都可以存储。导致取出时，如果出现强转就会引发运行时 ClassCastException。 而因为集合存放的数据类型不固定，故网集合里面存放元素时，存在安全隐患，如果定义集合时，可以像定义数组一样指定数据类型，那么就可以解决该类安全问题。 JDK1.5
Java 集合-List
最新发布
qq_43339789的博客
05-10 979
集合主要分为两组(单列集合, 双列集合)
c#泛型集合list
08-21
C#泛型集合List是一种可以存储任意类型的动态数组，它位于System.Collections.Generic命名空间下。语法如下：List<T> listName = new List<T>(); 其中T代表泛型类型参数，可以是任意有效的C#数据类型。（引用） List集合可以通过add方法逐个添加元素，也可以使用AddRange方法将另一个List集合添加到当前集合中。例如，可以创建两个List<int>对象，一个用于存储偶数，一个用于存储奇数，然后将奇数集合添加到偶数集合中，并通过foreach循环遍历输出集合中的元素。代码如下（引用）： ```csharp int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; List<int> listEven = new List<int>(); List<int> listOdd = new List<int>(); foreach (int num in nums) { if (num % 2 == 0) { listEven.Add(num); } else { listOdd.Add(num); } } listEven.AddRange(listOdd); foreach (int item in listEven) { Console.Write(item + " "); } Console.ReadKey(); ``` 使用泛型集合List的一个好处是可以避免频繁的类型转换。通过指定泛型类型参数，我们可以直接在集合中存储特定类型的对象，而无需进行繁琐的类型转换。这样可以提高代码的可读性和效率。（引用）<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [C#中List泛型用法，必知必会！](https://blog.csdn.net/qq_44034384/article/details/106312390)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [c#List泛型集合](https://blog.csdn.net/linxianming_/article/details/125979400)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值