第二章基本语法

2.3 避免误导
包含List、import、java等类名、关键字或特殊字；
字母o与数字0，字母l与数字1等
提防使用不同之处较小的名称。比如：XYZControllerForEfficientHandlingOfStrings与XYZControllerForEfficientStorageOfStrings

2.4 做有意义的区分
反面教材，变量名：a1、a2、a3
避免冗余，不要出现Variable、表字段中避免出现table、字符串避免出现nameString，直接name就行，知道是字符串类型
再比如：定义了两个类：Customer类和CustomerObject类，如何区分？
定义了三个方法：getActiveAccount()、getActiveAccounts()、getActiveAccountInfo()，如何区分？

2.5 使用读得出来的名称
不要使用自己拼凑出来的单词，比如：xsxm(学生姓名)；genymdhms(生成日期，年、月、日、时、分、秒)
所谓的驼峰命名法，尽量使用完整的单词

2.6 使用可搜索的名称
一些常量，最好不直接使用数字，而指定一个变量名，这个变量名可以便于搜索到.
比如：找MAX_CLASSES_PER_STUDENT很容易，但想找数字7就麻烦了。

2.7 避免使用编码
2.7.1 匈牙利语标记法
即变量名表明该变量数据类型的小写字母开始。例如，szCmdLine的前缀sz表示“以零结束的字符串”。
2.7.2 成员前缀
避免使用前缀，但是Android中一个比较好的喜欢用m表示私有等，个人感觉比较好
2.7.3 接口和实现
作者不喜欢把接口使用I来开头，实现也希望只是在后面添加Imp

2.8 避免思维映射
比如传统上惯用单字母名称做循环计数器。所以就不要给一些非计数器的变量命名为：i、j、k等

2.9 类名
类名与对象名应该是名词与名词短语。如Customer、WikiPage、Account和AddressParser。避免使用Data或Info这样的类名。
不能使动词。比如：Manage、Process

2.10 方法名
方法名应当是动词或者动词短语。如postPayment、deletePage或save

2.11 别扮可爱
有的变量名叫haha、banana
别用eatMyShorts()表示abort()

2.12 每个概念对应一个词
项目中同时出现controllers与managers，为什么不统一使用其中一种？
对于那些会用到你代码的程序员，一以贯之的命名法简直就是天降福音。

2.13 别用双关语
有时可能使用add并不合适，比例insert、append。add表示完整的新添加的含义。

2.14 使用解决方案领域名称
看代码的都是程序员，所以尽量用那些计算机科学术语、算法名、模式名、数学术语，
依据问题所涉领域来命名不算是聪明的做法。

2.15 使用源自所涉问题领域的名称
如果不能用程序员熟悉的术语来给手头的工作命名，就采用从所涉问题领域而来的名称吧。
至少，负责维护代码的程序员就能去请教领域专家了。

2.16 添加有意义的语境
可以把相关的变量放到一个类中，使用这个类来表明语境。

2.17 不要添加没用的语境
名字中带有项目的缩写，这样完全没有必要。比如有一个名为“加油站豪华版”（Gas Station Deluxe）的项目，
在其中给每个类添加GSD前缀就不是什么好策略。

2.18 最后的话
取好名字最难的地方在于需要良好的描述技巧和共有文化背景。

一、Java基本语法: 变量与运算符

1 关键字与保留字

1.1关键字(keyword)的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：关键字中所有字母都为小写

官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

1.2 保留字(reserved word)

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 goto 、const

2 标识符(Identifier)

标识符：

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符

技巧：凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则：

由26个英文字母大小写，0-9 ，_或 $ 组成

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

练习：miles, Test, a++, --a, 4#R, $4, #44, apps, class, public, int, x, y, radius

2.1 Java中的名称命名规范

Java中的名称命名规范：

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

更多细节详见《代码整洁之道.pdf》

3 变量

基本数据类型：1.基本数据类型变量间转换 2.基本数据类型与String间转换 3.进制与进制间的转换

3.1 整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。

java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

500MB 1MB = 1024KB 1KB= 1024B B= byte ? bit?

bit: 计算机中的最小存储单位。byte:计算机中基本存储单元

