Stack 类 全部显示

by admin on 2020年2月2日

NET   Framework   类库        
   
  Stack   类   全体显得  
  代表对象的精简的后进先出会集。  
   
  有关此类型全数成员的列表,请参阅   Stack   成员。  
   
  System.Object  
        System.Collections.Stack  
   
  [Visual   Basic]  
  <Serializable>  
  Public   Class   Stack  
        Implements   ICollection,   IEnumerable,   ICloneable  
   
  [C#]  
  [Serializable]  
  public   class   Stack   :   ICollection,   IEnumerable,  
ICloneable  
   
  [C++]  
  [Serializable]  
  public   __gc   class   Stack   :   public   ICollection,  
IEnumerable,  
        ICloneable  
   
  [JScript]  
  public  
        Serializable  
  class   Stack   implements   ICollection,   IEnumerable,  
ICloneable  
   
  线程安全  
  此类型的公家静态(在   Visual   Basic   中为  
Shared)成员对于四线程操作是悠闲自在的。不能够承保实例成员是线程安全的。  
   
  若要保险   Stack   的线程安全,则必需经过由   Synchronized  
方法再次来到的卷入来进行全数操作。  
   
 
通过会集枚举在真相上不是一个线程安全的进度。以致在对集中举行协作管理时,别的线程还能够改革该集合,那会形成枚举数引发那三个。若要在枚举进程中保障线程安全,能够在全体枚举进度中锁定集中,也许捕捉由于其余线程进行的改观而引发的十二分。
 
   
  备注  
  将   Stack   达成为循环缓冲区。  
   
  要是   Count   小于货仓的容积,则   Push   为   O(1State of Qatar  
操作。假诺急需充实容积以包容新成分,则   Push   成为   O(nState of Qatar   操作,此中  n   为   Count。Pop   为   O(1卡塔尔   操作。  
   
  Stack   接纳空引用(Visual   Basic   中为  
Nothing)作为有效值並且同意再次的因素。  
   
  示例  
  [Visual   Basic,   C#,   C++]   下列示例表明什么创造  
Stack   并向其加多值,以致怎么着打印出其值。  
   
  [Visual   Basic]    
  Imports   System  
  Imports   System.Collections  
  Imports   Microsoft.VisualBasic  
   
  Public   Class   SamplesStack          
           
          Public   Shared   Sub   Main()  
           
                  ‘   Creates   and   initializes   a   new   Stack.
 
     

— 集结(包涵部分字典知识)

绝大多数会晤都在
 System.Collections,System.Collections.Generic八个命名空间。

动态数组–集结类–能够增添放肆档案的次序数据–稍低于list<T>
ArrayList,能够看成是动态的数组。Add、Clear、Contains、Count、Remove、RemoveAt、ToArray(转变,再没提到)、索引器
C#中全部的数组类型int[]、string[]等都以继续自Array类。list1.AddRange(strs卡塔尔会集,ArrayList、HashSet、Hashtable、Dictionary等都足以叫做集结类。完成了IEnumerable(getEnumerator(卡塔尔国卡塔尔、IEnumerable<T>的接口都足以应用foreach进行遍历。

里头System.Collections.Generic特意用来泛型集结。

数组length 集合count—-ArrayList(每黄金年代项object,大概须要类型转变)
Convert–是否归属非常类型都会尝试转变显式调换–唯有三头在同品种范围才能够转

针对特定项指标联谊类型坐落于System.Collections.Specialized;命名空间;

 

线程安全的集结类坐落于System.Collections.Concurrent;命名空间。

static void Main(string[] args){ArrayList
list1 = newArrayList();list1.Add(“aaa”);list1.Add(“bbb”);list1.Add(“ccc”);list1.Add(“asfdadsfa”);list1.Add(“asdfasdfsaf”);//list1.Remove(“bbb”);list1.RemoveAt(0);Console.WriteLine(list1[0]卡塔尔(قطر‎;//Remove八个因素之后前边的要素会递补PrintList(list1卡塔尔;Console.WriteLine(list1.Contains(“www”State of Qatar卡塔尔;//判别是或不是留存Console.WriteLine(list1.Contains(“ccc”卡塔尔(قطر‎卡塔尔;list1.Clear(卡塔尔;//清空Console.WriteLine(list1.Count卡塔尔;Console.ReadKey(卡塔尔国;}static voidMain(string[]
args卡塔尔{//<键的类别,值的种类>Dictionary<string, int> dict
= new Dictionary<string, int>(卡塔尔(قطر‎;dict.Add(“0108888888888”,30卡塔尔国;//放进去一个键值对dict.Add(“1108889998x”, 18卡塔尔;dict.Add(“0108888889999”, 22State of Qatar;dict.Add(“010888888x”, 18State of Qatar;//假诺加上相符key的项会报错//dict.Add(“010888888x”,19State of Qatar;//用索引的方式赋值也正是存在就update,子虚乌有就insert//和Add比较,这种情势不会报错dict[“010888888x”]
= 19;dict[“010888888y”] = 19;int age =
dict[“0108888888888”];//依照key找valueConsole.WriteLine(age卡塔尔;//dict.Remove(“010888888x”卡塔尔;//移除钦赐key的值//dict.Clear(卡塔尔(قطر‎;//Console.WriteLine(dict.ContainsKey(“0108888888888″State of Qatar卡塔尔;//Console.WriteLine(dict.ContainsKey(“afdasfasdfdsa”卡塔尔国卡塔尔;//推断是或不是存在keyforeach (string key in dict.Keys卡塔尔国{int value
= dict[key];//select * from …where
id=@IdConsole.WriteLine(“{0}={1}”, key, value);}

上面是会集和列表完结的接口如下:

 

图片 1

用ArrayList的麻烦的地点:数据放进去就不精晓是什么品种的了;不能够防卫不法类型数据的放入;将ArrayList重临给其余函数,会令调用者很困惑。要分别变量、再次来到值类型和事实上指标类型的区分。IntArrayList,StringArrayList又软磨硬泡。
大家供给泛型的ArrayList,所以就有了List<T>。List<int>
除此而外并无例外,<int>表示List中放的数据类型是int类型的,因为有评释类型时的预定,因而具有办法的参数、重临值都是规定项指标了。
从三个大背头的ArrayList、List<int>中抽取最大数。别用max方法。
List<int>
实现了IEnumerable<int>(泛型版本的IEnumerable)、ICollection<int>
(泛型版本的ICollection) 。
全数的List<T>全体的措施也都以泛型的,范型的聚众提供的艺术更加多,Max、Min、Sort等,讲Linq的时候会详细介绍。

一、列表

ArrayList(非泛,只能object卡塔尔国和List(泛型,任意档期的顺序,包罗自定义的类卡塔尔(قطر‎—非泛和泛型(IList,
ICollection, IEnumerable,||||||||使用大小可按需动态扩大的数组完毕System.Collections.IList 接口。)
—–都归属集结System.Collection(包蕴泛型集结【Dictionary、List、HashSet、IList<T>,
ICollection<T>,
IEnumerable<T>,】和非泛型集结【ArrayList、Hashtable】State of Qatar

[csharp] 

using System.Collections;非泛型命名空间 // 摘要: //
定义全部非泛型集结的抑扬顿挫、枚举数和承办方法。 [ComVisible(true)] public
interface ICollection : IEnumerable

 

using System.Collections.Generic;泛型命名空间

[Serializable]  
[DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]  

[DebuggerDisplay("Count = {Count}")]  

public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable  

二 集合(Collections)—-Linq—Lamda

 

IList和List<T>(后面一个倘诺不加<T>,只可以是非泛型;后面一个只可以是泛型,必得加<T>,List子虚乌有卡塔尔(قطر‎IEnumerable和IEnumerable<T>和Enumerable(IEnumerable<T>继承自
IEnumerable,
二者皆以为贯彻简单的循环迭代(相近foreach,只有完毕IEnumerable接口foreach技巧用)提供的接口,前面叁个为非泛型提供,前者泛型;Enumerable提供生机勃勃组用于查询实现System.Collections.Generic.IEnumerable<T> 的指标的 static(在
Visual // Basic 中为 Shared)方法。卡塔尔 List<T> :
IList<T>(除了前面三个世袭前者;后边八个类,方法多;前面一个接口,方法少,只定义常用的多少个法子,前者给落到实处的)
Dictionary<K,V>的非泛型对应的是Hashtable;List<T>→ArrayList
HashSet<T>:不能盛开重复的多少,重复的多寡只保留生龙活虎份。
泛型(重临T)—-List<T> :
IList<T>:ICollection<T>:IEnumerable<T>:IEnumerable
非泛型(重临object)—ArrayList :
IList::ICollection:IEnumerable:ICloneable

从那些能够看看,泛型会集List<T>达成了如此多接口,具体接口的新闻能够通过工具查看。

瞩目List()是个法子
(*卡塔尔Stack<T>,栈,先入后出,Push(压栈)、Pop(出栈)。
(*卡塔尔Queue<T>,队列,先入先出:Enqueue(入队)、Dequeue(出队)

 

// 摘要: // 提供蓬蓬勃勃组用于查询完成System.Collections.Generic.IEnumerable<T> 的靶子的 static(在
Visual // Basic 中为 Shared)方法。 public static class Enumerable

using System;  
using System.Collections.Generic;  

namespace ConsoleApplication1  
{  
    public class Program  
    {  
        static void Main(string[] args)  
        {  
            List<String> list = new List<string>();  
            list.Add("张三");  
            list.Add("李四");  
            list.Add("王五");  
            list.Add("田六");  
            list.Add("赵七");  

            for (int i = 0; i < list.Count; i++)  
            {  
                Console.WriteLine("for循环:" + i.ToString() + "=" + list[i]);  
            }  

            list.RemoveAt(0);  
            foreach (String item in list)  
            {  
                Console.WriteLine("foreach迭代:" + item);  
            }  
            list.AddRange(new String[] { "Hello1", "Hello2", "Hello3" });  

            list.ForEach(Print);  

            Console.Read();  
        }  

        private static void Print(String item)  
        {  
            Console.WriteLine("ForEach:" + item);  
        }  
    }  

}  

_________________________________________
public interface IEnumerable { // 摘要: //
再次来到三个巡回访谈群集的枚举数。——相近foreach // // 再次回到结果: //
可用来循环访谈会集的 System.Collections.IEnumerator 对象。

  

摘要: // 协理对非泛型群集的简短迭代(形似foreach卡塔尔国 [ComVisible(true)]
[Guid(“496B0ABF-CDEE-11d3-88E8-00902754C43A”)] public interface
IEnumerator { // 摘要: // 获取群集中的当前成分。 // // 重回结果: //
集结中的当前成分。 // // 卓殊: // System.InvalidOperationException: //
枚举数定位在该集结的首先个因素此前或最终一个要素之后。 object Current {
get; }

 

// 摘要: // 将枚举数推动到集结的下多少个要素。 // // 重回结果: //
尽管枚举数成功地推向到下一个要素,则为
true;若是枚举数赶过集合的末尾,则为 false。 // // 相当: //
System.InvalidOperationException: // 在创建了枚举数后集结被修正了。 bool
MoveNext(卡塔尔国; // // 摘要: //
将枚举数设置为其初叶地点,该岗位放在集结中率先个成分早前。 // // 非凡:
// System.InvalidOperationException: // 在创建了枚举数后会集被改造了。
void Reset(卡塔尔; } }

 二、队列

三 词典(归于集合)

队列先进先出,贰只进二只出,用Queue<T>完毕

Key-value Pair 键值对。成语不得以另行,不过解释能够再度。
Dictionary<K,V>: Add:加多,假使重复,则报错
索引器方式设置值:可以再度设置,即便不设有也没涉及,假设再一次则新数据覆盖旧数据
ContainsKey,判定是或不是留存这几个Key
(常考卡塔尔Dictionary<K,V>的非泛型对应的是Hashtable;List<T>→ArrayList

[csharp]  

ASP.NET 技术员每一日要应酬的
Application、Cache、Session、Request.Params等均由 Dictionary /Hashtable
完毕。数据库中的索引也是日常的规律。 自个儿出手写Dictionary<char,
char> 。Dictionary质量测量试验(做紫炁星文翻译200次卡塔尔(قطر‎。为啥速度这么快?
查字典为何能如此快?目录中著录了种种汉字的页码,查找的时候先看汉字的页码,再翻到钦点的页就可以非常急忙的找到词条了

 

Dictionary中有贰个仓库储存键值没有错区域,选择贰个稳固算法(散列算法,非常快,能够感到时间复杂度为O(1卡塔尔国)依照key来测算那几个kvp贮存的地点,总结key的值的键值对应该积存之处,将键值对放入钦命的地址就能够。查找的时候首先总括key的地点,就能够找到数据了。依照key找房间号,并非每一个房子找。(*)

[Serializable]  
[DebuggerTypeProxy(typeof(System_QueueDebugView<>))]  
[ComVisible(false)]  
[DebuggerDisplay("Count = {Count}")]  
public class Queue<T> : IEnumerable<T>, ICollection, IEnumerable  

HashSet<T>:不可能盛开重复的数码,重复的数额只保留后生可畏份。Add(T
value卡塔尔国添澳元素;Contains(T
value卡塔尔(قطر‎决断是或不是留存元素,HashSet使用了和Dictionary相似的算法,因而Contains方法效用特别高,时间复杂度为O(1卡塔尔。
面试题:抽取整数数组中不另行数据的个数,{30,31,99,38,31,99,50}。
面试题:现成1~10共13个整数,已随机归入一个有8个要素的数组a[8]。要求寻找从未被归入数组的那2个数。注意:程序不用完毕自然数随机归入数组的历程,测验数据{9,8,5,3,1,10,2,7}。
(*卡塔尔Stack<T>,栈,先入后出,Push(压栈)、Pop(出栈)。
(*卡塔尔(قطر‎Queue<T>,队列,先入先出:Enqueue(入队)、Dequeue(出队)

 

能够看见队列完毕了汇集的接口,迭代的接口

 

[csharp]  

 

图片 2图片 3

using System;  
using System.Collections.Generic;  

namespace ConsoleApplication1  
{  
    public class Program  
    {  
        static void Main(string[] args)  
        {  
            Queue<String> queue = new Queue<string>();  
            //进队  
            queue.Enqueue("张三");  
            queue.Enqueue("李四");  
            queue.Enqueue("王五");  
            queue.Enqueue("田六");  
            queue.Enqueue("赵七");  

            foreach (String item in queue)  
            {  
                Console.WriteLine("foreach迭代:" + item);  
            }  

            //出队  
            while (queue.Count > 0)  
            {  
                Console.WriteLine("出队:" + queue.Dequeue());  
            }  

            Console.Read();  
        }  
    }  
}  

View Code

 

 三、栈

栈:从同生龙活虎边先进后出,用Stack<T>落成

[csharp]  

 

[DebuggerDisplay("Count = {Count}")]  
   [DebuggerTypeProxy(typeof(System_StackDebugView<>))]  
   [ComVisible(false)]  
   public class Stack<T> : IEnumerable<T>, ICollection, IEnumerable  

  

栈也是促成了聚众接口与迭代接口的

[csharp]  

 

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace ConsoleApplication1  
  5. {  
  6.     public class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             Stack<String> stack = new Stack<string>();  
  11.             //进栈  
  12.             stack.Push(“张三”);  
  13.             stack.Push(“李四”);  
  14.             stack.Push(“王五”);  
  15.             stack.Push(“田六”);  
  16.             stack.Push(“赵七”);  
  17.   
  18.             foreach (String item in stack)  
  19.             {  
  20.                 Console.WriteLine(“foreach迭代:” + item);  
  21.             }  
  22.   
  23.             //出栈  
  24.             while (stack.Count > 0)  
  25.             {  
  26.                 Console.WriteLine(“出栈:” + stack.Pop());  
  27.             }  
  28.   
  29.             Console.Read();  
  30.         }  
  31.     }  
  32. }  

 四、链表

LinkedList是多少个双向链表,链表有个有一点,正是在链表中间插入、删除元素不慢,但是查找中间与终极的因素极慢,需求贰个节点一个节点的去找。

[csharp] view
plaincopy

 

  1. [Serializable]  
  2. [DebuggerTypeProxy(typeof(System_CollectionDebugView<>))]  
  3. [DebuggerDisplay(“Count = {Count}”)]  
  4. [ComVisible(false)]  
  5. public class LinkedList<T> : ICollection<T>, IEnumerable<T>, ICollection, IEnumerable, ISerializable, IDeserializationCallback  

有鉴于此链表也会有汇集的性状的,能够迭代,同一时候还大概有链表的特征

 

[csharp] view
plaincopy

 

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace ConsoleApplication1  
  5. {  
  6.     public class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             LinkedList<String> lList = new LinkedList<string>();  
  11.             LinkedListNode<String> node = new LinkedListNode<string>(“root”);  
  12.             lList.AddFirst(node);  
  13.             node = lList.AddAfter(node, “张三”);  
  14.             node = lList.AddAfter(node, “李四”);  
  15.             node = lList.AddAfter(node, “王五”);  
  16.             node = lList.AddAfter(node, “田六”);  
  17.             node = lList.AddAfter(node, “赵七”);  
  18.   
  19.             foreach (String item in lList)  
  20.             {  
  21.                 Console.WriteLine(“foreach迭代:” + item);  
  22.             }  
  23.   
  24.             node = lList.First;  
  25.             Console.WriteLine(“第一个要素:” + node.Value卡塔尔;  
  26.             node = lList.Last;  
  27.             Console.WriteLine(“最终多个要素:” + node.ValueState of Qatar;  
  28.             Console.Read();  
  29.         }  
  30.     }  
  31. }  

 五、有连串表

SortedList选拔键-值对存款和储蓄,键不可能重新,何况会基于key进行排序

[csharp] view
plaincopy

 

  1. [Serializable]  
  2. [DebuggerTypeProxy(typeof(System_DictionaryDebugView<,>))]  
  3. [DebuggerDisplay(“Count = {Count}”)]  
  4. [ComVisible(false)]  
  5. public class SortedList<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IEnumerable  

能够见到SortedList不仅仅具备字典的风味,还大概有群集,迭代的功能

 

[csharp] view
plaincopy

 

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace ConsoleApplication1  
  5. {  
  6.     public class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             //Key必须唯风姿洒脱,假如不唯黄金年代能够杜撰Lookup<TKey,TElement>  
  11.             SortedList<int, String> sList = new SortedList<int, string>();  
  12.             sList.Add(100, “张三”);  
  13.             sList.Add(21, “李四”);  
  14.             sList.Add(13, “王五”);  
  15.             sList.Add(44, “田六”);  
  16.             sList.Add(35, “赵七”);  
  17.   
  18.             foreach (KeyValuePair<int, String> item in sList)  
  19.             {  
  20.                 Console.WriteLine(“key=” + item.Key.ToString() + “;value=” + item.Value);  
  21.             }  
  22.   
  23.             Console.Read();  
  24.         }  
  25.     }  
  26. }  

 六、字典

词典是很复杂的数据布局,允许通过key来寻觅值,字典可以轻易增加、删除成分,未有群集由于活动成分导致的开采。

[csharp] view
plaincopy

 

  1. [Serializable]  
  2.     [DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]  
  3.     [DebuggerDisplay(“Count = {Count}”)]  
  4.     [ComVisible(false)]  
  5.     public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback  

能够看看词典也保有集结的性状,能够迭代

 

[csharp] view
plaincopy

 

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace ConsoleApplication1  
  5. {  
  6.     public class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             //Key必需唯后生可畏  
  11.             Dictionary<int, String> dict = new Dictionary<int, string>();  
  12.             dict.Add(11, “张三”);  
  13.             dict.Add(1, “李四”);  
  14.             dict.Add(2, “王五”);  
  15.             dict.Add(16, “田六”);  
  16.             dict.Add(12, “赵七”);  
  17.   
  18.             foreach (KeyValuePair<int, String> item in dict)  
  19.             {  
  20.                 Console.WriteLine(“key=” + item.Key.ToString() + “;value=” + item.Value);  
  21.             }  
  22.   
  23.             Console.Read();  
  24.         }  
  25.     }  
  26. }  

 提起字典,顺便谈一下萧规曹随字典,与平稳列表对应;SortedDictionary,SortedList,SortedSet

会依照Key实行排序

[csharp] view
plaincopy

 

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace ConsoleApplication1  
  5. {  
  6.     public class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             //Key必得唯后生可畏  
  11.             SortedDictionary<int, String> dict = new SortedDictionary<int, string>();  
  12.             dict.Add(11, “张三”);  
  13.             dict.Add(1, “李四”);  
  14.             dict.Add(2, “王五”);  
  15.             dict.Add(16, “田六”);  
  16.             dict.Add(12, “赵七”);  
  17.   
  18.             foreach (KeyValuePair<int, String> item in dict)  
  19.             {  
  20.                 Console.WriteLine(“key=” + item.Key.ToString() + “;value=” + item.Value);  
  21.             }  
  22.   
  23.             Console.Read();  
  24.         }  
  25.     }  
  26. }  

 

 七、集

集(Set卡塔尔国:包罗不另行成分,常用HashSet,SortedSet

[csharp] view
plaincopy

 

  1. [Serializable]  
  2.    [DebuggerDisplay(“Count = {Count}”)]  
  3.    [DebuggerTypeProxy(typeof(HashSetDebugView<>))]  
  4.    public class HashSet<T> : ISerializable, IDeserializationCallback, ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable  

 

[csharp] view
plaincopy

 

  1. [Serializable]  
  2.    [DebuggerTypeProxy(typeof(SortedSetDebugView<>))]  
  3.    [DebuggerDisplay(“Count = {Count}”)]  
  4.    public class SortedSet<T> : ISet<T>, ICollection<T>, IEnumerable<T>, ICollection, IEnumerable, ISerializable, IDeserializationCallback  

 

[csharp] view
plaincopy

 

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace ConsoleApplication1  
  5. {  
  6.     public class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             HashSet<String> hSet = new HashSet<string>();  
  11.             hSet.Add(“张三”);  
  12.             hSet.Add(“李四”);  
  13.             hSet.Add(“王五”);  
  14.             hSet.Add(“田六”);  
  15.             hSet.Add(“赵七”);  
  16.   
  17.             foreach (String item in hSet)  
  18.             {  
  19.                 Console.WriteLine(“foreach迭代:” + item);  
  20.             }  
  21.   
  22.             Console.Read();  
  23.         }  
  24.     }  
  25. }  

 

[csharp] view
plaincopy

 

  1. using System;  
  2. using System.Collections.Generic;  
  3.   
  4. namespace ConsoleApplication1  
  5. {  
  6.     public class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             SortedSet<String> hSet = new SortedSet<string>();  
  11.             hSet.Add(“张三”);  
  12.             hSet.Add(“李四”);  
  13.             hSet.Add(“王五”);  
  14.             hSet.Add(“田六”);  
  15.             hSet.Add(“赵七”);  
  16.   
  17.             foreach (String item in hSet)  
  18.             {  
  19.                 Console.WriteLine(“foreach迭代:” + item);  
  20.             }  
  21.   
  22.             Console.Read();  
  23.         }  
  24.     }  
  25. }  

质量相比:

图片 4

 

出自:

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图