字符串于字符互相转换:
字符串转字符:
String str="asfasdfakdfja";
Char[] ch=new ch[]{};
ch=str.ToCharArray();
字符转字符串:
Char[] ch=new ch[](w,e,r,y,f,y,u,q,s,9,4);
String str=new String(ch);
冒泡排序:
Int [] nums=new nums[]{134,3214,543,2341,-143,124,-9,0};
For(int j=0;j<nums.length;j++)
{
For(int i=0;i<nums.length-1-j;i++)
{
If(nums[i]>nums[i+1])
{
Int stmp=nums[i];
nums[i]=nums[i+1];
nums[i+1]=stmp;
}
}
}
基本读文件:
//StreamReader的用法:
//文件地址: c:\\abc\123.txt
StreamReader sr=new StreamReader("c:\\abc\123.txt",Encoding.GetEncoding("gb2312"));
Char [] num=new char [255] //0--255就是265
Int f; //给Read返回值做判断.
do
{
//Read返回值是int类型,假如读到文件返回相应的数字,没有则返回负数.
//Read参数(Char数组,从第几个开始,一次读取的长度)
f=sr.Read(num,0,255)
}
While(f>=0)
{
String str=new String(num); //也可用SB来追加/
}
//FileStream用法
//FileMode状态 FileAccess是读/写文件
FileStream fs=new FileStream("c:\\abc\123.txt",FileMode.Open,FileAccess.Read);
复制文件示例代码:
Using(FileStream creatFile=new FileStream(@"c:\new123.txt",FileMode.Create))
{
Using(FileStream openFile=new FileStream(@"c:\abc\123.txt",FileMode.Open,FileAccess.Read))
{
Byte [] b=new Btye[255];
Int num;
While(num=openFile.read(b,0,b.Length)>0)
{
createFile.Write(b,0,num);
}
}
}
单例模式:
//单例模式就是在程序里,只允许有一个这样的类.
//单例模式的特点:1.实现不允许用new 对象,因为不允许实现多个.对象
2.该类的构造方法必须私有
3.必须通过方法/属性来访问.(示例用方法返回)
代码如下:
//调用:
MySingle mysingle=MySingle.MySingleOne();
//单例模式类:
Class MySingle
{
//构造方法私有
Private MySingle
{
}
//初始字段私有,否则有更改的可能
Private Static MySingle createMySingle=null;
//必须是Static 因为构造方法是私有的,
Public Static MySingle MySingleOne()
{
//判断初始字段是否为第一次加载,如果是New,否则直接返回初始字段
If(createMySingle==null)
{
retrun New MySingle
}
return createMySingle;
}
//之后和普通类一样....
Public string name;
Public int age;
.......
}
序列化与反序列化:
//序列化的目的就是将对象,序列化成二进制流文件保存起来.
//反序列化目的是将序列化后的二进制流文件还原成对象.
//如果将类序列化,需要在该类前面加上[Serializable]标记
代码如下:
//假设要将List<Person> list序列化
//序列化代码:
//序列化用BinaryFormatter背下来,需要引用命名空间
BinaryFormatter bf=new BinaryFormatter();
Using(FileStream fs=New FileStream(@"c:/abc.dat",FileMode.Create,FileAccess.Write))
{
//参数1:必须是流;参数2:需要序列化的object
bf.Serialize(fs,list);
}
//反序列化代码:
BinaryFormatter dbf=BinaryFormatter();
List<Person> pList=new list<Person>();
Using(FileStream dfs=New FileStream(@"c:/abc.dat",FileMode.Open,FileAccess.Read))
{
//因为反序列化后的文件类型为object要强制转换;;;反序列化的参数必须是流
pList=(list<Person>)nbf..Deserialize(dfs);
}
//示例:将一个类序列化到一个文件中
//可序列化类必须用Serializable标记
[Serializable]
Class Person
{
String name;
Int age;
Int num;
String add;
Public void SayHello()
{
Console.WriteLine("我的名字是{0},我今年{1},我家在{2}",name,age,add);
}
}
//调用:
//序列化
Person person=new Person();
BinaryFormatter bf=new BinaryFormatter();
Using(FileStream fs=new FileStream(@"c:\123.dat",FileMode.Creat,FileAccess.Write))
{
bf.Serialize(fs,person);
}
//反序列化
BinaryFormatter dbf=New BinaryFormatter();
Using(FileStream fs=new FileStream(@"c:\123.dat",FileMode.Open,FileAccess.Read))
{
Person p=(Person)Deserialize();
}
文件管理操作:
文件管理:File
//判断文件是否存在
//创建一个名为1.txt的文件
//移动文件参数1:原绝对路径文件名;参数2:将要移动文件的绝对路径文件名
File.Move(@"c:\123\1.txt",@"d:\2.txt");
//复制文件
File.Copy(@"c:\123\1.txt",@"d:\2.txt");
//删除文件
//以一个流的形式返回
File.Open();
目录管理:Directory
//判断目录是否存在
Directory.Exists(@"c:\123");
//创建一个名为123的文件夹
Directory.CreatDirectory(@"c:\123");
//移动文件夹
Directory.Move("@c:\123",@"d:\123");
//删除文件目录
//第2个参数为true时删除目录中所有的文件.
Directory.Delete(@"C:\123",true);
Path类
Path类的用途是,针对路径,文件名,后缀名,的操作.
//合并路径
System.IO.Path.Combine(目录名,文件名+后缀);
//修改后缀
Path.ChangeExtension(文件名+后缀,需要修改的后缀名);
//获取后缀名
Path.GetExtension(目录名);
//获取路径名
Path.GetDirectoryName(目录名);
//获取文件名
Path.GetFileNameWithoutExtension(目录名);
//当我们不想把数据保存到文件中,那就把临时数据放到临时缓冲文件中去
Path.GetTempPath();
正则表达式:
元字符:
．：匹配除/n意外所以单个字符．例如：bug b.g good g..d
[]：匹配中括号中任何一个单个字符．例如：b[abc]g 可以匹配bag bbg bcg
也可以写成b[0-9]g 可以匹配b0g到b9g 当为[0-9a-zA-Z]可以匹配任何一个大小写字母和数字
｜：或的意思例如:f｜good可以匹配f或good切不要认为可以匹配到food和good；如果想要匹配成food或者good 需要这么写:(f｜g)ood
()：优先级改变优先级 定义提取组(分组)．
＾：匹配它后面的字符
＄：匹配它前面的字符
例如:＾f｜ood＄匹配ｆ和ood结尾的
例如:^f｜good＄匹配以f和good结尾
例如:^(f|g)ood$匹配只可以匹配food和good
*：匹配0次或多次他前面的表达式可以理解为：｛０，｝
+：匹配1次或多次它前面的表达式可以理解为：｛１，｝
//因为*匹配0次或多次,没有匹配上的用空代替
例如:正则z*字符串abczzz->匹配 _ _ _ zzz
例如:正则az*字符串abcazdfazzz->匹配a az azzz
例如:正则az+字符串abcazdfazzz->匹配az azzz
?：匹配它前面的表达式0次或1次 或者 终止贪婪模式可以理解为｛０，１｝
例如:正则do(es)?字符串adfadowedoes99wer->匹配do does
{数字}：能够匹配它前面的字符确定的次数．
例如:z{3} 匹配字符串中所有z连续出现3次的
例如:z{3,}匹配三次以上的(包括三次)
例如:z{3,6}匹配三次到六次的
[^]：表示非
\d：代表一个数字，等同于[0-9]
\D：代表一个非数字 等同于[^0-9]
\s：代表换行符.Tab制表符等空白字符
\S：代表非空白字符 例如(a0%$@~)
\w：代表字母数字下划线或汉字
\W：代表非\w等同于[^\w]
贪婪模式？：正常情况下正则表达式默认尽可能多的匹配,如果根据需要少匹配，需要终止贪婪模式．
在限定符后面加上？号即终止贪婪模式．？要加载限定符的后面，？号后面是要终止的字符．
例如：终止贪婪模式：正则/w+?> 字符串为aaa>bbb>ccc>ddd>->结果aaa> bbb> ccc> ddd>
贪婪模式：正则/w+>字符串为aaa>bbb>ccc>ddd>->结果aaa>bbb>ccc>ddd>
使用正则表达式:
判断是否匹配:Regex.IsMatch("字符串","正则表达式");
提取一个字符串:Regex.Match("字符串","正则表达式");
循环提取所有字符串:Regex.Matches("字符串","正则表达式");
字符串替换:Regex.Replace("字符串","正则","替换内容");
分组:Regex.Groups[数字]例如正则表达式[^d]*((\d{2})_\(d{2})\.jpg)Regex.Groups[0]将匹配结果全部显示,Regex.Groups[1]现实正则表达式()里面((\d{2})_\(d{2})\.jpg)即第1个括号内的结果;Regex.Groups[2]现实正则表达式()里面(\d{2})即第2个括号内的结果;Regex.Groups[3]现实正则表达式()里面(\d{2})即第3个括号内的结果;
示例代码:
例子1://调用Regex类的构造方法实现
String str="safsadf927347fasdfa";
Regex r=new Regex("\d+");
If(r.IsMatch(str))
{
//Regex类中的Match方法返回值是Match类型,所以要用Match类型定义的变量m接收
Match m=r.Match(str);
//Value属性返回匹配后的结果,为string类型
Console.WriteLine(m.Value);
}
例子2://使用Regex静态方法实现
String str="safsadf927347fasdfa";
If(Regex.IsMatch(str,@"\d+"))
{
Match m=Regex.Match(str,@"\d+");
Console.WriteLine(m.Value);
}
例子3://使用Matches
String str="safsadf927347fasdfa";
Regex r=new Regex("\d+");
If(r.IsMatch(str))
{
//Regex类中的Matches方法返回值是MatchCollection集合类型,所以要用MatchCollection类型定义的变量m接收
MatchCollection m=r.Matches(str);
//用foreach循环遍历MatchCollection集合,值分别付给Match的变量,输出结果
Foreach(Match match in m)
{
//Value属性返回匹配后的结果,为string类型
Console.WriteLine(match.Value);
}
}
例子４：使用Replace替换
String date="2012-12-21";
//用到分组,通过$占位符替换匹配后的结果
date=Regex.Replace("date",@"(\d[4])-(\d[2])-(\d[2]"))",@"年$1,月$2,日$3");
//date结果为2012年12月21日
委托:
//委托是类型,是以变量形式存储方法名,然后直接调用委托变量名使用该方法.
//委托通常放在类外命名空间内(整个命名空间可有),也可以放到类内(仅该类可用)
例如:
//定义:
//定义委托类型,按照规范委托类型名后面要+Delegate,
Public delegate int FunDelegate(int num);
Class Person
{
Public int fun1(int f1)
{
Return 1;
}
Public int fun2(int f2)
{
Return 2;
}
}
//调用:
FunDelegate fd=fun1;
Int n=fd(1);
//结果:n=1
多播委托(委托链):
可以联动按照顺序依次使用多个方法,可以用到多播委托
//使用+=为委托变量依次赋值多个方法名,执行顺序从上到下.
//如果+=后使用赋值运算符"="那么就会"覆盖"(即直接运行最后面"="的方法)
//如果其中一个+=出现异常,其后所有方法不再执行.
//示例代码:
//定义
Public delegate void MyDelegate();
//类
Class MyP
{
Public void Fun1(){};
Public void Fun2(){};
Public void Fun3(){};
}
//调用
MyDelegate Md=new MyP().Fun1;
Md+=MyP().Fun2;
Md+=MyP().Fun3;
匿名方法和Lambda表达式:
匿名方法:
//当一个方法在整个程序中,仅仅使用一次,就没有必要给这个方法写名字,通常写成匿名方法.
示例:
//声明定义委托
Public delegate void FunDelegate(int num);
//调用
//匿名方法没有名字,直接写delegate关键字(委托类型参数)
FunDelegate fd=delegate(int i);
{
//方法体
}
//使用
fd(int i);
Lambda表达式:
//语法
参数列表(如果只有1个参数可以省略圆括号)=>方法体(如果方法体有多个,那么用{}括起来)
参数列表没有参数也得写圆括号.
参数列表中如果有多个参数,使用逗号分割,一般不写类型名,当容易混淆时,才写类型名.
委托类型 委托变量名=(a,b)=>{方法体1;方法体2;};
XML的使用:
//写XML
1.写XML文档首先要有个XDocument类创建文档
2.实例化XElement类,通过构造方法的参数,创建根节点(每个节点)
3.用XDocument类的变量．Add属性,将节点加到文档中
4.用父节点名．Add(子节点名)将子节点加到父节点中
5.用XAttribute类的构造方法,创建属性(参数1:"属性名" 参数2:"属性值");
6.用节点名．Add(属性名)将属性加到节点中.
7.使用XDocument的变量的Save方法保存XML文档
//示例代码:
XDocument xDoc=new XDocument();
XElement p=new XElement ("person");
XElement t=new XElement ("teatcher");
p.Add(t);
XAttribute xAtt=New XAttribute("id","20121221");
xAtt.SetValue("我是一个老师");
xDoc.Add(p);
t.Add(xAtt);
//效果
<?xml version="1.0" encoding="utf-8"?>
<person>
<teacher id="20121221">我是一个老师
</teacher>
</person>
//读XML
//通过XDocument的构造方法找到xml绝对路径
XDocument xDoc=new XDocument(@"c:\1.xml");
//获取此文档的根节点
XElement xRoot=xDoc.Root;
//遍历根节点
Foreach(XEncoder x in xRoot.Encoders())
{
//通过属性找到节点
Attribute xAtt=x.Attribute("id");
If(xAtt.Value="20121221")
{
}
}
XmlSerializer(Xml序列化):
//假设实现定好的一个person类,并且有一个有参数的构造函数.
//示例代码:
List<Person>lps=new List<Person>();
lps.Add(new Person("张三",18,"男"));
lps.Add(new Person("李四",19,"女"));
lps.Add(new Person("王五",21,"男"));
//在序列化之前必须知道所要序列化的类型是什么,否则无法序列化
XmlSerializer x=new XmlSerializer(typeof(List<Person>));
Using(FileStream fs=new FileStream(@"d:\1.xml",FileMode.Create,FileAccess.Write))
{
x.Serializer(fs,lps);
}
[Serializable]
Public Class Person
{
}