C#学习日记 列表List<T>

using System;
using System.Collections.Generic;

namespace Sample
{
public class MainEntryPoint
{
static int Main(string[] args)
{
//各种在列表里添加元素的方法
var july = new Racer(3, "July", "Wu", "China", 14);
var john = new Racer(5, "John", "Wu", "China", 14);
var mario = new Racer(16, "Mario", "Andretti", "USA", 12);
var racers = new List<Racer>(20){july, john, mario};
racers.Add(new Racer(14, "Niki", "Lauda", "Austria", 25));
racers.AddRange(new Racer[]
{
new Racer(12, "Jochen", "Rindt","Austria", 6),
new Racer(22, "Ayrton", "Senna", "Brazil", 41),
}
);
racers.Insert(3,new Racer(14,"Joyn","Wu","China",3));

//ForEach方法括号中应该放方法地址或者lambda表达式
//public delegate void Action<T>(T obj)没有返回值 参数是T类型的lambda

//racers.ForEach(r => Console.WriteLine("{0:A}",r));
/*for(int i = 0; i < racers.Count; i++)
{
Console.WriteLine("{0:W}",racers[i]);
}*/

//两种移除的方法 第一种是根据索引的位置 一种是根据元素对象 第二种实际上还是第一种因为第二种会先用IndexOf（）方法寻找元素的索引

/*racers.RemoveAt(3);
if(!racers.Remove(july))
Console.WriteLine("object not found in collection.");
foreach(Racer r in racers)
{
Console.WriteLine("{0:F}", r);
}*/

//运用自己写的类寻找符合国家相同的第一个元素的索引
//这个类中有一个参数存储国家信息
//还有一个方法匹配该对象的国家是否一致的方法返回布尔类型

/*int index1 = racers.FindIndex((new FindCountry("China")).FindCountryPredicate);
Console.WriteLine(index1);

//也可以写lambda表带式进行匹配
//public delegate bool Predicate<T>(T obj)返回值为布尔类型 参数为T类型
int index2 = racers.FindIndex(r => r.Country == "China");
int index3 = racers.FindIndex(r => r.LastName == "Wu");
Console.WriteLine(index2);
Console.WriteLine(index3);

//找到符合条件的所有项 返回一个集合
//前面的方法都是返回匹配的第一项就不再搜索了

List<Racer> bigWinners = racers.FindAll(r => r.Wins > 20);
foreach(Racer r in bigWinners)
{
Console.WriteLine("{0:A}",r);
}*/

//实现了IComparebale<Racer>接口 会自动的调用CompareTo（）方法进行排序
/*racers.Sort();
foreach(Racer r in racers)
{
Console.WriteLine("{0:A}",r);
}
Console.WriteLine("-------------------");

//public delegate int Comparison<T>(T x, T y)返回值是int 有两个类型为T的参数

racers.Sort((r1, r2) => r1.Wins.CompareTo(r2.Wins));
foreach(Racer r in racers)
{
Console.WriteLine("{0:W}",r);
}

//Sort（）方法里传递一个实现了IComparer接口的类的实例
//根据传递进来的比较类型 进行比较 排序

Console.WriteLine("-------------------");
racers.Sort(new RacerComparer(RacerComparer.CompareType.Country));
foreach(Racer r in racers)
{
Console.WriteLine("{0:A}",r);
}
Console.WriteLine("-------------------");*/

//一个集合往另一个集合进行转换
//public sealed delegate Toutput Convert<Tinput, Toutput>(Tinput from);

List<Person> persons = racers.ConvertAll<Person>(r => new Person(r.FirstName+" "+r.LastName));
foreach(Person p in persons)
{
Console.WriteLine(p);
}
return 0;
}
}
[Serializable]
public class Person
{
private string name;
public Person(string name)
{
this.name = name;
}
public override string ToString()
{
return name;
}
}
[Serializable]
public class Racer : IComparable<Racer>,IFormattable
{
public int Id{ get; private set;}
public string FirstName{ get; set;}
public string LastName{ get; set;}
public string Country{ get; set;}
public int Wins{ get; set;}
public Racer(int id, string firstName,string lastName, string country)
:this(id,firstName,lastName,country,0)
{
}
public Racer(int id, string firstName, string lastName, string country, int wins)
{
this.Id = id;
this.FirstName = firstName;
this.LastName = lastName;
this.Country = country;
this.Wins = wins;
}
public override string ToString()
{
return String.Format("{0} {1}",FirstName,LastName);
}
public string ToString(string format,IFormatProvider formatProvider)
{
if(format == null) format = "N";
switch(format)
{
case "N":
return ToString();
case "F":
return FirstName;
case "L":
return LastName;
case "W":
return String.Format("{0},Wins:{1}",ToString(),Wins);
case "C":
return String.Format("{0},Country:{1}",ToString(),Country);
case "A":
return String.Format("{0},Country:{1},Wins:{2}",ToString(),Country,Wins);
default:
throw new FormatException(String.Format(formatProvider,"Format {0} is not supported",format));
}
}
public string ToString(string format)
{
return ToString(format, null);
}
public int CompareTo(Racer other)
{
int complare = LastName.CompareTo(other.LastName);
if(complare == 0)
complare = FirstName.CompareTo(other.FirstName);
return complare;
}
}
public class FindCountry
{
private string country;
public FindCountry(string country)
{
this.country = country;
}
public bool FindCountryPredicate(Racer r)
{
//Contract.Requires<ArgumentNullException>(r != null);//异常我还没有学到估计是如果r为null就抛这个异常的意思
return r.Country == country;
}
}
public class RacerComparer : IComparer<Racer>
{
public enum CompareType
{
FirstName,
LastName,
Country,
Wins
}
private CompareType compareType;
public RacerComparer(RacerComparer.CompareType type)
{
this.compareType = type;
}
public int Compare(Racer r1, Racer r2)
{
if(r1 == null && r2 == null) return 0;
if(r1 == null)return -1;
if(r2 == null)return 1;
int result;
switch(compareType)
{
case CompareType.FirstName:
return r1.FirstName.CompareTo(r2.FirstName);
case CompareType.LastName:
return r1.LastName.CompareTo(r2.LastName);
case CompareType.Country:
result = r1.Country.CompareTo(r2.Country);
if(result == 0)
result = r1.LastName.CompareTo(r2.LastName);
if(result == 0)
result = r1.FirstName.CompareTo(r2.FirstName);
return result;
case CompareType.Wins:
return r1.Wins.CompareTo(r2.Wins);
default :
throw new ArgumentException("Invalid Compare Type");
}
}
}
}