S01-03 JavaSE-基础-运算符
[TOC]
运算符 Operator（掌握）
运算符：是一种特殊的符号，用以表示数据的运算、赋值和比较等。
运算符的分类：
按照功能分为：
算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda 运算符
分类 运算符 算术运算符（7 个） +、-、*、/、%、++、-- 赋值运算符（12 个） =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等 比较(或关系)运算符（6 个） >、>=、<、<=、==、!= 逻辑运算符（6 个） &、|、^、!、&&、|| 位运算符（7 个） &、|、^、~、<<、>>、>>> 条件运算符（1 个） (条件表达式)?结果 1:结果 2 Lambda 运算符（1 个） ->（后面学） 按照操作数个数分为：
一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
分类 运算符 一元运算符（单目运算符） 正号（+）、负号（-）、++、--、!、~ 二元运算符（双目运算符） 除了一元和三元运算符剩下的都是二元运算符 三元运算符 （三目运算符） (条件表达式)?结果 1:结果 2
算术运算符
基本语法
举例 1：加减乘除模
java
public class ArithmeticTest1 {
public static void main(String[] args) {
int a = 3;
int b = 4;
System.out.println(a + b);// 7
System.out.println(a - b);// -1
System.out.println(a * b);// 12
System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
System.out.println(a % b);// 3
//结果与被模数符号相同
System.out.println(5%2);//1
System.out.println(5%-2);//1
System.out.println(-5%2);//-1
System.out.println(-5%-2);//-1
//商*除数 + 余数 = 被除数
//5%-2 ==>商是-2，余数时1 (-2)*(-2)+1 = 5
//-5%2 ==>商是-2，余数是-1 (-2)*2+(-1) = -4-1=-5
}
}举例 2：“+”号的两种用法
- 第一种：对于
+两边都是数值的话，+就是加法的意思 - 第二种：对于
+两边至少有一边是字符串的话，+就是拼接的意思
java
public class ArithmeticTest2 {
public static void main(String[] args) {
// 字符串类型的变量基本使用
// 数据类型 变量名称 = 数据值;
String str1 = "Hello";
System.out.println(str1); // Hello
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 520); // Java520
// String + int + int
// String + int
// String
System.out.println(str2 + 5 + 20); // Java520
}
}举例 3：自加自减运算
理解：++ 运算，表示自增1。同理，-- 运算，表示自减1，用法与++ 一致。
1、单独使用
- 变量在单独运算的时候，变量
前++和变量后++，是没有区别的。 - 变量
前++：例如++a。 - 变量
后++：例如a++。
java
public class ArithmeticTest3 {
public static void main(String[] args) {
// 定义一个int类型的变量a
int a = 3;
//++a;
a++;
// 无论是变量前++还是变量后++，结果都是4
System.out.println(a);
}
}2、复合使用
- 和
其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
- 变量
前++：变量先自增 1，然后再运算。 - 变量
后++：变量先运算，然后再自增 1。
java
public class ArithmeticTest4 {
public static void main(String[] args) {
// 其他变量放在一起使用
int x = 3;
//int y = ++x; // y的值是4，x的值是4，
int y = x++; // y的值是3，x的值是4
System.out.println(x);
System.out.println(y);
System.out.println("==========");
// 和输出语句一起
int z = 5;
//System.out.println(++z);// 输出结果是6，z的值也是6
System.out.println(z++);// 输出结果是5，z的值是6
System.out.println(z);
}
}案例与练习
案例 1：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1java
/**
* @author 尚硅谷-宋红康
* @create 12:20
*/
class ArithmeticExer1 {
public static void main(String[] args) {
int num = 187;
int bai = num / 100;
int shi = num % 100 / 10;//int shi = num / 10 % 10;
int ge = num % 10;
System.out.println("百位为：" + bai);
System.out.println("十位为：" + shi);
System.out.println("个位为：" + ge);
}
}拓展：获取一个四位数的个位，十位，百位，千位
java
/**
* @author 尚硅谷-宋红康
* @create 12:39
*/
public class ArithmeticExer01 {
public static void main (String [] args) {
//1.定义一个变量，赋值为一个四位数整数，例如1234
int num = 1234;
//2.通过运算操作求出个位，十位，百位，千位
int ge = num % 10;
int shi = num /10 % 10;
int bai = num /100 % 10;
int qian = num / 1000 % 10;
System.out.println("个位上的数字是：" + ge);
System.out.println("十位上的数字是：" + shi);
System.out.println("百位上的数字是：" + bai);
System.out.println("千位上的数字是：" + qian);
}
}案例 2：为抵抗洪水，战士连续作战 89 小时，编程计算共多少天零多少小时？
java
/**
* @author 尚硅谷-宋红康
* @create 17:47
*/
public class ArithmeticExer2 {
public static void main(String[] args){
int hours = 89;
int day = hours / 24;
int hour = hours % 24;
System.out.println("为抵抗洪水，战士连续作战89小时：");
System.out.println(hours + "是" + day + "天" + hour +"小时");
}
}练习 1：算术运算符：自加、自减
java
public class ArithmeticExer3{
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i="+i); //10
System.out.println("i1="+i1);//11
i = ++i1;
System.out.print("i="+i);//12
System.out.println("i1="+i1);//12
i = i2--;
System.out.print("i="+i);//20
System.out.println("i2="+i2);//19
i = --i2;
System.out.print("i="+i);//18
System.out.println("i2="+i2);//18
}
}练习 2：
java
System.out.println("5+5=" + 5 + 5); //打印结果是？ 5+5=55 ?练习 3：
java
byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128练习 4：
java
int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j);练习 5：（企业真题）写出下列程序的输出结果
java
int m = 2;
m = m++; //(1)先取b的值“2”放操作数栈 (2)m再自增,m=3 (3)再把操作数栈中的"2"赋值给m,m=2
System.out.println(m);
int n = m++;
System.out.println(n);赋值运算符
基本语法
符号：=
类型转换：当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
javaint i1 = 10; long l1 = i1; // 自动类型转换 byte bb1 = (byte)i1; // 强制类型转换支持连续赋值。
java// 连续赋值的测试 // 写法一：正常写法 int a1 = 10; int b1 = 10; // 写法二：连续赋值写法 int a2, b2; a2 = b2 = 10; // 写法三：多重变量声明 int a3 = 10, b3 = 20;
扩展赋值运算符： +=、 -=、*=、 /=、%=
| 赋值运算符 | 符号解释 |
|---|---|
+= | 将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量 |
-= | 将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量 |
*= | 将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量 |
/= | 将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量 |
%= | 将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量 |
示例：
+=示例：类似于m1 = m1 + 5，但不等同。m1 += 5：该写法不会改变 m1 的 short 类型。m1 = m1 + 5：该写法由于和 int 类型的 5 运算，会改变 m1 的类型为 int，再将 init 类型的值赋值给 short 类型，编译不会通过。
java// 举例说明：+= -= *= /= %= short m1 = 10; m1 += 5; // 类似于 m1 = m1 + 5 的操作，但不等同 System.out.println(m1);// 15
练习：
开发中，如何实现一个变量+2 的操作呢？
java//写法1：s1 += 2(推荐) short s1 = 10; s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short System.out.println(s1);//12 //写法2：s2 = s2 + 2 short s2 = 10; //s2 = s2 + 2;// 编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度 s2 = (short)(s2 + 2); // 正确写法 System.out.println(s2);开发中，如何实现一个变量+1 的操作呢？
java//写法1：num1++（推荐） int num1 = 10; num1++; System.out.println(num1); //写法2：num2 += 1 int num2 = 10; num2 += 1; System.out.println(num2); //写法3：num3 = num3 + 1 int num3 = 10; num3 = num3 + 1; System.out.println(num3);
练习
练习 1：
java
short s = 3;
s = s+2; //① 编译报错
s += 2; //② 正常执行
//①和②有什么区别？练习 2：
java
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1练习 3：
java
int m = 2;
int n = 3;
n *= m++; //n = n * (m++)
System.out.println("m=" + m);
System.out.println("n=" + n);练习 4：
java
int n = 10;
n += (n++) + (++n); //n = n + (n++) + (++n)
System.out.println(n);练习 5：
int j = 1;
j += ++j * j++;//相当于 j = j + (++j * j++);
System.out.println(j);//5练习 6：你有几种办法实现变量值 - 1？变量值-2 呢？
java
/**
* @author 尚硅谷-宋红康
* @create 16:55
*/
public class MinusTest {
public static void main(String[] args) {
//练习①：变量-1
short s = 10;
//方式1：
//s = (short)(s - 1);
//方式2：推荐
s--; // --s
//方式3：
s -= 1;
//练习②：变量-2
short s1 = 10;
//方式1：
//s1 = (short)(s1 - 2);
//方式2：推荐
s1 -= 2;
}
}关系(比较)运算符
运算结果：比较运算符的结果都是boolean类型，也就是要么是 true，要么是 false。
适用数据类型：
== != > < >= <=：只适用于基本数据类型（除 boolean 类型之外，== !=适用于布尔类型）== !=：适用于基本数据类型和引用数据类型
比较运算符“==”不能误写成“=”
示例：
关系运算符的基本使用
java// 关系运算符的基本使用 int i1 = 10; int i2 = 20; System.out.println(i1 == i2);//false System.out.println(i1 != i2);//true System.out.println(i1 >= i2);//false== 和 = 的区别
java// == 和 = 的区别 int m = 10; int n = 20; System.out.println(m == n);//false System.out.println(m = n);//20boolean 类型不能参与比较运算
java// boolean 类型不能参与比较运算 boolean b1 = false; boolean b2 = true; System.out.println(b1 == b2);//false System.out.println(b1 = b2);//true
思考：
java
boolean b1 = false;
//区分好==和=的区别。
if(b1 == true) //if(!b1)
System.out.println("结果为真");
else
System.out.println("结果为假");逻辑运算符
基本语法
逻辑运算符：操作的都是 boolean 类型的变量或常量，而且运算得结果也是 boolean 类型的值。
运算符说明：
& 和 &&：表示"且"关系，当符号左右两边布尔值都是 true 时，结果才能为 true。否则，为 false。| 和 ||：表示"或"关系，当符号两边布尔值有一边为 true 时，结果为 true。当两边都为 false 时，结果为 false!：表示"非"关系，当变量布尔值为 true 时，结果为 false。当变量布尔值为 false 时，结果为 true。^：表示"异或"关系，当符号左右两边布尔值不同时，结果为 true。当两边布尔值相同时，结果为 false。- 理解：异或，追求的是“异”！
逻辑运算符用途：用于连接布尔型表达式，在 Java 中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。
区分“&”和“&&”：
相同点：如果符号左边是 true，则二者都执行符号右边的操作
不同点：
&： 如果符号左边是 false,则继续执行符号右边的操作&&：如果符号左边是 false,则不再继续执行符号右边的操作
建议：开发中，推荐使用
&&
区分“|”和“||”：
相同点：如果符号左边是 false，则二者都执行符号右边的操作
不同点：
|： 如果符号左边是 true，则继续执行符号右边的操作||：如果符号左边是 true，则不再继续执行符号右边的操作
建议：开发中，推荐使用
||
java
public class LoginTest {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;
// & 与，且；有false则false
System.out.println((a > b) & (a > c));
System.out.println((a > b) & (a < c));
System.out.println((a < b) & (a > c));
System.out.println((a < b) & (a < c));
System.out.println("===============");
// | 或；有true则true
System.out.println((a > b) | (a > c));
System.out.println((a > b) | (a < c));
System.out.println((a < b) | (a > c));
System.out.println((a < b) | (a < c));
System.out.println("===============");
// ^ 异或；相同为false，不同为true
System.out.println((a > b) ^ (a > c));
System.out.println((a > b) ^ (a < c));
System.out.println((a < b) ^ (a > c));
System.out.println((a < b) ^ (a < c));
System.out.println("===============");
// ! 非；非false则true，非true则false
System.out.println(!false);
System.out.println(!true);
//&和&&的区别
System.out.println((a > b) & (a++ > c));
System.out.println("a = " + a);
System.out.println((a > b) && (a++ > c));
System.out.println("a = " + a);
System.out.println((a == b) && (a++ > c));
System.out.println("a = " + a);
//|和||的区别
System.out.println((a > b) | (a++ > c));
System.out.println("a = " + a);
System.out.println((a > b) || (a++ > c));
System.out.println("a = " + a);
System.out.println((a == b) || (a++ > c));
System.out.println("a = " + a);
}
}案例与练习
案例：
1. 定义类 CompareLogicExer
2. 定义 main方法
3. 定义一个int类型变量a,变量b,都赋值为20
4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
5. 输出a的值,bo1的值
6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
7. 输出b的值,bo2的值java
/**
* @author 尚硅谷-宋红康
* @create 12:42
*/
public class CompareLogicExer {
public static void main(String[] args){
int a = 20;
int b = 20;
boolean bo1 = ((++a % 3) == 0) && ((a++ % 7) == 0);
System.out.println("bo1的值：" + bo1);
System.out.println("a的值：" + a);
System.out.println("----------------------------");
boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0);
System.out.println("bo2的值：" + bo2);
System.out.println("b的值：" + b);
}
}练习：
**练习 1：**区分 & 和 &&
java
int x = 1;
int y = 1;
if(x++ == 2 & ++y == 2){
x = 7;
}
System.out.println("x=" + x + ",y=" + y);java
int x = 1,y = 1;
if(x++ == 2 && ++y == 2){
x =7;
}
System.out.println("x="+x+",y="+y);**练习 2：**区分 | 和 ||
java
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);java
int x = 1,y = 1;
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);**练习 3：**程序输出
java
class Test {
public static void main (String [] args) {
boolean x = true;
boolean y = false;
short z = 42;
//if(y == true)
if ((z++ == 42) && (y = true)) z++;
if ((x = false) || (++z == 45)) z++;
System.out.println("z=" + z);
}
}java
//结果为：
//z= 46位运算符（难点、非重点）@
基本语法
- 位运算符的运算过程都是基于二进制的补码运算
（1）左移：<<
运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）
【注意】当左移的位数 n 超过该数据类型的总位数时，相当于左移（n-总位数）位
byte,short,char 在计算时按照 int 类型处理
java
3<<4 类似于 3*2的4次幂 => 3*16 => 48
java
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）
【注意】如果不能整除，向下取整。
java
69>>4 类似于 69/2的4次 = 69/16 =4
-69>>4 类似于 -69/2的4次 = -69/16 = -5
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补 0。（正数、负数都适用）
69>>>4 类似于 69/2的4次 = 69/16 =4
-69>>>4 结果：268435451
（4）按位与：&
运算规则：对应位都是 1 才为 1，否则为 0。
1 & 1 结果为 1
1 & 0 结果为 0
0 & 1 结果为 0
0 & 0 结果为 0
java
9 & 7 = 1
java
-9 & 7 = 7
（5）按位或：|
运算规则：对应位只要有 1 即为 1，否则为 0。
1 | 1 结果为 1
1 | 0 结果为 1
0 | 1 结果为 1
0 & 0 结果为 0
java
9 | 7 //结果： 15
java
-9 | 7 //结果： -9
（6）按位异或：^
运算规则：对应位一个为 1 一个为 0，才为 1，否则为 0。
1 ^ 1 结果为 0
1 ^ 0 结果为 1
0 ^ 1 结果为 1
0 ^ 0 结果为 0
java
9 ^ 7 //结果为14
java
-9 ^ 7 //结果为-16
（7）按位取反：~
运算规则：对应位为 1，则结果为 0；对应位为 0，则结果为 1。
~0 就是 1
~1 就是 0
java
~9 //结果：-10
java
~-9 //结果：8
举例
举例 1：
举例 2：体会 m = k ^ n = (m ^ n) ^ n
案例
**案例 1：**高效的方式计算 2 * 8 的值
答案：2 << 3 、 8 << 1**案例 2：**变量换值：交换两个 int 型变量的值。 String 呢？
java
/**
* @author 尚硅谷-宋红康
* @create 16:58
*/
public class BitExer {
public static void main(String[] args) {
int m = 10;
int n = 5;
System.out.println("m = " + m + ", n = " + n);
//（推荐）实现方式1：优点：容易理解，适用于不同数据类型 缺点：需要额外定义变量
//int temp = m;
//m = n;
//n = temp;
//实现方式2：优点：没有额外定义变量 缺点：可能超出int的范围；只能适用于数值类型
//m = m + n; //15 = 10 + 5
//n = m - n;//10 = 15 - 5
//m = m - n;//5 = 15 - 10
//实现方式3：优点：没有额外定义变量 缺点：不易理解；只能适用于数值类型
m = m ^ n;
n = m ^ n; //(m ^ n) ^ n
m = m ^ n;
System.out.println("m = " + m + ", n = " + n);
}
}条件运算符
基本语法
- 条件运算符格式：
java
(条件表达式) ? 表达式1 : 表达式2说明：条件表达式是 boolean 类型的结果，根据 boolean 的值选择表达式 1 或表达式 2
表达式 1 和表达式 2 为同种或兼容的类型
java
public static void main(String[] args) {
int i = (1==2 ? 100 : 200);
System.out.println(i);//200
boolean marry = false;
System.out.println(marry ? "已婚" : "未婚" );
double d1 = (m1 > m2)? 1 : 2.0;
System.out.println(d1);
int num = 12;
System.out.println(num > 0? true : "num非正数");
}案例
**案例 1：**获取两个数中的较大值。
java
/**
* @author 尚硅谷-宋红康
* @create 12:40
*/
public class ConditionExer1 {
public static void main(String[] args) {
//获取两个数的较大值
int m1 = 10;
int m2 = 20;
int max1 = (m1 > m2)? m1 : m2;
System.out.println("m1和m2中的较大值为" + max1);
}
}**案例 2：**获取三个数中的最大值。
java
/**
* @author 尚硅谷-宋红康
* @create 12:43
*/
public class ConditionExer2 {
public static void main(String[] args) {
int n1 = 23;
int n2 = 13;
int n3 = 33;
//写法1：
int tempMax = (n1 > n2)? n1:n2;
int finalMax = (tempMax > n3)? tempMax : n3;
System.out.println("三个数中最大值为：" + finalMax);
//写法2：不推荐，可读性差
int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3;
System.out.println("三个数中最大值为：" + finalMax1);
}
}**案例 3：**今天是周 2，10 天以后是周几？
要求：控制台输出"今天是周 2，10 天以后是周 x"。
java
/**
* @author 尚硅谷-宋红康
* @create 12:46
*/
public class ConditionExer3 {
public static void main(String[] args) {
int week = 2;
week += 10;
week %= 7;
System.out.println("今天是周2,10天以后是周" + (week == 0 ? "日" : week));
}
}案例 4：
给定一个年份，判断是否是闰年。输出"xxx年(是/不是)闰年"。
闰年的判断标准是：
1）可以被4整除，但不可被100整除
2）可以被400整除java
/**
* @author 尚硅谷-宋红康
* @create 12:49
*/
public class ConditionExer4 {
public static void main(String[] args) {
int year = 2018;
boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
System.out.println(year + (isLeapYear ? "是闰年" : "不是闰年"));
}
}与 if-else 的转换关系
凡是可以使用条件运算符的地方，都可以改写为 if-else 结构。反之，不成立。
开发中，如果既可以使用条件运算符，又可以使用 if-else，推荐使用条件运算符。因为执行效率稍高。
java
//if-else实现获取两个数的较大值
int i1 = 10;
int i2 = 20;
int max;//声明变量max，用于记录i1和i2的较大值
if(i1 > i2){
max = i1;
}else{
max = i2;
}
System.out.println(max);运算符优先级
运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。
| 优先级 | 运算符说明 | Java 运算符 | | ------ | :--------------: | :--------------------------------: | ------------------------ | --- | | 1 | 括号 | ()、[]、{} | | 2 | 正负号 | +、- | | 3 | 单元运算符 | ++、--、~、！ | | 4 | 乘法、除法、求余 | *、/、% | | 5 | 加法、减法 | +、- | | 6 | 移位运算符 | <<、>>、>>> | | 7 | 关系运算符 | <、<=、>=、>、instanceof | | 8 | 等价运算符 | ==、!= | | 9 | 按位与 | & | | 10 | 按位异或 | ^ | | 11 | 按位或 | | | | 12 | 条件与 | && | | 13 | 条件或 | | | | | 14 | 三元运算符 | ? : | | 15 | 赋值运算符 | =、+=、-=、*=、/=、%= | | 16 | 位赋值运算符 | &=、 | =、<<=、>>=、>>>= |
开发建议：
- 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量
使用()来控制、改变表达式的执行顺序。- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它
分成几步来完成。例如： (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;- 逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（
逻辑非 > 逻辑与 > 逻辑或）。如： a || b && c 的运算结果是：a || ( b && c )，而不是( a|| b ) && c
字符集（拓展）
字符集
- 编码与解码
计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。
字符编码（Character Encoding） : 就是一套自然语言的字符与二进制数之间的对应规则。
字符集：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等。
ASCII 码
- ASCII 码（American Standard Code for Information Interchange，美国信息交换标准代码）：上个世纪 60 年代，美国制定了一套字符编码，对
英语字符与二进制位之间的关系，做了统一规定。这被称为 ASCII 码。 - ASCII 码用于显示现代英语，主要包括控制字符（回车键、退格、换行键等）和可显示字符（英文大小写字符、阿拉伯数字和西文符号）。
- 基本的 ASCII 字符集，使用 7 位（bits）表示一个字符（最前面的 1 位统一规定为 0），共
128个字符。比如：空格“SPACE”是 32（二进制 00100000），大写的字母 A 是 65（二进制 01000001）。 - 缺点：不能表示所有字符。
ISO-8859-1 字符集
- 拉丁码表，别名 Latin-1，用于显示欧洲使用的语言，包括荷兰语、德语、意大利语、葡萄牙语等
- ISO-8859-1 使用单字节编码，兼容 ASCII 编码。
GBxxx 字符集
- GB 就是国标的意思，是为了
显示中文而设计的一套字符集。 - GB2312：简体中文码表。一个小于 127 的字符的意义与原来相同，即向下兼容 ASCII 码。但两个大于 127 的字符连在一起时，就表示一个汉字，这样大约可以组合了包含
7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名们都编进去了，这就是常说的"全角"字符，而原来在 127 号以下的那些符号就叫"半角"字符了。 - GBK：最常用的中文码表。是在 GB2312 标准基础上的扩展规范，使用了
双字节编码方案，共收录了21003个汉字，完全兼容 GB2312 标准，同时支持繁体汉字以及日韩汉字等。 - GB18030：最新的中文码表。收录汉字
70244个，采用多字节编码，每个字可以由 1 个、2 个或 4 个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等。
Unicode 码
Unicode 编码为表达
任意语言的任意字符而设计，也称为统一码、标准万国码。Unicode 将世界上所有的文字用2个字节统一进行编码，为每个字符设定唯一的二进制编码，以满足跨语言、跨平台进行文本处理的要求。Unicode 的缺点：这里有三个问题：
- 第一，英文字母只用一个字节表示就够了，如果用更多的字节存储是
极大的浪费。 - 第二，如何才能
区别Unicode和ASCII？计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢？ - 第三，如果和 GBK 等双字节编码方式一样，用最高位是 1 或 0 表示两个字节和一个字节，就少了很多值无法用于表示字符，
不够表示所有字符。
- 第一，英文字母只用一个字节表示就够了，如果用更多的字节存储是
Unicode 在很长一段时间内无法推广，直到互联网的出现，为解决 Unicode 如何在网络上传输的问题，于是面向传输的众多 UTF（UCS Transfer Format）标准出现。具体来说，有三种编码方案，UTF-8、UTF-16 和 UTF-32。
UTF-8
- Unicode 是字符集，UTF-8、UTF-16、UTF-32 是三种
将数字转换到程序数据的编码方案。顾名思义，UTF-8 就是每次 8 个位传输数据，而 UTF-16 就是每次 16 个位。其中，UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。 - 互联网工程工作小组（IETF）要求所有互联网协议都必须支持 UTF-8 编码。所以，我们开发 Web 应用，也要使用 UTF-8 编码。UTF-8 是一种
变长的编码方式。它可以使用 1-4 个字节表示一个符号它使用一至四个字节为每个字符编码，编码规则：- 128 个 US-ASCII 字符，只需一个字节编码。
- 拉丁文等字符，需要二个字节编码。
- 大部分常用字（含中文），使用三个字节编码。
- 其他极少使用的 Unicode 辅助字符，使用四字节编码。
- 举例
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
小结
注意：在中文操作系统上，ANSI（美国国家标准学会、AMERICAN NATIONAL STANDARDS INSTITUTE: ANSI）编码即为 GBK；在英文操作系统上，ANSI 编码即为 ISO-8859-1。