| JAVA与C#语法对照表 | |||||||||||||||||
| JAVA | C# | ||||||||||||||||
| 程 序 入 口 |
大括号 | 左大括号，跟随语句后面，右大括号独占一行 | 左右大括号都独占一行 | ||||||||||||||
| 包的命名 | 名字由小写字母组成，通常使用组织的网络域名逆序。关键字：package 例：package net.javagroup.research.powerproject; |
名字使用Pascal命名方式。关键字：namespace 例：namespace HelloWorld |
|||||||||||||||
| 导入包的语法 | 关键字：import 例：import net.javagroup.research.powerproject; 导入包的语句必须在package之后，class之前 |
关键字：using 例：using HelloWorld; 导入包的语句，可以写在namespace外部或者内部 |
|||||||||||||||
| 类的命名 | 名字使用Pascal命名方式。关键字：class，要求类名与源文件名必须一致。 例：class Hello{} |
名字使用Pascal命名方式。关键字：class，不要求类名与源文件名一致。 例：class Hello{} |
|||||||||||||||
| main方法 | publicstaticvoidmain(String[] args){}//命令行参数必须有 | 访问修饰符 static void/int Main(string[] args){}//命令行参数可选 | |||||||||||||||
| 用户自定义方法 | 名字使用Camel命名方式。访问修饰符返回类型 方式名字(参数列表){} 例：public void showMe{} |
名字使用Pascal命名方式。访问修饰符 返回类型
方式名字(参数列表){} 例：public void ShowMe{} |
|||||||||||||||
| 程序结构书写顺序 |
1 package net.javagroup.research.powerproject;
2 import java.util.*;
3 访问修饰符 class Hello{
4 public static void main(String[] args){
5 //方法体
6 }
7 }
|
using System;
namespace OutPutName
{
访问修饰符 class Hello
{
访问修饰符 static void Main(string[] args)
{
//方法体
}
}
}
|
|||||||||||||||
| 注 释 |
单行注释 | //单行注释 | //单行注释 | ||||||||||||||
| 多行注释 | /*多行注释*/ | /*多行注释*/ | |||||||||||||||
| 文档注释 | /**文档注释*/ | ///文档注释 ///文档注释 |
|||||||||||||||
| 注释规范 | 1、关键性的语句要使用注释，如变量声明、条件判断、循环等。 2、类名前应使用文档注释，说明类的简单功能和使用方法。 3、方法前应使用注释，说明方法的功能，参数的含义、返回值等。 |
||||||||||||||||
| 折叠代码添加说明 | 没有此功能 | 将每个方法都折叠成一句并提供说明，做法是：把方法或属性的代码写在#region和#endregion之间。在#region后面可以添加说明。 例： #region 成员变量 public string name; public int age; #endregion |
|||||||||||||||
| 控 制 台 |
输出 |
System.out.println();//输出后换行 System.out.print();//输出后不换行
|
Console.WriteLine();//输出后换行 Console.Write();//输出后不换行
|
||||||||||||||
| 输出 | 输出格式："格式字符窜" + 变量名//使用加号连接 例：System.out.println("名字" + name); java还有一种输出方式叫做格式化控制台输出 语法：System.out.printf(format,item1,item2,…itemn) format是指一个子串和格式标识符构成的字符串 itm1指的是任意类型的变量 常用标识符：%b(布尔值) %c（字符）%d（整型） %f（浮点型） %s（字符串) 参数列表与标识符必须在次序、数量和类型上匹配。 例子： int count = 5;
double amount = 45.56;
System.out.printf("count is %d and amount is %f",count,amount);
显示：count is 5 and amount is 45.56 |
同样能使用java的输出格式，但C#有一种新语法，使用起来更方便，不容易出错 输出格式："格式字符串{0}",变量列表//其中{0}为占位符，它占的就是变量列表对应次序的变量位置。 例：Console.WriteLine("名字：{0}",name); |
|||||||||||||||
| 输入 | java使用控制台输入需要先导入包：import java.util.*; 再创建Scanner类的对象:Scanner 对象名 = newScanner(System.in); 输入int类型变量：对象名.nextInt(); 输入float类型变量：对象名.nextFloat(); 输入单个字符串类型变量：对象名.next(); 输入整行字符窜类型变量：对象名.nextLine(); |
C#中四大命名空间已默认导入 输入整行字符串类型变量：Console.ReadLine(); 输入单个字符串类型变量：Console.Read(); 输入int类型变量：int.Parse(Console.ReadLine()); 输入float类型变量：float.Parse(Console.ReadLine()); |
|||||||||||||||
| 运 算 符 |
算术运算符 | =+、-、*、/、%、++、--、+=、-= 例子： 求商：1234 / 10 得 123 求余（取模）： 1234 % 10 得 4 |
|||||||||||||||
| 关系运算符 | ==、>=、<=、>、<、!= | ||||||||||||||||
| 逻辑运算符 | &&、||、！ | ||||||||||||||||
| 三目运算符 |
?: int score = 60; String str = (score >= 60) ? "及格" : "不及格"; //问号前为布尔表达式，如果表达式为true则返回冒号前的值，如果表达式为false则返回冒号后的值，返回值的类型根据问号后的值的类型而定 //问号后的两个值的数据类型必须一致，不然会编译出错，此例子返回的是值为"及格"。
|
||||||||||||||||
| 运算符的优先级 | 1、最高优先级：小括号 2、最低优先级：等于号（赋值运算符） 3、优先级顺序：! > 算术运算符 > 关系运算符 > && > || |
||||||||||||||||
| 经验 | 当运算符比较多，你无法确定运算符执行的顺序时，可以使用小括号控制一下顺序。 | ||||||||||||||||
| 基 本 数 据 类 型 |
变量 | 整型：int 浮点型：float 双精度浮点型：double 字符型：char 布尔型：boolean |
整型：int 浮点型：float 双精度浮点型：double 字符型：char 布尔型：bool |
||||||||||||||
| 常量 | 关键字：final 例：final int a = 1; |
关键字：const 例：const int a = 1; |
|||||||||||||||
| 弱类型 | 在不确定接收的数据类型是什么的时候使用，效率比object稍高 var a = "a"; |
||||||||||||||||
| 生成int类型随机数 |
int a = (int)(Math.random()*10);//返回0-9中的一个int类型的随机参数 int b = c + (int)(Math.random() * d;// 返回一个在c到c+d之间但不包括c+d的随机数 //例子：要生成一个50到100之间的数。 int a = 50; int b = 100; int c = a + (int)(Math.random() * b-a+1;//因为不包括a+(b-a)所以加1以达到题目要求
|
Random 对象名 = new Random(); int a = 对象名.Next(1,10);//随机生成1-10中的一个int类型的数
|
|||||||||||||||
| 生产char类型随机数 | 每个字符都有一个唯一的对应的数：97~122对应a~z 例子： 生成a至z的其中一个字符 char a = (char)('a' + Math.random() * ('z' - 'a' + 1));
|
每个字符都有一个唯一的对应的数：97~122对应a~z 例子： 生成a至z的其中一个字符 Random 对象名 = new Random(); char a = (char)对象名.Next(97,122);
|
|||||||||||||||
| 命名规则 | 1、变量必须以字母、下划线“_”或“$”符号开头 2、变量可以包括数字，但不能以数字开头 3、除了“_”或“$”符号以外，变量名不能包含任何特殊字符 4、不能使用java语言的关键字，比如int、class、public等 |
1、变量必须以字母或下划线“_”符号开头 2、变量可以包括数字，但不能以数字开头 3、除了“_”符号以外，变量名不能包含任何特殊字符 5、不能使用c#语言的关键字，比如int、class、public等 |
|||||||||||||||
| 引 用 数 据 类 型 |
变量 | 字符串型数组：String 数组名
= new String[]; int类型数组：int[] 数组名 = new int[数组长度];//可以将[]放在数组名后面 float类型数组：float[] 数组名 = new float[数组长度];//如果赋初始值，就不能指定长度，如果指定了长度，就不能同时赋初始值。 用户自定义对象数组： 1.专门用一个类封装属性 2.创建对象数组语法步骤：类名[] 对象名 = new 类名(数组长度); 3.for循环实例化：对象[下标] = new 类名(); 4.调用属性并赋值：对象[下标].变量名 = 变量值;通常跟for循环配合赋值。 在main方法中对象数组每个下标要先实例化后才能使用(只需一次)，在类中创建一个专门封装变量的量，用对象数组调用，并实现同类多个保存。 |
字符串型：string 数组名 = new string[]; int类型数组：int[] 数组名 = new int[数组长度];//不可以将[]放在数组名后面 float类型数组：float[] 数组名 = new float[数组长度];//可以同时指定数组长度和初始值，但长度和初始值的数目必须一致。 用户自定义对象数组： 1.专门用一个类封装属性 2.创建对象数组语法步骤：类名[] 对象名 = new 类名(数组长度); 3.for循环实例化：对象[下标] = new 类名(); 4.调用属性并赋值：对象[下标].变量名 = 变量值;通常跟for循环配合赋值。 在main方法中对象数组每个下标要先实例化后才能使用(只需一次)，在类中创建一个专门封装变量的量，用对象数组调用，并实现同类多个保存。 |
||||||||||||||
| 常量 | 关键字：final 例：final int[] 数组名 = new int[数组长度]; |
关键字：const 例：const int[] 数组名 = new int[数组长度]; |
|||||||||||||||
| 数组复制 |
第一种方法：利用for循环复制
int[] copy = Arrays.copyOf(a , a.length);//将a的数组的值和数组长度复制给copy数组
|
第一种方法：利用for循环复制
int []pins = {9,3,7,2}
int []copy2 = new int[pins.length];
pins.CopyTo(copy2,0);//将pins的数组的值复制给copy2数组，从下标0开始
|
|||||||||||||||
| 数组排序 | java使用数组排序需要先导入包：import java.util.*; Arrays.sort(数组名);//静态方法 如果元素的值为数字，可从小到大排列，如果元素的值为字母，按首字母从a-z排列 |
c#中四大命名空间已默认导入。 Array.Sort(数组名);//静态方法 如果元素的值为数字，可从小到大排列，如果元素的值为字母，按首字母从a-z排列 |
|||||||||||||||
| 经验 | 值得注意的是，直接创建并赋值的方式一般在数组元素比较少的情况下使用。它必须一并完成，如下代码是不合法的。 int[] score; score = {60,70,80,90}; //编译出错 数组一经创建，其长度（数组中包含元素的数目）是不可改变的，如果越界访问（即元素下标超过0至数组长度-1的范围），程序会运行时出错。因此，当我们需要使用数组长度时，一般用如下的方式。 数组名.length； 循环变量i小于数组长度，我们写成 i < scores.length; 而不是写成 i < 5; |
||||||||||||||||
| 类 | 属性 | 成员变量，用来描述类的特征 | 用属性实现字段封装：在c#中，字段通常是私有的。如果要访问类中的字段需要通过get和set访问器实现，这种结合了字段和方法的实现方式我们称为属性。 get访问器用来返回相应的私有字段的值。get访问器与方法相似，必须用return语句返回字段的值。执行get访问器相当于读取类中私有字段的值。 set访问器用来设定相应的私有字段的值。set访问器类似于返回类型为void的方法。它使用一个隐含的输入参数value。当对属性赋值时，将会调用set访问器，并将新的参数值赋予对应的字段。 例： private int _age =;//字段与属性的数据类型必须一致
public int Age//属性可以是一个类或一个数组
{
get//只设置get,就是只读属性
{
return _age;
}
set//只设置set，就是只写属性
{
if(value < 0 || value > 100)
{
_age = 19;
}
else
{
_age = value;
}
}
}
调用属性语法：1、给类创建对象 2、对象名.属性名（当你给它赋值时，它会自动调用set方法，当你要输出它时它会调用get方法） |
||||||||||||||
| 方法 | 成员方法，用来描述类的行为，主要分为：①有参方法②无参方法③有返回类型④无返回类型。四种方法 | 成员方法，用来描述类的行为，主要分为：①有参方法②无参方法③有返回类型④无返回类型。四种方法 | |||||||||||||||
| 字段 | 没有此功能 | 成员变量，用来描述类的特征 | |||||||||||||||
| this | 表示用类的成员变量，而非方法参数，注意在方法参数和成员变量重名时进行区分 | 表示用类的成员变量，而非方法参数，注意在方法参数和成员变量重名时进行区分 | |||||||||||||||
| ref | 没有此功能 | 默认情况下，基本数据类型为按值传递，引用数据类型为按引用传递，要想使基本数据类型能按引用传递，需要用ref关键字来修饰，ref的使用方法很简单，在方法定义和方法调用时都要使用ref修饰参数，而且使用ref修饰的参数必须在调用的方法中赋值。 | |||||||||||||||
| 条 件 选 择 结 构 |
基本if选择结构 | 可以处理单一或组合条件的情况，如果布尔表达式为true则执行if里面的代码块 if(布尔表达式){ //代码块 } |
可以处理单一或组合条件的情况，如果布尔表达式为true则执行if里面的代码块 if(布尔表达式) { //代码块 } |
||||||||||||||
| if-else选择结构 | 可以处理简单的条件分支情况，如果布尔表达式为true则执行if里面的代码块，否则就执行else里面的代码块。 if(布尔表达式){ //代码块 }else{ //代码块 } |
可以处理简单的条件分支情况，如果布尔表达式为true则执行if里面的代码块，否则就执行else里面的代码块。 if(布尔表达式) { //代码块 } else { //代码块 } |
|||||||||||||||
| 多重if选择结构 | 可以处理复杂的条件分支情况，首先程序判断条件1，如果成立，执行代码块1.然后直接跳出这个多重if选择结构。这种情况下，代码块2和代码块3都不会被执行。如果条件1不成立，条件2将会被判断。如果条件2成立，执行代码块2，然后跳出这个多重if选择结构。这种情况下，代码块1和代码块3不会被执行。如果条件2也不成立，代码块1和代码块2都不执行，直接执行代码块3. if(条件1）{ //代码块1 }elseif(条件2){ //代码块2 }else{ //代码块3 } |
可以处理复杂的条件分支情况，首先程序判断条件1，如果成立，执行代码块1.然后直接跳出这个多重if选择结构。这种情况下，代码块2和代码块3都不会被执行。如果条件1不成立，条件2将会被判断。如果条件2成立，执行代码块2，然后跳出这个多重if选择结构。这种情况下，代码块1和代码块3不会被执行。如果条件2也不成立，代码块1和代码块2都不执行，直接执行代码块3. if(条件1） { //代码块1 } elseif(条件2) { //代码块2 } else { //代码块3 } |
|||||||||||||||
| 经验 | 当if关键字后的一对大括号里只有一个语句时，可以省略大括号。但是为了避免有多个语句时遗忘大括号以及为了保持程序整体风格一致，建议不要省略if结构块的大括号 | ||||||||||||||||
| switch选择结构 | switch(int/char表达式){ case 常量表达式1: 语句1; break;//可以没有 case 常量表达式2: 语句2; break;//可以没有 default: 语句n; } |
switch(int/char/string表达式) { case 常量表达式1: 语句1; break;//必须有 case 常量表达式2: 语句2; break;//必须有 default: 语句n; break;//必须有 } |
|||||||||||||||
| 经验 | 每个case后的代码块可以有多个语句，也就是说可以有一组语句，而且不需要用“｛｝”括起来。Case和default后都有一个冒号，不要忘记了；否则编译不通过。对于每个case的结尾，都要想一想是否需要从这里跳出整个switch选择结构。如果需要，一定不要忘记写一个语句，那就是“break；”！ | ||||||||||||||||
| 循 环 结 构 |
while循环结构 | 特点：先判断条件表达式是否成立。若成立则执行循环体，否则结束循环。 语法如下： while(布尔表达式){ //循环体（代码块） } |
特点：先判断条件表达式是否成立。若成立则执行循环体，否则结束循环。 语法如下： while(布尔表达式) { //循环体（代码块） } |
||||||||||||||
| do-while循环结构 | 特点：先执行一次循环体再判断条件表达式是否成立。若成立则继续循环；否则结束循环。 语法如下： do{ //循环体（代码块） }while(布尔表达式）; |
特点：先执行一次循环体再判断条件表达式是否成立。若成立则继续循环；否则结束循环。 语法如下： do { //循环体（代码块） }while(布尔表达式）; |
|||||||||||||||
| for循环结构 | 必须使用整型变量做循环计算器，通过条件表达式限定计数器变量值来控制循环 语法如下： for(表达式1;表达式2;表达式3){//分号必不可少，三个表达式可省略。 //循环体(代码块） } 表达式1：赋值语句，循环结构的初始部分，为循环变量赋初始值。（只执行一次）例：int i = 0; 表达式2：条件语句，布尔表达式，循环结构的循环条件。 例：i < 100; 表达式3：赋值语句，通常使用++或--运算符，循环结构的迭代部分，通常用来修改循环变量的值，每次循环结束后判断完条件语句再执行此语句。 例:i++ |
必须使用整型变量做循环计算器，通过条件表达式限定计数器变量值来控制循环 语法如下： for(表达式1;表达式2;表达式3)//分号必不可少，三个表达式可省略。 { //循环体(代码块） } 表达式1：赋值语句，循环结构的初始部分，为循环变量赋初始值。（只执行一次）例：int i = 0; 表达式2：条件语句，布尔表达式，循环结构的循环条件。 例：i < 100; 表达式3：赋值语句，通常使用++或--运算符，循环结构的迭代部分，通常用来修改循环变量的值，每次循环结束后判断完条件语句再执行此语句。 例:i++ |
|||||||||||||||
| foreach循环结构 | 特点：自动遍历给定集合或者数组的所有值，也可用于将字符串分解输出。 语法如下： for(数据类型 元素 : 集合或者数组){ //循环体（代码块） } 元素是一个只读变量，结构中不能改变集合中各项的值。 |
特点：自动遍历给定集合或者数组的所有值，也可用于将字符串分解输出。 语法如下： foreach(数据类型 元素 in 集合或者数组) { //循环体（代码块） } 元素是一个只读变量，结构中不能改变集合中各项的值。 |
|||||||||||||||
| break | break语句用语终止某个循环，使程序跳到循环块外的下一条语句。在循环中位于break语句后的将不再执行，循环也停止执行 | ||||||||||||||||
| countinue | countinue语句不仅可以用在for循环中，也可以用在while和do-while循环。在for循环中continue使程序先跳转到迭代部分，然后判断循环条件。如果为true，继续下一次循环；否则终止循环。在while循环中，continue执行完毕后，程序将直接判断循环条件。Continue语句只能用在循环结构中。 | ||||||||||||||||
| 经验 | break语句不仅可以用在for循环中，也可以用在while和do-while循环中。 break语句通常与if条件语句一起使用。 |
||||||||||||||||
| 流程图 | 符号汇总 |
流程图：逐步解决指定问题的步骤和方法的一种图形化表示方法。 |
|||||||||||||||
| 常 用 的 字 符 串 处 理 方 法 |
比较字符串的值是否相等 | 字符串名.equals(String
value)//动态方法 比较一个字符串与另外一个字符串value的值是否相等。如果二者相等返回true；如果不相等返回false，运算符“==”通常用来比较int、double等数值类型的数据是否相等，如果应用在String类型的数据时，只比较两个String类型的首地址是否相等。 例子： String a = “abc”; String b = “abc”; boolean c = a.equals(b);
|
字符串名.Equals(String value)//动态方法 比较一个字符串与另外一个字符串value的值是否相等。如果二者相等返回true；如果不相等返回false，该方法的作用与运算符“==”相同。 例子： String a = “abc”; String b = “abc”; boolean c = a.Equals(b);
|
||||||||||||||
| 比较字符串的大小关系 | strA.compareTo(strB);//动态方法 比较两个字符串的大小关系，返回一个整数。如果strA小于strB，返回值小于0；如果strA等于strB，返回值为0；如果strA大于strB，返回值大于0。 例子： String a = "abc"; String b = "bac"; int c = a.compareToIgnoreCase(b);//IgnoreCase忽略大小写
|
strA.CompareTo(strB)//动态方法; 比较两个字符串的大小关系，返回一个整数。如果strA小于strB，返回值小于0；如果strA等于strB，返回值为0；如果strA大于strB，返回值大于1。 例子： string a = "abc"; string b = "bac"; int c = a.CompareTo(b); int d = String.Compare(a,b,true);//true忽略大小写，c#中另外一种比较字符串方法，为静态方法
|
|||||||||||||||
| 查找指定的字符串首次出现的首字母下标 |
字符串名.indexOf(char or string)//动态方法 String a = “abc”;
int b = a.indexOf("b",0);
indexOf(String a , int b) String a = “abc”;
int b = a.indexOf("b",0);
|
字符串名.IndexOf(char or string)//动态方法 string a = “abc”;
int b = a.IndexOf("b");
IndexOf(String a , int b);
在b的位置开始以顺序搜索a的位置，如果找到了，就返回它的位置；如果没有找到就返回-1。 string a = “abc”;
int b = a.IndexOf("b",0);
|
|||||||||||||||
| 查找指定的字符串最后一次出现的首字母下标 |
字符串名.lastIndexOf(char or string)//动态方法 String a = “abc”;
int b = a.lastIndexOf("b");
lastIndexOf(String a , int b) String a = “abc”;
int b = a.lastIndexOf("b",0);
|
字符串名.LastIndexOf(char or string)//动态方法 string a = “abc”;
int b = a.LastIndexOf("b");
LastIndexOf(String a , int b);
在b的位置开始以逆序搜索a的位置，如果找到了，就返回它的位置；如果没有找到就返回-1。 string a = “abc”;
int b = a.LastIndexOf("b",0);
|
|||||||||||||||
| 连接字符串数组 | 创建StringBuffer数组，使用StringBuffer的方法.append（String value）配合循环。 StringBuffer数组的声明： StringBuffer stringBuffer = new StringBuffer[10]; 在实用前必须对每个下表都实例化一次。 stringBuffer[0] = new StringBuffer(); |
Join(string
separator,string[] value)//静态方法 把字符串数组value中的每个字符串用指定的分隔符separator连接，返回连接后的字符串。 例子 string[] a = {"abc","bca"};
string b = String.Join("_",a);
|
|||||||||||||||
| 连接字符串 | strA.concat(strB); strA、strB位置必须是String类型 例子： String a = "abc"; String b = "def"; String c = a.concat(b);
|
||||||||||||||||
| 获取字符串长度 | 例子：String a = "abc"; int b = a.length();//动态方法
|
例子：string a = "abc"; int b = a.Length;//c#中没有小括号
|
|||||||||||||||
| 拆分字符串 |
字符串名.split(String sparator,int limit)//动态方法 String a = "abcdefg";
String[] b = a.split("cd");
//返回的字符串数组，有两个元素，下标0的值为ab，下标1的值为efg
|
字符串名.Split(char sparator)//动态方法 string a = "abcdef";
string[] b = a.Split('c');
b的值有两个，下标为0的值为ab，下标为1的值为def 字符串名.Split(char[] sparator)//动态方法 string a = "abcdef";
string[] b = a.Split(new char(2){'c','d'});
b的值有两个，下标为0的值为ab，下标为1的值为ef |
|||||||||||||||
| 提取字符串 |
字符串名.substring(int startIndex,int endindex)//动态方法 String a = "abcdef"; String b = a.substring(3,5); //b的值为de
|
字符串名.Substring(int startIndex,int length)//动态方法 从指定的位置startindex开始检索长度为length的子字符串 例子： string a = "abcdef"; string b = a.substring(3,2); b的值为cd |
|||||||||||||||
| 将字母全部转换为小写 |
字符串名.toLowerCase()//动态方法 String a = “ABC”; String b = a.toLowerCase(); //b的值为abc
|
字符串名.ToLower()//动态方法 将字母全部转换为小写 例子： string a = “ABC”; string b = a.ToLower();
|
|||||||||||||||
| 将字母全部转换为大写 |
字符串名.toUpperCase()//动态方法 String a = “abc”; String b = a.toUpperCase(); //b的值为ABC
|
字符串名.ToUpper()//动态方法 将字母全部转换为小写 例子： string a = “abc”; string b = a.ToUpper();
|
|||||||||||||||
| 去掉字符串前后两端多余的空格 |
字符串名.trim();//动态方法 String a = " abc "; String b = a.trim(); //b的值为abc
|
字符串名.Trim();//动态方法 去掉字符串前后两端多余的空格 例子： string a = " abc "; string b = a.Trim();
|
|||||||||||||||
| 判断是否为空 |
name.length() == 0//性能最高 name == String.Empty//性能中 name == ""//性能低
|
name.Length == 0//性能最高 name == string.Empty//性能中 name == ""//性能低
|
|||||||||||||||
| 查找指定内容是否包含在当前字符串中 | 可以使用indexOf的方法，如果存在则返回该字母的位置，不存在则返回-1 也可以使用contains的方法，如果存在则返回true，不存在则返回false |
例子:string a = "abcdefg";
bool b = a.Contains("c");//动态方法，返回bool类型,此例子返回true
|
|||||||||||||||
| string.Empty与null区别 | string.Empty表示空字符串，即字符串对象中不包含任何字符，而null表示空引用，即不引用任何对象。 | ||||||||||||||||
| Format格 式 化 |
保留小数点后两位 |
NumberFormat fm = new DecimalFormat("#.00");
fm.format(数据);
|
语法： String myString = String.Format("格式字符串",参数列表); 其中格式字符串中包含固定文本和格式项。格式项的形式如下。 {索引[,对齐][:格式字符串]} 其中索引从0考试，与变量列表对应；对齐部分设置显示的宽度和对齐的方式，是一个带符号的整数，整数的大小表示数据的宽度，正数为右对齐，负数为左对齐 |
||||||||||||||
| 格式化数值结果表 字符 说明 示例 输出结果 C 货币说明 String.Format("{0:C3}",2000) ￥2000.000 D 十进制格式 String.Format("{0:D3}",2000) 2000 F 小数点后的位数固定 String.Format("{0:F3}",2000) 2000.000 N 用逗号隔开的数字 String.Format("{0:N}",250000) 250,000.00 P 百分比计数法 String.Format("{0:P3}",0.29768) 29.768% X 十六进制格式 String.Format("{0:X000}",12) C |
|||||||||||||||||
| 例子： String.Format("{0,-8:F2",23); 显示结果为"23.00 "，即以左对齐，宽度为8，保留2为小数的方式输出数值23. String.Format("{0,8:C2}",23); 显示结果为" ￥23.00"，即以右对齐，宽度为8，显示货币符号，保留2位小数的方式输出数值23. |
|||||||||||||||||
| 简单的类型转换 | 自动类型转换 | 规则很简单，对于任何数值类型A，只要其取值范围完全包含在类型B的取值范围内，就可以自动类型转换为类型B。也就是说，int类型可以自动类型转换为float类型或double类型，float类型可以自动类型转换为double类型 | 规则很简单，对于任何数值类型A，只要其取值范围完全包含在类型B的取值范围内，就可以隐式类型转换为类型B。也就是说，int类型可以隐式类型转换为float类型或double类型，float类型可以隐式类型转换为double类型 | ||||||||||||||
| 强制类型转换 | 与自动类型转换相反，当要把取值范围大的类型转换为取值范围笑的类型时，就需要执行强制类型转换。 当精度类型强制转换为整型时会丢失精度。 例： int a = (int)58.89; //a的值为58 尽管对变量进行了强制类型转换，但实际上的值并没有改变，只是在计算时临时转换成整数参与表达式计算 |
与隐式类型转换相反，当要把取值范围大的类型转换为取值范围笑的类型时，就需要执行显示类型转换。 当精度类型显示转换为整型时会丢失精度。 例： int a = (int)58.89; a的值为58 尽管对变量进行了显示类型转换，但实际上的值并没有改变，只是在计算时临时转换成整数参与表达式计算 |
|||||||||||||||
| 数值 类型 与字 符串 之间 的转 换 | 将字符串转换为单精度浮点型 | Float.parseFloat(String);//静态方法 注意：要转换的字符串必须是数字的有效表示形式，parse()方法不接受String类型以外的参数。 |
float.Parse(string);//静态方法 注意：要转换的字符串必须是数字的有效表示形式，Parse()方法不接受string类型以外的参数。 |
||||||||||||||
| 将字符串转换为双精度浮点型 |
Double.parseDouble(String);//静态方法 注意：要转换的字符串必须是数字的有效表示形式，parse()方法不接受String类型以外的参数。 |
double.Parse(string);//静态方法 注意：要转换的字符串必须是数字的有效表示形式，Parse()方法不接受string类型以外的参数。 |
|||||||||||||||
| 将字符串转换为整型 |
Integer.parseInt(String);//静态方法 注意：要转换的字符串必须是数字的有效表示形式，parse()方法不接受String类型以外的参数。 |
int.Parse(string);//静态方法 注意：要转换的字符串必须是数字的有效表示形式，Parse()方法不接受string类型以外的参数。 |
|||||||||||||||
| 数值类型转换为字符串类型 |
String.valueOf(任何基本数据类型);//静态方法
|
任何基本数据类型.ToString();//动态方法
|
|||||||||||||||
| 字符串类型转换为int类型 |
String a = "1"//该String的值必须为int形式的，其他任何类型的形式都会报错 int a = Integer.valueOf(a);//该静态方法,只能接受String类型和int类型的参数
|
||||||||||||||||
| 字符串类型转换为float类型 |
String a = "1"//该String的值必须为float形式的，其他任何类型的形式都会报错 float a = Float.valueOf(a);//该静态方法,只能接受String类型和float类型的参数
|
||||||||||||||||
| String Buffer类 |
转换成String类型 | toString();//动态方法 例子： StringBuffer a = new StringBuffer("abc");
String b = a.toString();
|
没有此类 | ||||||||||||||
| 连接字符串 |
append(任何基本数据类型);//动态方法 例子： StringBuffer a = new StringBuffer("abc");
int b = 12;
a = a.append(b);
|
没有此类 | |||||||||||||||
| 插入字符串 |
insert(int 位置,任何基本数据类型);//动态方法 例子： StringBuffer a = new StringBuffer("abc");
int a = 1;
a = a.insert(1,a);
|
没有此类 | |||||||||||||||
| StringBuilder类 | 常用属性和方法 |
属性：
|
|||||||||||||||
| 注意 | 如果要将StringBuilder类对象转换为String类对象，唯一的方式是使用ToString()方法。 StringBuilder类并不总能提高性能，它基本上在处理多个字符串时使用。如果只是连接两个字符串，使用System.String类会比较好。 |
||||||||||||||||
| Convert类进行转换 | 转换为整型 | 没有此功能 |
Convert.ToInt32(int型)//静态方法 如果用Convert类将浮点型转换为整型时，不像显示类型转换会直接丢失精度，而会采用四舍五入方法转换 |
||||||||||||||
| 转换为单精度浮点型 | 没有此功能 |
Convert.ToSingle(float型)//静态方法
|
|||||||||||||||
| 转换为双精度浮点型 | 没有此功能 |
Convert.ToDouble(double型)//静态方法
|
|||||||||||||||
| 转换为字符串型 | 没有此功能 |
Convert.ToString(string型)//静态方法
|
|||||||||||||||
| 枚举 | 使用枚举的好处 | 使用enum关键字来定义一个枚举，它表示一组有限的值，即对可能的值进行约束。 | 使用enum关键字来定义一个枚举，它表示一组有限的值，即对可能的值进行约束。 | ||||||||||||||
| 定义枚举的语法 |
public class TestEnum {
/*最普通的枚举*/
public enum ColorSelect {
red, green, yellow, blue;
}
/* 枚举也可以象一般的类一样添加方法和属性,你可以为它添加静态和非静态的属性或方法,这一切都象你在一般的类中做的那样. */
public enum Season {
// 枚举列表必须写在最前面，否则编译出错
winter, spring, summer, fall;
private final static String location = "Phoenix";
public static Season getBest() {
if (location.equals("Phoenix"))
return winter;
else
return summer;
}
}
/*还可以有构造方法*/
public enum Temp {
/*通过括号赋值,而且必须有带参构造器和一属性跟方法，否则编译出错
* 赋值必须是都赋值或都不赋值，不能一部分赋值一部分不赋值
* 如果不赋值则不能写构造器，赋值编译也出错*/
absoluteZero(-459), freezing(32),boiling(212), paperBurns(451);
private final int value;
public int getValue() {
return value;
}
//构造器默认也只能是private, 从而保证构造函数只能在内部使用
Temp(int value) {
this.value = value;
}
}
public static void main(String[] args) {
/*
* 枚举类型是一种类型，用于定义变量，以限制变量的赋值 赋值时通过"枚举名.值"来取得相关枚举中的值
*/
ColorSelect m = ColorSelect.blue;
switch (m) {
/*注意:枚举重写了ToString(),说以枚举变量的值是不带前缀的
*所以为blue而非ColorSelect.blue
*/
case red:
System.out.println("color is red");
break;
case green:
System.out.println("color is green");
break;
case yellow:
System.out.println("color is yellow");
break;
case blue:
System.out.println("color is blue");
break;
}
System.out.println("遍历ColorSelect中的值");
/*通过values()获得枚举值的数组*/
for (ColorSelect c : ColorSelect.values()) {
System.out.println(c);
}
System.out.println("枚举ColorSelect中的值有："+ColorSelect.values().length+"个");
/*ordinal()返回枚举值在枚举中的索引位置，从0开始*/
System.out.println(ColorSelect.red.ordinal());//0
System.out.println(ColorSelect.green.ordinal());//1
System.out.println(ColorSelect.yellow.ordinal());//2
System.out.println(ColorSelect.blue.ordinal());//3
/*枚举默认实现了java.lang.Comparable接口*/
System.out.println(ColorSelect.red.compareTo(ColorSelect.green));
System.out.println(Season.getBest());
for(Temp t:Temp.values()){
/*通过getValue()取得相关枚举的值*/
System.out.println(t+"的值是"+t.getValue());
}
}
}
|
访问修饰符 enum 枚举{值1，值2，……} 枚举是一组描述性的名称。通过枚举可以定义一组有限的值，对可能的值进行约束，但不能包含方法。枚举是开发者可以定义的一个类型。枚举的特征在于它标识了一个在编译时定义的所有可能值的集合，每个值都有一个名称来引用，这就是提高了代码的可读性。示例代码如下： public enum Genders
{
Male = 1,
Female = 0
}
public class Sex
{
private Genders studentGender;
public Genders StudentGender
{
get{ return studentGender; }
set{ studentGender = value; }
}
}
//使用枚举赋值
student.StudentGender = Genders.Male;
//也可以这样写
student.StudentGender = 10;//这样赋值是不能通过编译的。
在示例代码中，定义了枚举Genders，它包含值Male和Female，学生性别属性StudentGender的类型是Genders，在对StudentGender属性赋值的时候只能用枚举Genders。如果给它一个其他类型的值是不允许的，将会产生编译错误。这样就约束了我们的性别属性，只能是枚举Genders中的两个值。 |
|||||||||||||||
| 枚举转int型或string型 | 将枚举的值转换为int型，就可以得到定义枚举时所指定的整数值。在实际的开发中，这种用途很普遍。在程序中还可以获取它的字符串表示。示例代码如下：Console.WriteLine("性别{0}表示的值是{1}",student.StudentGender.ToString(),(int)student.StudentGender);
|
||||||||||||||||
| string型转枚举 | 要从字符串转换成枚举，需要使用Enum.Parse()方法，这个方法的第一个参数是关键字typeof后跟放在括号中的枚举类型，第二个参数是要转换的字符串。在方法最外面要使用枚举类型进行强制转换。示例代码如下：student.StudentGender = (Genders)(Enum.parse(typeof(Genders),"Male"));
Console.WriteLine("您输入的性别是{0}",student.StudentGender.ToString());
|
||||||||||||||||
| 经验 | 枚举的好处： 1、枚举可以使代码更易于维护，有助于确保给变量指定合法的、期望的值。 2、枚举更易于输入，如果我们使用枚举赋值，则只要输入枚举名，然后输入一个"."就能将所有的值显示出来，减少了按键次数，并能够让我们回忆起可选的值。 3、枚举使代码更清晰，允许用描述性的名称表示数据，使用时直观方便。 4、枚举的主体中，可以定义属性、方法和构造函数。 |
枚举的好处： 1、枚举可以使代码更易于维护，有助于确保给变量指定合法的、期望的值。 2、枚举更易于输入，如果我们使用枚举赋值，则只要输入枚举名，然后输入一个"."就能将所有的值显示出来，减少了按键次数，并能够让我们回忆起可选的值。 3、枚举使代码更清晰，允许用描述性的名称表示数据，使用时直观方便。 注意：枚举的主体中，不能定义属性和方法。 |
|||||||||||||||
| 常用算法归类 | 二分算法 |
public static int find(int[] a,int key){
int low = 0;
int high = a.length - 1;
while (low <= high) {
int mid = low + ((high - low) / 2);
int midVal = a[mid];
if (midVal < key){
low = mid + 1;
}
else if (midVal > key){
high = mid - 1;
}
else{
return mid; // key found
}
}
return -(low + 1); // key not found.
}
|
public static int find(int[] a, int key)
{
int low = 0;
int high = a.Length - 1;
while (low <= high)
{
int mid = low + ((high - low) / 2);
int midVal = a[mid];
if (midVal < key)
{
low = mid + 1;
}
else if (midVal > key)
{
high = mid - 1;
}
else
{
return mid; // key found
}
}
return -(low + 1); // key not found.
}
|
||||||||||||||
| 冒泡排序法 |
for(int i = 0; i < array.length - 1; i++){
for(int j = 0; j < array.length - 1 - i; j++){
//将最大的元素交换到最后，如果想把最小的交换到最后只需将>改为<
if(arrays[j] > array[j + 1]){
//交换元素
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
|
for(int i = 0; i < array.length - 1; i++)
{
for(int j = 0; j < array.length - 1 - i; j++)
{
//将最大的元素交换到最后，如果想把最小的交换到最后只需将>改为<
if(arrays[j] > array[j + 1])
{
//交换元素
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
|
|||||||||||||||
| 规范 | 1、规范要求类名必须使用public修饰。 2、一行只写一条语句。 3、用｛｝括起来的部分通常表示程序的某一层结构，“｛”一般放在这一结构开始行的最 末，“｝”与该结构的第一个字母对齐，并单独占一行。 4、低一层次的语句或注释应该比高一层次的语句或注释缩进若干格后书写，使程序更加清晰，增加程序的可读性。 5、变量名第一个单词首字母小写，其后单词首字母大写。 |
1、一行只写一条语句。 2、用｛｝括起来的部分通常表示程序的某一层结构，“｛”一般放在这一结构开始行的下一行并单独占一行，“｝”与该结构的第一个字母对齐，并单独占一行。 3、低一层次的语句或注释应该比高一层次的语句或注释缩进若干格后书写，使程序更加清晰，增加程序的可读性。 4、变量名第一个单词首字母小写，其后单词首字母大写。 5、在c#中一般为类的私有字段和属性的命名会采用不同的命名法。在类的私有字段命名时，要以下划线“_”开头，随后出现的英文字母采用camel命名法 6、在为类的属性命名时，采用pascal命名法 |
|||||||||||||||
来源：https://www.cnblogs.com/fengweicong/archive/2012/12/07/2807916.html