3.2 浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。 浮点型常量有两种表示形式：

 十进制数形式：如：5.12 512.0f .512 (必须有小数点）

 科学计数法形式:如：5.12e2 512E2 100E-2

float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

double:双精度，精度是float的两倍。通常采用此类型。

 Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

3.3 字符类型：char

char 型数据用来表示通常意义上“字符”(2字节)

Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

字符型变量的三种表现形式：

字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';

 Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // '\n'表示换行符

直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。

char类型是可以进行运算的。因为它都对应有Unicode码。

3.4 了解：ASCII 码

3.5 了解： Unicode 编码

3.6 了解： UTF-8

详见《计算机字符编码》

3.7 布尔类型：boolean

boolean 类型用来判断逻辑条件，一般用于程序流程控制：

if条件控制语句；

while循环控制语句；

do-while循环控制语句；

for循环控制语句；

boolean类型数据只允许取值true和false，无null。

不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的 boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false 用0表示。

———《java虚拟机规范 8版》

3.8 基本数据类型转换

3.9 字符串类型：String

3.10 强制类型转换

4 .进制

4.1 二进制

二进制 ——》十进制

4.2 变量之进制间的转换

5.运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

算术运算符 赋值运算符 比较运算符（关系运算符） 逻辑运算符 位运算符 三元运算符

5.1 运算符：算术运算符

5.2 运算符：赋值运算符

5.3 运算符：比较运算符

5.4 运算符：逻辑运算符

5.5 运算符：位运算符

5.6 运算符：三元运算符

二、Java基本语法：程序流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，

即： 顺序结构 分支结构 循环结构

1 顺序结构

2 分支语句1： if-else结构

if语句例题1 :

岳小鹏参加Java考试，他和父亲岳不群达成承诺：如果：

成绩为100分时，奖励一辆BMW；

成绩为(80，99]时，奖励一台iphone xs max；

当成绩为[60,80]时，奖励一个 iPad；其它时，什么奖励也没有。

请从键盘输入岳小鹏的期末成绩，并加以判断

3 分支语句2： switch-case结构

switch和if语句的对比

if和switch语句很像，具体什么场景下，应用哪个语句呢？

 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。

 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

也就是说，使用switch-case的，都可以改写为if-else。反之不成立。

4 循环结构

4.1 循环结构1： for循环

##应用举例
public class ForLoop {
public static void main(String args[]) {
int result = 0;
for (int i = 1; i <= 100; i++) {
result += i;
}
System.out.println("result=" + result);
}
}

4.2 循环结构2： while循环

##应用举例

public class WhileLoop {
public static void main(String args[]) {
int result = 0;
int i = 1;
while (i <= 100) {
result += i;
i++;
}
System.out.println("result=" + result);
}
}

4.3 循环结构3： do-while循环

循环语句综合例题

class PositiveNegative {
public static void main(String[] args) {
 Scanner scanner = new Scanner(System.in);
 int positiveNumber = 0;//统计正数的个数
 int negativeNumber = 0;//统计负数的个数
 for(;;){ //while(true){
 System.out.println("请输入一个整数：");
 int z = scanner.nextInt();
 if(z>0)
 positiveNumber++;
 else if(z<0)
 negativeNumber++;
 else
 break;  }
 System.out.println("正数的个数为："+ positiveNumber);
 System.out.println("负数的个数为："+ negativeNumber); } 
}

5.嵌套循环

5.1嵌套循环(多重循环)

6.特殊关键字的使用： break、continue

6.1 break的使用

6.2 continue的使用

6.3 return的使用

特殊流程控制语句说明

break只能用于switch语句和循环语句中。

continue 只能用于循环语句中。

二者功能类似，但continue是终止本次循环，break是终止本层循环。

break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。

标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。

三、章节练习题及面试题

简答题（变量与运算符）

标识符的命名规则需要注意哪几点？

基本数据类型有哪几类？包含String吗？

写出基本数据类型自动转化的流程图

整型默认的是什么类型，浮点型（实数型）默认的是什么类型？

对于包名，类名接口名，变量名和函数名，常量名我们习惯如何格式来命名？

定义一个变量需要注意什么？

强制类型转化可能出现的问题

char型变量中能不能存贮一个中文汉字?为什么?

答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，

所以放一个中文是没问题的

定义float f=3.4;是否正确?

答:不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4

String是最基本的数据类型吗

答：基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String是java中定义的一个类，类都属于引用数据类型。

根据运算符的功能，我们把运算符分成哪几类？

Java有没有goto

答：java中的保留字，现在没有在java中使用

用最有效的的方法算出2称以8等于几

答案：2<<3

char型变量中是否可以存储一个汉字？

能，因为Java一个字符是2个字节，每一个字符使用Unicode编码表示

float f=3.4;是否正确，表达式15/2*2的值是多少

答案：不正确，float f = 3.4F;

答案：14

Java的基本数据类型有哪些？String是基本数据类型吗？

基本数据类型有：byte,short,int,long,float,double,char,boolean

String是引用数据类型，不是基本数据类型

以下代码的运行结果

public static void main(String[] args) {

char x = 'x';

int i = 10;

System.out.println(true? x : i);

System.out.println(true? 'x' : 10);

}

答案：

120

* 如果其中有一个是变量，按照自动类型转换规则处理成一致的类型；

* 如果都是常量，如果一个是char，如果另一个是[0~65535]之间的整数按char处理；

* 如果一个是char，另一个是其他，按照自动类型转换规则处理成一致的类型；

以下代码的执行结果

public static void main(String[] args) {

int a = 8, b = 3;

System.out.println(a>>>b);

System.out.println(a>>>b | 2);

}

答案：

编程题

为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

//为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

public class TestExer1 {

public static void main(String[] args) {

int hour = 89;

int day = hour / 24;

hour = hour % 24;

System.out.println("为抵抗洪水，战士连续作战" + day + "天" + hour + "小时");

}

今天是周二，100天以后是周几？

//今天是周二，100天以后是周几？

public class TestExer2 {

public static void main(String[] args) {

int week = 2;

week += 100;

week = week % 7;

System.out.println("100天后星期" + week);

}

算术运算符的使用

class SuanShu{

public static void main(String[] args){

int a = 23;

int b = 12;

System.out.println(a + "+" + b + "=" + (a+b));

int sum = a + b;

System.out.println(a + "+" + b + "=" + sum);

int sub = a - b;

//System.out.println(a + "-" + b + "=" + a-b);//错误，原因是a + "-" + b + "=" + a的结果是字符串，字符串不能进行减法

System.out.println(a + "-" + b + "=" + (a-b));

System.out.println(a + "-" + b + "=" + sub);

int mul = a * b;

System.out.println(a + "*" + b + "=" + a*b);

System.out.println(a + "*" + b + "=" + mul);

//整数相除，只保留整数部分

int div = a / b;

System.out.println(a + "/" + b + "=" + a/b);

System.out.println(a + "/" + b + "=" + div);

double d = (double)a/b;//先把a的类型进行转换，转换成double类型，然后再和b相除

System.out.println(a + "/" + b + "=" + d);

int yu = a % b;

System.out.println(a + "%" + b + "=" + yu);

System.out.println("------------------特殊的取模----------------------");

System.out.println(5%2);//1

System.out.println(-5%-2);//-1

System.out.println(-5%2);//-1

System.out.println(5%-2);//1

System.out.println("------------------负号----------------------");

int num1 = 12;

int num2 = -num1;

System.out.println("num2=" + num2);

System.out.println("------------------自增----------------------");

int i = 0;

System.out.println("自增之前i=" + i);

i++;

System.out.println("自增第一次之后i=" + i);

++i;

System.out.println("自增第二次之后i=" + i);

int j = ++i;//把i自增1，然后结果赋值给j，或者说，先算++i，然后再赋值

System.out.println("自增第三次之后i=" + i);

System.out.println("j="+j);

int k = i++;//先算赋值，把i的值赋值给k，i原来是3，把3赋值给k，然后i在自增1，i变成4

System.out.println("自增第四次之后i=" + i);

System.out.println("k="+k);

//面试题：陷阱题

i = i++;//先赋值，把i原来的值重新赋值给i，不变，然后i自增，但是这个自增后的值没有在放回变量i的位置

System.out.println("自增第五次之后i=" + i);

}

考查运算符的优先级

写出输出的结果.

class Demo{

public static void main(String[] args){

int x=0,y=1;

if(++x==y-- & x++==1||--y==0)

System.out.println("x="+x+",y="+y); //x = 2,y = 0;

else

System.out.println("y="+y+",x="+x);

}

编写代码实现两个变量值交换，int m = 3, n =5;

答案一：

int temp = m;

m = n;

n = temp;

答案二：

m = m + n;

n = m - n;

m = m - n;

答案三：

m = m ^ n;

n = m ^ n;

m = m ^ n;

如何求一个0~255范围内的整数的十六进制值，例如60的十六进制表示形式3C

//方式一：自动实现

String str1 = Integer.toBinaryString(60);

String str2 = Integer.toHexString(60);

//方式二：手动实现

int i1 = 60;

int i2 = i1&15;

String j = (i2 > 9)? (char)(i2-10 + 'A')+"" : i2+"";

int temp = i1 >>> 4;

i2 = temp & 15;

String k = (i2 > 9)? (char)(i2-10 + 'A')+"" : i2+"";

System.out.println(k+""+j);

小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

//小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。

//它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

public static void main(String[] args) {

int h = 80;

double s = (h - 32) / 1.8;

System.out.println(h + "华氏度，是摄氏度" + Math.round(s));

}

练习前++,后++,三元运算符

写出输出结果：

class Demo{

public static void main(String[] args){

int a=3,b=8;

int c=(a>b)?a++:b++;

System.out.println("a="+a+"\tb="+b+"\tc="+c); //

int d=(a>b)?++a:++b;

System.out.println("a="+a+"\tb="+b+"\td="+d); //

int e=(a<b)?a++:b++;

System.out.println("a="+a+"\tb="+b+"\te="+e); //

int f=(a<b)?++a:++b;

System.out.println("a="+a+"\tb="+b+"\tf="+f); //

}

比较 + 与 +=

short s1 = 1; s1 = s1 + 1;有什么错?

short s1 = 1; s1 += 1;有什么错

答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）

short s1 = 1; s1 += 1;（可以正确编译）

分支结构：

写出结果

class Demo{

public static void main(String[] args){

int m=0,n=3;

if(m>0)

if(n>2)

System.out.println("A");

else

System.out.println("B");

}

//answer:没有结果

实现对三个整数进行排序，输出时按照从小到大的顺序输出。

编写程序，从键盘接收整数参数。如果该数为1-7，打印对应的星期值，否则打印“非法参数”。

import java.util.Scanner;

class TestSwitch{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

System.out.print("请输入星期值：");

int week = input.nextInt();

switch(week){

case 1:

System.out.println("星期一：Monday");

break;

case 2:

System.out.println("星期二：Tuesday");

break;

case 3:

System.out.println("星期三：Wednesday");

break;

case 4:

System.out.println("星期四：Thursday");

break;

case 5:

System.out.println("星期五：Friday");

break;

case 6:

System.out.println("星期六：Saturday");

break;

case 7:

System.out.println("星期天：Sunday");

break;

default:

System.out.println("非法星期值");

break;

}

从键盘分别输入年、月、日，判断这一天是当年的第几天

import java.util.Scanner;

class TestDaysOfYear{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

System.out.print("年：");

int year = input.nextInt();

System.out.print("月：");

int month = input.nextInt();

System.out.print("日：");

int day = input.nextInt();

int days = day;

//加前面几个月的满月天数

switch(month){

case 12:

//前面11个月的总天数

//days += 第11月的天数;

days += 30;

case 11:

//前面10个月的总天数

//days += 第10月的天数;

days += 31;

case 10:

days += 30;//九月

case 9:

days += 31;//八月

case 8:

days += 31;//七月

case 7:

days += 30;//六月

case 6:

days += 31;//五月

case 5:

days += 30;//四月

case 4:

days += 31;//三月

case 3:

days += 28;//二月

/*if(闰年){

days++;

}

if(year % 4 ==0 && year % 100 != 0 || year%400==0){

days++;

}

case 2:

days += 31;//一月

}

System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + days + "天");

int days = 0;

switch(month){

case 1:

days = day;

break;

case 2:

days = 31 + day;

break;

case 3:

//days = 31 + 二月的天数 + day;

days = 31 + 28 + day;

break;

case 4:

//days = 31 + 二月的天数 + 31 + day;

days = 31 + 28 + 31 + day;

break;

....

}

if(闰年 && month >2){

days++;

}

switch是否能作用在byte上，是否能作用在long上，是否能作用在String上

答：switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是

int、 short、 char 或者 byte。long不能作用于swtich.JDK1.7新加入了String类型。

编写程序，判断给定的某个年份是否是闰年

闰年的判断规则如下：

（1）若某个年份能被4整除但不能被100整除，则是闰年。

（2）若某个年份能被400整除，则也是闰年。

提示：

if((year % 4 ==0 && year % 100 != 0) || year % 400 == 0){}

要求用户输入两个数a和b，如果a能被b整除或者a加b大于1000，则输出a；否则输出b。

使用条件结构实现，如果用户名等于字符‘青’，密码等于数字‘123’，就输出“欢迎你，青”，否则就输出“对不起，你不是青”。

提示：先声明两个变量，一个是char型的，用来存放用户名，一个是int型的，用来存放密码。

编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级：

score>=90 等级：A

70=<score<90 等级：B

60=<score<70 等级：C

score<60 等级：D

建议使用if...else

import java.util.Scanner;

class Exam1{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

System.out.print("请输入学生的成绩：");

int score = input.nextInt();

if(score>=90){

System.out.println("等级：A");

}else if(score>=70){

System.out.println("等级：B");

}else if(score>=60){

System.out.println("等级：C");

}else{

System.out.println("等级：D");

}

if(score>=90){

System.out.println("等级：A");

}else if(score<90 && score>=70){

System.out.println("等级：B");

}else if(score<70 && score>=60){

System.out.println("等级：C");

}else{

System.out.println("等级：D");

}

根据指定月份，打印该月份所属的季节。

3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

import java.util.Scanner;

class TestSeason{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

System.out.println("请输入当前月份：");

int month = input.nextInt();

switch(month){

case 3:

case 4:

case 5:

System.out.println("春季");

break;

case 6:

case 7:

case 8:

System.out.println("夏季");

break;

case 9:

case 10:

case 11:

System.out.println("秋季");

break;

case 12:

case 1:

case 2:

System.out.println("冬季");

break;

default:

System.out.println("非法月份");

}

求ax2+bx+c=0方程的根。

求ax2+bx+c=0方程的根。a,b,c分别为函数的参数，

提示1：Math.sqrt(num); sqrt指平方根

例如：

求x2-4x+1=0方程的根

求x2-2x+1=0方程的根

import java.util.Scanner;

class Exer5{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

System.out.println("一元二次方程：ax^2+bx+c=0");

System.out.print("请输入参数a：");

double a = input.nextDouble();

System.out.print("请输入参数b：");

double b = input.nextDouble();

System.out.print("请输入参数c：");

double c = input.nextDouble();

if(a!=0){

double temp = b*b - 4*a*c;

if(temp==0){

double x = -b/(2*a);

System.out.println("该方程是一元二次方法，有两个相同解：" + x);

}else if(temp>0){

double sqrt = Math.sqrt(temp);

double x1 = (-b+ sqrt)/(2*a);

double x2 = (-b- sqrt)/(2*a);

System.out.println("该方程是一元二次方法，两个不同解：" + x1 +"," + x2);

}else{

System.out.println("该方程是一元二次方法，在实数范围内无解！");

}

}else{

if(b!=0){

double x = -c/b;

System.out.println("该方程是一元一次方程，有一个解：" + x);

}else{

System.out.println("不是方程，是一个等式");

if(c == 0){

System.out.println("等式成立");

}else{

System.out.println("等式不成立");

}

彩票游戏

假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。

1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。

2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。

3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。

4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。

5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。

提示：使用Math.random() 产生随机数

Math.random() 产生[0,1)范围的随机值

Math.random() * 90：[0,90)

Math.random() * 90 + 10：[10,100) 即得到 [10,99]

使用(int)(Math.random() * 90 + 10)产生一个两位数的随机数。

import java.util.Scanner;

class TestCaiPiao{

public static void main(String[] args){

//1、随机产生一个两位数

//System.out.println(Math.random());//产生[0,1)

int number = (int)(Math.random()*90 + 10);//得到[10,99]，即[10,100)

//System.out.println(number);

int numberShi = number/10;

int numberGe = number%10;

//2、用户输入一个两位数

Scanner input = new Scanner(System.in);

System.out.print("请输入一个两位数：");

int guess = input.nextInt();

int guessShi = guess/10;

int guessGe = guess%10;

if(number == guess){

System.out.println("奖金10 000美元");

}else if(numberShi == guessGe && numberGe == guessShi){

System.out.println("奖金3 000美元");

}else if(numberShi==guessShi || numberGe == guessGe){

System.out.println("奖金1 000美元");

}else if(numberShi==guessGe || numberGe == guessShi){

System.out.println("奖金500美元");

}else{

System.out.println("没中奖");

}

System.out.println("中奖号码是：" + number);

}

赌数游戏

提供三个1-6的随机数，作为掷骰子得到的点数。如果各个点数相同，则为豹子。

如果三个骰子点数和，小于或等于9，则为“小”。

如果三个骰子点数和，大于9，则为“大”。

用户随机选择：押大、押小或者押豹子。通过判断，输出客户是否押正确。

import java.util.Scanner;

class GuessNumber{

public static void main(String[] args){

//1、产生一个[1-6]的数

int a = (int)(Math.random()*6+1);

//System.out.println(a);

int b = (int)(Math.random()*6+1);

//System.out.println(b);

int c = (int)(Math.random()*6+1);

//System.out.println(c);

a = 1;

b = 1;

c = 1;

String result = "";

if(a==b && b==c){

result = "豹子";

}else if(a+b+c <=9 ){

result = "小";

}else{

result = “大”;

}

//2、用户输入猜的结果

Scanner input = new Scanner(System.in);

System.out.print("请押宝，买定离手：(选择：大、小、豹子)");

String guess = input.next();

//3、判断结果

if(result.equals(guess)){

System.out.println("猜对了");

}else{

System.out.println("猜错了");

}

生肖问题

编写一个程序，为一个给定的年份找出其对应的中国生肖。

中国的生肖基于12年一个周期，每年用一个动物代表：

rat（鼠）、ox（牛）、tiger（虎）、rabbit（兔）、dragon（龙）、snake（蛇）、

horse（马）、sheep（羊）、monkey（候）、rooster（鸡）、dog（狗）、pig（猪）。

提示：2019年：猪 2019 % 12 == 3

import java.util.Scanner;

class ShengXiaoTest{

public static void main(String[] args){

Scanner input = new Scanner(System.in);

System.out.print("请输入年份：");

int year = input.nextInt();

switch(year%12){

case 0:

System.out.println("猴年");

break;

case 1:

System.out.println("鸡年");

break;

case 2:

System.out.println("狗年");

break;

case 3:

System.out.println("猪年");

break;

case 4:

System.out.println("鼠年");

break;

case 5:

System.out.println("牛年");

break;

case 6:

System.out.println("虎年");

break;

case 7:

System.out.println("兔年");

break;

case 8:

System.out.println("龙年");

break;

case 9:

System.out.println("蛇年");

break;

case 10:

System.out.println("马年");

break;

case 11:

System.out.println("羊年");

break;

}

switch是否能作用在byte上，是否能作用在long上，是否能作用在String上？

答案一：switch可以作用在byte上，不能作用在long上，JDK1.7之后可以作用在String上。

答案二：switch支持的类型byte,short,int,char，JDK1.5之后支持枚举，JDK1.7之后支持String类型。

下面程序片段的输出结果是？

public static void main(String[] args) {

int a = 3;

int b = 1;

if(a = b){

System.out.println("Equal");

}else{

System.out.println("Not Equal");

}

答案：编译不通过

循环结构：

What is the result when you compile and run the following code?

public class Test{

public void method(){

for(int i = 0; i < 3; i++) {

System.out.print(i);

}

System.out.print(i);

}

A. 0122

B. 0123

C. compile error

D. none of these

答案：C

打印1-100之间13的倍数，使用for循环

使用双重循环打印20 * 8的矩形，使用for循环实现

用for循环计算1000以内偶数的和

执行如下代码后，c的值是多少？

public static void main(String[] args) {

int a = 0;

int c = 0;

do {

--c;

a = a - 1;

} while (a >= 0);

System.out.println("c = " + c);

}

答案：c = -1

以下代码的运行结果？

public static void main(String[] args) {

int i=10;

while(i>0){

i = i +1;

if(i==10){

break;

}

System.out.println("i=" + i);

}

答案一：是一个负数，因为i一直累加会超过int的存储范围

答案二：死循环

修正如下代码

下面是一段程序，目的是输出10个=，但是不小心代码写错了，现在需要修改代码，使得程序完成功能，但是只能“增加”或“修改”其中“一个”字符，很明显，将i--改为i++，可以完成功能，但是需要修改“两个”字符，所以并不是一个正确的答案？

public static void main(String[] args) {

int n=10;

for (int i = 0; i < n; i--) {

System.out.println("=");

}

i<n修改为-i<n

1)输入长和宽，输出长方形，如：输入4和3, 将输出如下图形

####

2)输入高度，输出直角三角形。如：输入4, 将输出如下图形

###

####

3)输入高度，输出倒直角三角形。如：输入4, 将输出如下图形

####

###

打印九九乘法表

public static void main(String[] args) {

for(int i =1;i<=9;i++){

for(int j=1;j<=i;j++){

System.out.print(j+"*"+i+"="+(i*j) + "\t");

}

System.out.println();

}

3000米长的绳子，每天减一半。问多少天这个绳子会小于5米？不考虑小数。

public static void main(String[] args) {

int day = 0;

for (int x = 3000; x >= 5; x /= 2) {

day++;

}

System.out.println("day=" + day);

* 方法二：

* day = 0;

* for(int x=3000; x>=5; day++) {

* x = x/2;

* }

* System.out.println(day);

}

打印1-100之间非13的倍数，使用continue语句

用循环控制语句打印输出：1+3+5+...+99=?的结果

答案一：

public static void main(String[] args) {

int sum = 0;

for (int i = 1; i <= 99; i+=2) {

sum += i;

}

System.out.println("sum = " + sum);

}

答案二：

public static void main(String[] args) {

int sum = 0;

for (int i = 1; i < 100; i++) {

if (i % 2 != 0) {

sum += i;

}

System.out.println("sum = " + sum);

}

混合结构练习

写出结果

public class Demo{

public static void main(String []args){

int i = 0, j = 5;

tp: for (;;){

i++;

for(;;){

if(i > j--)

break tp;

}

System.out.println("i = " + i + ", j = "+ j); //i=1,j=-1;

}

输出从1到100之间所有不能被3整除的数;并输出这些整数的和

猜数字游戏

随机生成一个100以内的数，猜数字游戏：

从键盘输入数，如果大了提示，大了，如果小了，提示小了，如果对了，就不再猜了，并统计一共猜了多少次？

提示：随机数

import java.util.Random;

Random rand = new Random();

int num= rand.nextInt(100);

import java.util.Random;

import java.util.Scanner;

public class TestDoWhileLoop{

public static void main(String[] args){

//1、随机产生一个100以内的整数

Random rand = new Random();

//int num = rand.nextInt();//产生的是任意大小的整数

int num = rand.nextInt(100);//产生[0,100)的整数

System.out.println(num);

//2、键盘输入

Scanner input = new Scanner(System.in);

//声明变量

int guess;

int count = 0;

do{

//循环体至少执行一次

System.out.print("请输入一个整数：");

guess = input.nextInt();//为变量赋值

count++;//输入一次，计数一次

if(guess>num){

System.out.println("大了");

}else if(guess < num){

System.out.println("小了");

}else{

System.out.println("猜对了");

}

}while(guess != num);

System.out.println("一共猜了：" + count + "次");

}

public static void main(String[] args) {

Random rand = new Random();

int num= rand.nextInt(100);

Scanner input = new Scanner(System.in);

int count =0 ;

do{

count++;

System.out.println("请猜：");

int temp = input.nextInt();

if(temp<num){

System.out.println("小了");

continue;

}

if(temp>num){

System.out.println("大了");

continue;

}

if(temp == num){

break;

}

}while(true);

System.out.println("总共猜了"+count+"次");

}

打印1-100之间数，其中3、5、7的倍数不打印（continue）

class TestContinue {

public static void main(String[] args) {

//打印1-100之间数，其中3、5、7的倍数不打印

for(int i=1; i<=100; i++){

if(i%3==0 | i%5==0 | i%7==0){

//跳过下面的打印语句，提前进入下一次循环，即i++语句

//break;//结束循环

continue;

}

//下面这部分循环体语句，有些情况下需要跳过

System.out.println(i);

}

System.out.println("over");

}

一个数如果恰好等于它的因子之和，这个数就称为"完数"。（因子：除去这个数本身的约数）

例如6=1＋2＋3.编程找出1000以内的所有完数

public static void main(String[] args) {

System.out.println("1-1000之间的完数有：");

for(int i=1;i<=1000;i++){

int sum = 0;

for(int j=1;j<i;j++){

if(i%j==0){

sum +=j;

}

if(sum == i){

System.out.println(i);

}

输入两个正整数m和n，求其最大公约数和最小公倍数

int m = 12, n = 28;

//获取m和n的较大值

int max = (m > n)? m : n;

//获取m和n的较小值

int min = (m < n)? m : n;

//求m和n的最大公约数

for(int i = min;i >= 1;i--){

if( m % i == 0 && n % i == 0){

System.out.println("m和n的最大公约数是：" + i);

break;

}

//求m和n的最小公倍数

for(int i = max;i <= m * n;i++){

if( i % m == 0 && i % n == 0){

System.out.println("m和n的最小公倍数是：" + i);

break;

}

根据指定月份，打印该月份所属的季节

分别使用if-else if-else语句和switch-case语句：

3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

[第一种]

if(x==3 || x==4 || x==5)

System.out.println(x+"春季");

else if(x==6 || x==7 || x==8)

System.out.println(x+"夏季");

else if(x==9 || x==10 || x==11)

System.out.println(x+"秋季");

else if(x==12 || x==1 || x==2)

System.out.println(x+"冬季");

else

System.out.println(x+"月份不存在");

[第二种]

if(x>12 || x<1)

System.out.println(x+"月份不存在");

else if(x>=3 && x<=5)

System.out.println(x+"春季");

else if(x>=6 && x<=8)

System.out.println(x+"夏季");

else if(x>=9 && x<=11)

System.out.println(x+"秋季");

else

System.out.println(x+"冬季");

[第三种]

public static void main(String[] args) {

int x = 4;

switch(x){

case 3:

case 4:

case 5:

System.out.println(x+"春季");

break;

case 6:

case 7:

case 8:

System.out.println(x+"夏季");

break;

case 9:

case 10:

case 11:

System.out.println(x+"秋季");

break;

case 12:

case 1:

case 2:

System.out.println(x+"冬季");

break;

default:

System.out.println("nono");

}

已知学生成绩以100分为满分，共分5个等级：A,B,C,D,E

90～100为等级A，

80～89为等级B，

70～79为等级C，

60～69为等级D，

0～59为等级E。

要求定义一个成绩变量，当成绩变化时，可直接知道该成绩对应的等级。

例如：当成绩为100时，该学生的等级是A。

class LevelDemo{

//定义一功能，通过给定分数，获取该分数对应的等级。

public static void main(String[] args){

int num = 89;

if(num>=90 && num<=100)

System.out.println("level = A");

else if(num>=80 && num<=89)

System.out.println("level = B");

else if(num>=70 && num<=79)

System.out.println("level = C");

else if(num>=60 && num<=69)

System.out.println("level = D");

else

System.out.println("level = E");

}

打印自然数的个数

1）打印1~100之间 6的倍数的个数

2）求出1～100之间，既是3又是7的倍数的自然数出现的次数？

public static void main(String[] args) {

int count1 = 0,count2 = 0;

for (int x = 1; x <= 100; x++) {

if (x % 6 == 0){

count1++;

}

if(x % 3 == 0 && x % 7 == 0){

count2++;

}

System.out.println("count1=" + count1);

System.out.println("count2=" + count2);

}

求调和级数中从第多少项开始值大于10

调和级数的第n项形式为：1+1/2+1/3+…+1/n

public static void main(String[] args) {

double sum = 0.0;

int i = 1;

while (true) {

sum += 1.0 / i;

if (sum > 10) {

break;

}

i++;

}

System.out.println(i);

}

打印如下的图形：三角形

* * *

* * * * *

* * * * * * *

* * * * *

* * *

for (int i = 0; i < 7; i++) {

if (i < 4) {

for (int j = 0; j < 2 * i + 1; j++) {

System.out.print("* ");

}

System.out.println();

} else {

for (int k = 0; k < 13 - 2 * i; k++) {

System.out.print("* ");

}

System.out.println();

}

【拓展】

打印如下的图形：菱形1

* *

* * *

* * * *

* * * * *

* * * *

* * *

* *

// 上半部分

for (int i = 0; i < 5; i++) {

// 输出“-”

for (int j = 0; j < 4 - i; j++) {

System.out.print(" ");

}

// 输出“* ”

for (int k = 0; k < i + 1; k++) {

System.out.print("* ");

}

System.out.println();

}

// 下半部分

for (int i = 0; i < 4; i++) {

for (int j = 0; j < i + 1; j++) {

System.out.print(" ");

}

for (int k = 0; k < 4 - i; k++) {

System.out.print("* ");

}

System.out.println();

}

打印如下的图形：菱形2

**********

**** ****

*** ***

** **

* *

** **

*** ***

**** ****

**********

打印如下的图形：心形

****** ******

********** **********

************* *************

*****************************

***************************

***********************

*******************

***************

***********

*******

***

class Heart {

public static void main(String[] args) {

// 分三个大部分上中下

for (int i = 0, k = 0; i < 14; i++) {// 打印行

// 上部分上分为四个部分

if (i < 3) {

for (int j = 0; j < 5 - 2 * i; j++) {// 1、空心

System.out.print(" ");

}

if (i == 2) {// 2、*

for (int j = 0; j < 6 + 4 * i - 1; j++) {

System.out.print("*");

}

for (int j = 0; j < 7 - 4 * i + 2; j++) {// 3、空心

System.out.print(" ");

}

for (int j = 0; j < 6 + 4 * i - 1; j++) {// 4、*

System.out.print("*");

}

} else {

for (int j = 0; j < 6 + 4 * i; j++) {// 2、*

System.out.print("*");

}

for (int j = 0; j < 7 - 4 * i; j++) {// 3、空心

System.out.print(" ");

}

for (int j = 0; j < 6 + 4 * i; j++) {// 4、*

System.out.print("*");

}

} else if (i < 6) {// 中间

for (int j = 0; j < 29; j++) {

System.out.print("*");

}

} else {// 下部分 6

if (i == 13) {

for (int j = 0; j < 2 * (i - 6); j++) {// 打印空格

System.out.print(" ");

}

System.out.print("*");

} else {

for (int j = 0; j < 2 * (i - 6) + 1; j++) {// 打印空格

System.out.print(" ");

}

for (int j = 1; j < 28 - 4 * k; j++) {

System.out.print("*");

}

k++;

}

System.out.println();// 换行

}

编写程序，打印100-200之间的质数

一个数如果恰好等于它的因子之和，这个数就称为"完数"

（因子：除去这个数本身正的约数）

例如6=1＋2＋3.编程找出1000以内的所有完数

public class WanShu {

static int count;

public static void main(String[] args) {

for (int i = 1; i <= 1000; i++) {

int factor = 0;

for (int j = 1; j < i; j++) {

if (i % j == 0)

factor += j;

}

if (factor == i) {

System.out.println(i);

count++;

}

System.out.println("1-1000之间的完数个数为：" + count);

}

写一个程序，找出4位数的所有吸血鬼的数字

例如：1260=21*60

1827=21*87

public class Test1 {

public static void main(String[] args) {

for (int num = 1001; num < 10000; num++) {

math(num);

}

public static void math(int num) {

int[] temp1 = new int[2];

int[] temp2 = new int[2];

int a = num / 1000;

int b = num / 100 % 10;

int c = num / 10 % 10;

int d = num % 10;

int[] data = { a, b, c, d };

for (int i = 0; i < data.length; i++) {

for (int j = 0; j < data.length; j++) {

if (i == j) {

continue;

}

temp1[0] = data[i];

temp1[1] = data[j];

for (int m = 0; m < data.length; m++) {

if (m != i && m != j) {

temp2[0] = data[m];

for (int n = 0; n < data.length; n++) {

if (n != i && n != j && n != m) {

temp2[1] = data[n];

multi(data, temp1, temp2);

}

public static int toInt(int[] temp) {

int m = 0;

int[] temp1 = new int[temp.length];

for (int i = 0; i < temp.length; i++) {

temp1[i] = temp[i] * (int) Math.pow(10, temp.length - 1 - i);

}

for (int i = 0; i < temp1.length; i++) {

m += temp1[i];

}

return m;

}

public static void multi(int[] temp, int[] temp1, int[] temp2) {

int i = toInt(temp1);

int j = toInt(temp2);

int k = toInt(temp);

if (k == i * j) {

System.out.println(k + "=" + i + "*" + j);

}

-------------------------------------------------------

输出所有的水仙花数

所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。

例如： 153 = 1*1*1 + 3*3*3 + 5*5*5

class ShuiXianHua {

public static void main(String[] args) {

for (int i = 100; i < 1000; i++) {// 实现所有的三位数的一个遍历

int j1 = 0;

int j2 = 0;

int j3 = 0;

j1 = i / 100;// 百位

j2 = (i - 100 * j1) / 10;// 十位

j3 = i - 100 * j1 - 10 * j2;// 个位

if (i == j1 * j1 * j1 + j2 * j2 * j2 + j3 * j3 * j3) {

System.out.println("此数值为满足条件的水仙花数:" + i);

}

山上有一口缸可以装50升水，现在有15升水。老和尚叫小和尚下山挑水，每次可以挑5升。问：小和尚要挑几次水才可以把水缸挑满？通过编程解决这个问题。

提示：

(1) 用整型变量water表示水缸里的水“int water = 15;”。

(2) 用整型变量l表示小和尚下山挑水的次数“int l = 0;”。

(3) 分析循环条件（水少于50升），循环操作（水增加5升，挑水次数增加1）。

(4) 套用while循环（或do-while循环）写出代码。

生成13位条形码

Ean-13码规则：第十三位数字是前十二位数字经过计算得到的校验码。

例如：690123456789

计算其校验码的过程为：

① 前十二位的奇数位和6+0+2+4+6+8=26

② 前十二位的偶数位和9+1+3+5+7+9=34

③ 将奇数和与偶数和的三倍相加26+34*3=128

④ 取结果的个位数：128的个位数为8

⑤ 用10减去这个个位数10-8=2

所以校验码为2

（注：如果取结果的个位数为0，那么校验码不是为10（10-0=10），而是0）

实现上述代码的功能，计算验证码，输入12位条码，返回带验证码的条码。

例：输入：692223361219输出：6922233612192

实现判断一个4位整数，统计出此整数里面包含多少个偶数，多少个奇数的功能

开发一款软件，根据公式（身高-108）*2=体重，可以有10斤左右的浮动。来观察测试者体重是否合适。

有3个整数，给出提示信息：

能否创建三角形；两边之和大于第三边三个条件都要写

如果能构建三角形，提示是直角三角形还是等边三角形等腰三角形还是普通三角形；

最后输出三角形面积；

其它

在JAVA中，如何跳出当前的多重嵌套循环？

答：用break或return 的方式。

三、计算机字符编码

一、有关编码的基础知识

1. 位 bit 最小的单元

字节 byte 机器语言的单位

1byte=8bits

1KB=1024byte

1MB=1024KB

1GB=1024MB

二进制 binary

八进制 octal

十进制 decimal

十六进制 hex

字符：是各种文字和符号的总称，包括各个国家的文字，标点符号，图形符号，数字等。字符集：字符集是多个符号的集合，每个字符集包含的字符个数不同。

字符编码：字符集只是规定了有哪些字符，而最终决定采用哪些字符，每一个字符用多少字节

表示等问题，则是由编码来决定的。计算机要准确的处理各种字符集文字，需要进行字符编码，以便计算机能够识别和存储各种文字。

二、常见字符编码的介绍

首先来看一下常用的编码有哪些，截图自 Notepad++。其中 ANSI 在中国大陆即为 GBK（以前

是 GB2312），最常用的是 GBK 和 UTF8 无 BOM 编码格式。后面三个都是有 BOM 头的文本格式，UCS-2 即为人们常说的 Unicode 编码，又分为大端、小端。

UTF8 的 BOM 头为 0xEF 0xBB 0xBF

Unicode 大端模式为 0xFE 0xFF

Unicode 小端模式为 0xFF 0xFE

**说明：需要添加插件 HEX-Editor

ASCII 码

计算机一开始发明的时候是用来解决数字计算的问题，后来人们发现，计算机还可以做更多的事，例如文本处理。但由于计算机只识“数”，因此人们必须告诉计算机哪个数字来代表哪个特定字符，例如 65 代表字母‘A’，66 代表字母‘B’，以此类推。但是计算机之间字符-数字的对应关系必须得一致，否则就会造成同一段数字在不同计算机上显示出来的字符不一样。因此美国国家标准协会 ANSI 制定了一个标准，规定了常用字符的集合以及每个字符对应的编号，这就是ASCII 字符集（Character Set），也称 ASCII 码。

那时候的字符编解码系统非常简单，就是简单的查表过程。例如将字符序列编码为二进制流写入存储设备，只需要在 ASCII 字符集中依次找到字符对应的字节，然后直接将该字节写入存储设备即可。解码二进制流的过程也是类似。

其中：

0～31 及 127(共 33 个)是控制字符或通信专用字符（其余为可显示字符），如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)

32～126(共 95 个)是字符(32 是空格），其中 48～57 为 0 到 9 十个阿拉伯数字。

65～90 为 26 个大写英文字母，97～122 号为 26 个小写英文字母，其余为一些标点符号、运算符号等。

后 128 个称为扩展 ASCII 码。许多基于 x86 的系统都支持使用扩展（或“高”）ASCII。扩展ASCII 码允许将每个字符的第 8 位用于确定附加的 128 个特殊符号字符、外来语字母和图形符号。

OEM 字符集的衍生

当计算机开始发展起来的时候，人们逐渐发现，ASCII 字符集里那可怜的 128 个字符已经不能再满足他们的需求了。人们就在想，一个字节能够表示的数字（编号）有 256 个，而 ASCII 字符只用到了 0x00~0x7F，也就是占用了前 128 个，后面 128 个数字不用白不用，因此很多人打起了后面这 128 个数字的主意。可是问题在于，很多人同时有这样的想法，但是大家对于0x80-0xFF 这后面的 128 个数字分别对应什么样的字符，却有各自的想法。这就导致了当时销往世界各地的机器上出现了大量各式各样的 OEM 字符集。

大家对于 0x00~0x7F 这个范围的解释基本是相同的，而对于后半部分 0x80~0xFF 的解释却不一定相同。甚至有时候同样的字符在不同 OEM 字符集中对应的字节也是不同的。

不同的 OEM 字符集导致人们无法跨机器交流各种文档。例如职员甲发了一封简历 résumés 给职员乙，结果职员乙看到的却是 r?sum?s，因为é字符在职员甲机器上的 OEM 字符集中对应的字节是 0x82，而在职员乙的机器上，由于使用的 OEM 字符集不同，对 0x82 字节解码后得到的字符却是?。

多字节字符集（MBCS）和中文字符集

上面我们提到的字符集都是基于单字节编码，也就是说，一个字节翻译成一个字符。这对于拉丁语系国家来说可能没有什么问题，因为他们通过扩展第8 个比特，就可以得到256 个字符了，足够用了。但是对于亚洲国家来说，256 个字符是远远不够用的。因此这些国家的人为了用上电脑，又要保持和 ASCII 字符集的兼容，就发明了多字节编码方式，相应的字符集就称为多字节字符集（Muilti-Bytes Charecter Set）。例如中国使用的就是双字节字符集编码。

例如目前最常用的中文字符集 GB2312，涵盖了所有简体字符以及一部分其他字符；GBK（K 代表扩展的意思）则在 GB2312 的基础上加入了对繁体字符等其他非简体字符。这两个字符集的字符都是使用 1-2 个字节来表示。Windows 系统采用 936 代码页来实现对GBK 字符集的编解码。在解析字节流的时候，如果遇到字节的最高位是 0 的话，那么就使用 936 代码页中的第 1 张码表进行解码，这就和单字节字符集的编解码方式一致了。如果遇到字节的最高位是 1 的话，那

么就表示需要两个字节值才能对应一个字符。假如你使用 GB2312 写了这么一句话：

我叫 ABC

它的二进制编码是这样的：

全角？

全角是一种电脑字符，且每个全角字符占用两个标准字符（或半角字符）位置。通常的英文字母、数字键、符号键都是半角的，半角的显示内码都是一个字节。为了排列整齐，英文和其它拉丁文的字符和标点也提供了全角格式。在中文输入法中，切换全角和半角格式的快捷键为SHIFT+空格。

ANSI 标准、国家标准、ISO 标准

不同 ASCII 衍生字符集的出现，让文档交流变得非常困难，因此各种组织都陆续进行了标准化流程。例如美国 ANSI 组织制定了 ANSI 标准字符编码（注意，我们现在通常说到 ANSI 编码，通常指的是平台的默认编码，例如英文操作系统中是 ISO-8859-1，中文系统是 GBK），ISO 组织制定的各种 ISO 标准字符编码，还有各国也会制定一些国家标准字符集，例如中国的 GBK， GB2312 和 GB18030 。

操作系统在发布的时候，通常会往机器里预装这些标准的字符集还有平台专用的字符集，这样

只要你的文档是使用标准字符集编写的，通用性就比较高了。例如你用 GB2312 字符集编写的文档，在中国大陆内的任何机器上都能正确显示。同时，我们也可以在一台机器上阅读多个国家不同语言的文档了，前提是本机必须安装该文档使用的字符集。

Unicode 的出现

虽然通过使用不同字符集，我们可以在一台机器上查阅不同语言的文档，但是我们仍然无法解决一个问题：如果一份文档中含有不同国家的不同语言的字符，那么无法在一份文档中显示所有字符。为了解决这个问题，我们需要一个全人类达成共识的巨大的字符集，这就是 Unicode

字符集。

Unicode 字符集涵盖了目前人类使用的所有字符，并为每个字符进行统一编号，分配唯一的字符码（Code Point）。Unicode 字符集将所有字符按照使用上的频繁度划分为 17 个层面（Plane），每个层面上有 216=65536 个字符码空间。

其中第 0 个层面 BMP，基本涵盖了当今世界用到的所有字符。其他的层面要么是用来表示一些远古时期的文字，要么是留作扩展。我们平常用到的 Unicode 字符，一般都是位于 BMP 层面上的。目前 Unicode 字符集中尚有大量字符空间未使用。

编码系统的变化

在 Unicode 出现之前，所有的字符集都是和具体编码方案绑定在一起的（即字符集≈编码方式），都是直接将字符和最终字节流绑定死了，例如 ASCII 编码系统规定使用 7 比特来编码 ASCII 字符

集；GB2312 以及 GBK 字符集，限定了使用最多 2 个字节来编码所有字符，并且规定了字节序。这样的编码系统通常用简单的查表，也就是通过代码页就可以直接将字符映射为存储设备

上的字节流了。例如下面这个例子：

Unicode 同样也不完美，这里就有三个问题，一个是，我们已经知道，英文字母只用一个字节表示就够了，第二个问题是如何才能区别 Unicode 和 ASCII？计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢？第三个，如果和 GBK 等双字节编码方式一样，用最高位是 1 或 0 表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。Unicode 在很长一段时间内无法推广，直到互联网的出现，为解决 Unicode 如何在网络上传输的问题，于是面向传输的众多 UTF（UCS Transfer Format）标准出现了，顾名思义，UTF-8 就是每次 8 个位传输数据，而 UTF-16 就是每次 16 个位。UTF-8 就是在互联网上使用最广的一种Unicode 的实现方式，这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。

UTF-8 最大的一个特点，就是它是一种变长的编码方式。它可以使用 1~4 个字节表示一个符号。从

unicode 到 uft-8 并不是直接的对应，而是要过一些算法和规则来转换（即 Uncidoe 字符集

≠UTF-8 编码方式）。

Unicode 符号范围 | UTF-8 编码方式

(十六进制) | （二进制）

—————————————————————–

0000 0000-0000 007F | 0xxxxxxx（兼容原来的 ASCII）

0000 0080-0000 07FF | 110xxxxx 10xxxxxx

0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx

0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

因此，Unicode 只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的 Unicode 编码是 UTF-16 和UTF-8。

早期字符编码、字符集和代码页等概念都是表达同一个意思。例如 GB2312 字符集、GB2312编码，936 代码页，实际上说的是同个东西。

但是对于 Unicode 则不同，Unicode 字符集只是定义了字符的集合和唯一编号，Unicode 编码，则是对 UTF-8、UCS-2/UTF-16 等具体编码方案的统称而已，并不是具体的编码方案。所以当需要用到字符编码的时候，你可以写 gb2312，codepage936，utf-8，utf-16，但请不要写 Unicode。造成乱码的原因就是因为使用了错误的字符编码去解码字节流，因此当我们在思考任何跟文本显示有关的问题时，请时刻保持清醒：当前使用的字符编码是什么。只有这样，我们才能正确分析和处理乱码问题。

常见 CharSet 有：GBK、GB2312、US-ASCII、ISO-8859-1、UTF-8、UTF-16BE、UTF-16LE、UTF-16