使用java的API编写代码

JavaBean

在Java中，有很多class的定义都符合这样的规范：

若干private实例字段；
通过public方法来读写实例字段。

public class Person {private String name;private int age;public String getName() { return this.name; }public void setName(String name) { this.name = name; }public int getAge() { return this.age; }public void setAge(int age) { this.age = age; }
}

如果读写方法符合以下这种命名规范：

// 读方法:
public Type getXyz()
// 写方法:
public void setXyz(Type value)

那么这种class被称为JavaBean：

上面的字段是xyz，那么读写方法名分别以get和set开头，并且后接大写字母开头的字段名Xyz，因此两个读写方法名分别是getXyz()和setXyz()。

boolean字段比较特殊，它的读方法一般命名为isXyz()：

// 读方法:
public boolean isChild()
// 写方法:
public void setChild(boolean value)

我们通常把一组对应的读方法（getter）和写方法（setter）称为属性（property）。例如，name属性：

对应的读方法是String getName()
对应的写方法是setName(String)

只有getter的属性称为只读属性（read-only），例如，定义一个age只读属性：

对应的读方法是int getAge()
无对应的写方法setAge(int)

类似的，只有setter的属性称为只写属性（write-only）。

很明显，只读属性很常见，只写属性不常见。

属性只需要定义getter和setter方法，不一定需要对应的字段。例如，child只读属性定义如下：

public class Person {private String name;private int age;public String getName() { return this.name; }public void setName(String name) { this.name = name; }public int getAge() { return this.age; }public void setAge(int age) { this.age = age; }public boolean isChild() {return age <= 6;}
}

可以看出，getter和setter也是一种数据封装的方法。

JavaBean的作用

JavaBean主要用来传递数据，即把一组数据组合成一个JavaBean便于传输。此外，JavaBean可以方便地被IDE工具分析，生成读写属性的代码，主要用在图形界面的可视化设计中。

枚举JavaBean属性

要枚举一个JavaBean的所有属性，可以直接使用Java核心库提供的Introspector：

import java.beans.*;
public class Main {public static void main(String[] args) throws Exception {BeanInfo info = Introspector.getBeanInfo(Person.class);for (PropertyDescriptor pd : info.getPropertyDescriptors()) {System.out.println(pd.getName());System.out.println("  " + pd.getReadMethod());System.out.println("  " + pd.getWriteMethod());}}
}class Person {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

运行上述代码，可以列出所有的属性，以及对应的读写方法。注意class属性是从Object继承的getClass()方法带来的。

JavaBean是一种符合命名规范的class，它通过getter和setter来定义属性；

属性是一种通用的叫法，并非Java语法规定；

可以利用IDE快速生成getter和setter；

使用Introspector.getBeanInfo()可以获取属性列表。

枚举类

在Java中，我们可以通过static final来定义常量。例如，我们希望定义周一到周日这7个常量，可以用7个不同的int表示：

public class Weekday {public static final int SUN = 0;public static final int MON = 1;public static final int TUE = 2;public static final int WED = 3;public static final int THU = 4;public static final int FRI = 5;public static final int SAT = 6;
}

使用常量的时候，可以这么引用：

if (day == Weekday.SAT || day == Weekday.SUN) {// TODO: work at home
}

也可以把常量定义为字符串类型，例如，定义3种颜色的常量：

public class Color {public static final String RED = "r";public static final String GREEN = "g";public static final String BLUE = "b";
}

使用常量的时候，可以这么引用：

String color = ...
if (Color.RED.equals(color)) {// TODO:
}

无论是int常量还是String常量，使用这些常量来表示一组枚举值的时候，有一个严重的问题就是，编译器无法检查每个值的合理性。例如：

if (weekday == 6 || weekday == 7) {if (tasks == Weekday.MON) {// TODO:}
}

上述代码编译和运行均不会报错，但存在两个问题：

注意到Weekday定义的常量范围是0~6，并不包含7，编译器无法检查不在枚举中的int值；
定义的常量仍可与其他变量比较，但其用途并非是枚举星期值。

enum

　　Java中的枚举其实是一种语法糖，在 JDK 1.5之后出现，用来表示固定且有限个的对象。比如一个季节类有春、夏、秋、冬四个对象；一个星期有星期一到星期日七个对象。这些明显都是固定的，且有限个。

枚举类和普通类的区别

　　①、使用 enum 定义的枚举类默认继承 java.lang.Enum 类，即枚举类是不能再继承别的类了。而普通类的一般父类默认是 Object

　　②、枚举类的构造器只能使用 private 定义，而普通类的还可以用 public 修饰

　　③、枚举类的所有实例必须在枚举类中显示列出（，分隔；结尾），列出的实例系统会默认自动添加 public static final 修饰

　　④、所有的枚举类都提供了一个 values() 方法，可以用来遍历枚举值

为了让编译器能自动检查某个值在枚举的集合内，并且，不同用途的枚举需要不同的类型来标记，不能混用，我们可以使用enum来定义枚举类：

public class Main {public static void main(String[] args) {Weekday day = Weekday.SUN;if (day == Weekday.SAT || day == Weekday.SUN) {System.out.println("Work at home!");} else {System.out.println("Work at office!");}}
}enum Weekday {SUN, MON, TUE, WED, THU, FRI, SAT;
}

注意到定义枚举类是通过关键字enum实现的，我们只需依次列出枚举的常量名。

和int定义的常量相比，使用enum定义枚举有如下好处：

首先，enum常量本身带有类型信息，即Weekday.SUN类型是Weekday，编译器会自动检查出类型错误。例如，下面的语句不可能编译通过：

int day = 1;
if (day == Weekday.SUN) { // Compile error: bad operand types for binary operator '=='
}

其次，不可能引用到非枚举的值，因为无法通过编译。

最后，不同类型的枚举不能互相比较或者赋值，因为类型不符。例如，不能给一个Weekday枚举类型的变量赋值为Color枚举类型的值：

Weekday x = Weekday.SUN; // ok!
Weekday y = Color.RED; // Compile error: incompatible types

这就使得编译器可以在编译期自动检查出所有可能的潜在错误。

enum的比较

使用enum定义的枚举类是一种引用类型。前面我们讲到，引用类型比较，要使用equals()方法，如果使用==比较，它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用equals()方法，但enum类型可以例外。

这是因为enum类型的每个常量在JVM中只有一个唯一实例，所以可以直接用==比较：

if (day == Weekday.FRI) { // ok!
}
if (day.equals(Weekday.SUN)) { // ok, but more code!
}

enum类型

通过enum定义的枚举类，和其他的class有什么区别？

答案是没有任何区别。enum定义的类型就是class，只不过它有以下几个特点：

定义的enum类型总是继承自java.lang.Enum，且无法被继承；
只能定义出enum的实例，而无法通过new操作符创建enum的实例；
定义的每个实例都是引用类型的唯一实例；
可以将enum类型用于switch语句。

例如，我们定义的Color枚举类：

public enum Color {RED, GREEN, BLUE;
}

编译器编译出的class大概就像这样：

public final class Color extends Enum { // 继承自Enum，标记为final class// 每个实例均为全局唯一:public static final Color RED = new Color();public static final Color GREEN = new Color();public static final Color BLUE = new Color();// private构造方法，确保外部无法调用new操作符:private Color() {}
}

所以，编译后的enum类和普通class并没有任何区别。但是我们自己无法按定义普通class那样来定义enum，必须使用enum关键字，这是Java语法规定的。

因为enum是一个class，每个枚举的值都是class实例，因此，这些实例有一些方法：

name()

返回常量名，例如：

String s = Weekday.SUN.name(); // "SUN"

ordinal()

返回定义的常量的顺序，从0开始计数，例如：

int n = Weekday.MON.ordinal(); // 1

改变枚举常量定义的顺序就会导致ordinal()返回值发生变化。例如：

public enum Weekday {SUN, MON, TUE, WED, THU, FRI, SAT;
}

和

public enum Weekday {MON, TUE, WED, THU, FRI, SAT, SUN;
}

的ordinal就是不同的。如果在代码中编写了类似if(x.ordinal()==1)这样的语句，就要保证enum的枚举顺序不能变。新增的常量必须放在最后。

有些童鞋会想，Weekday的枚举常量如果要和int转换，使用ordinal()不是非常方便？比如这样写：

String task = Weekday.MON.ordinal() + "/ppt";
saveToFile(task);

但是，如果不小心修改了枚举的顺序，编译器是无法检查出这种逻辑错误的。要编写健壮的代码，就不要依靠ordinal()的返回值。因为enum本身是class，所以我们可以定义private的构造方法，并且，给每个枚举常量添加字段：

public class Main {public static void main(String[] args) {Weekday day = Weekday.SUN;if (day.dayValue == 6 || day.dayValue == 0) {System.out.println("Work at home!");} else {System.out.println("Work at office!");}}
}enum Weekday {MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6), SUN(0);public final int dayValue;private Weekday(int dayValue) {this.dayValue = dayValue;}
}

这样就无需担心顺序的变化，新增枚举常量时，也需要指定一个int值。

注意：枚举类的字段也可以是非final类型，即可以在运行期修改，但是不推荐这样做！

默认情况下，对枚举常量调用toString()会返回和name()一样的字符串。但是，toString()可以被覆写，而name()则不行。我们可以给Weekday添加toString()方法：

public class Main {public static void main(String[] args) {Weekday day = Weekday.SUN;if (day.dayValue == 6 || day.dayValue == 0) {System.out.println("Today is " + day + ". Work at home!");} else {System.out.println("Today is " + day + ". Work at office!");}}
}enum Weekday {MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");public final int dayValue;private final String chinese;private Weekday(int dayValue, String chinese) {this.dayValue = dayValue;this.chinese = chinese;}@Overridepublic String toString() {return this.chinese;}
}

覆写toString()的目的是在输出时更有可读性。

注意：判断枚举常量的名字，要始终使用name()方法，绝不能调用toString()！

switch

枚举类可以应用在switch语句中。因为枚举类天生具有类型信息和有限个枚举常量，所以比int、String类型更适合用在switch语句中：

public class Main {public static void main(String[] args) {Weekday day = Weekday.SUN;switch(day) {case MON:case TUE:case WED:case THU:case FRI:System.out.println("Today is " + day + ". Work at office!");break;case SAT:case SUN:System.out.println("Today is " + day + ". Work at home!");break;default:throw new RuntimeException("cannot process " + day);}}
}enum Weekday {MON, TUE, WED, THU, FRI, SAT, SUN;
}

加上default语句，可以在漏写某个枚举常量时自动报错，从而及时发现错误。

Java使用enum定义枚举类型，它被编译器编译为final class Xxx extends Enum { … }；

通过name()获取常量定义的字符串，注意不要使用toString()；

通过ordinal()返回常量定义的顺序（无实质意义）；

可以为enum编写构造方法、字段和方法

enum的构造方法要声明为private，字段强烈建议声明为final；

enum适合用在switch语句中。

使用 Enum 来表示季节类：

public enum SeasonEnum {//必须在第一行写出有哪些枚举值SPRING("春天", "春暖花开"),SUMMER("夏天", "炎炎盛夏"),FALL("秋天", "秋高气爽"),WINTER("冬天", "大雪纷飞");private final String name;private final String desc;private SeasonEnum(String name, String desc) {this.name = name;this.desc = desc;}}

public static void main(String[] args) {System.out.println(SeasonEnum.SPRING); //SPRING//用 values() 来获取所有的枚举值for(SeasonEnum s : SeasonEnum.values()){System.out.println(s);}}

枚举类还能实现接口：

第一步：定义一个接口，方法是返回季节的月份

public interface SeasonEnumImpl {//用来返回季节的月份String getMonth();}

第二步：季节类实现接口，并实现接口中的方法

public enum SeasonEnum implements SeasonEnumImpl{//必须在第一行写出有哪些枚举值SPRING("春天", "春暖花开"){@Overridepublic String getMonth() {return "12-2";}},SUMMER("夏天", "炎炎盛夏"){@Overridepublic String getMonth() {return "3-5";}},FALL("秋天", "秋高气爽"){@Overridepublic String getMonth() {return "6-8";}},WINTER("冬天", "大雪纷飞"){@Overridepublic String getMonth() {return "9-11";}};private final String name;private final String desc;private SeasonEnum(String name, String desc) {this.name = name;this.desc = desc;}
}

public static void main(String[] args) {System.out.println(SeasonEnum.SPRING); //SPRING//用 values() 来获取所有的枚举值for(SeasonEnum s : SeasonEnum.values()){System.out.println(s.getMonth());}}

结果为：

SPRING
12-2
3-5
6-8
9-11

如果枚举类的对象只有一个，那么可以作为单例模式的实现

Math工具类

public class MathDemo {public static void main(String args[]){  /** *Math.sqrt()//计算平方根*Math.cbrt()//计算立方根*Math.pow(a, b)//计算a的b次方*Math.max( , );//计算最大值*Math.min( , );//计算最小值*/  System.out.println(Math.sqrt(16));   //4.0 System.out.println(Math.cbrt(8));    //2.0System.out.println(Math.pow(3,2));     //9.0System.out.println(Math.max(2.3,4.5));//4.5System.out.println(Math.min(2.3,4.5));//2.3Math.exp(2); // 计算ex次方：7.389...Math.log(4); // 计算以e为底的对数：1.386...Math.log10(100); // 计算以10为底的对数：2//三角函数Math.sin(3.14); // 0.00159...Math.cos(3.14); // -0.9999...Math.tan(3.14); // -0.0015...Math.asin(1.0); // 1.57079...Math.acos(1.0); // 0.0/** * abs求绝对值 */  System.out.println(Math.abs(-10.4));    //10.4  System.out.println(Math.abs(10.1));     //10.1  /** * ceil天花板的意思，就是返回大的值*/  System.out.println(Math.ceil(-10.1));   //-10.0  System.out.println(Math.ceil(10.7));    //11.0  System.out.println(Math.ceil(-0.7));    //-0.0  System.out.println(Math.ceil(0.0));     //0.0  System.out.println(Math.ceil(-0.0));    //-0.0  System.out.println(Math.ceil(-1.7));    //-1.0/** * floor地板的意思，就是返回小的值 */  System.out.println(Math.floor(-10.1));  //-11.0  System.out.println(Math.floor(10.7));   //10.0  System.out.println(Math.floor(-0.7));   //-1.0  System.out.println(Math.floor(0.0));    //0.0  System.out.println(Math.floor(-0.0));   //-0.0  System.out.println("----------------------------");/** * random 取得一个大于或者等于0.0小于不等于1.0的随机数 */  System.out.println(Math.random());  //小于1大于0的double类型的数System.out.println(Math.random()*2);//大于0小于1的double类型的数System.out.println(Math.random()*2+1);//大于1小于2的double类型的数/** * rint 四舍五入，返回double值 * 注意.5的时候会取偶数    异常的尴尬=。=*/  System.out.println(Math.rint(10.1));    //10.0  System.out.println(Math.rint(10.7));    //11.0  System.out.println(Math.rint(11.5));    //12.0  System.out.println(Math.rint(10.5));    //10.0  System.out.println(Math.rint(10.51));   //11.0  System.out.println(Math.rint(-10.5));   //-10.0  System.out.println(Math.rint(-11.5));   //-12.0  System.out.println(Math.rint(-10.51));  //-11.0  System.out.println(Math.rint(-10.6));   //-11.0  System.out.println(Math.rint(-10.2));   //-10.0  /** * round 四舍五入，float时返回int值，double时返回long值 */  System.out.println(Math.round(10.1));   //10  System.out.println(Math.round(10.7));   //11  System.out.println(Math.round(10.5));   //11  System.out.println(Math.round(10.51));  //11  System.out.println(Math.round(-10.5));  //-10  System.out.println(Math.round(-10.51)); //-11  System.out.println(Math.round(-10.6));  //-11  System.out.println(Math.round(-10.2));  //-10  //Math还提供了几个数学常量double pi = Math.PI; // 3.14159...double e = Math.E; // 2.7182818...Math.sin(Math.PI / 6); // sin(π/6) = 0.5}  }

生成一个随机数x，x的范围是0 <= x < 1：

Math.random(); // 0.53907... 每次都不一样

如果我们要生成一个区间在[MIN, MAX)的随机数，可以借助Math.random()实现，计算如下：

// 区间在[MIN, MAX)的随机数
public class Main {public static void main(String[] args) {double x = Math.random(); // x的范围是[0,1)double min = 10;double max = 50;double y = x * (max - min) + min; // y的范围是[10,50)long n = (long) y; // n的范围是[10,50)的整数System.out.println(y);System.out.println(n);}
}

有些童鞋可能注意到Java标准库还提供了一个StrictMath，它提供了和Math几乎一模一样的方法。这两个类的区别在于，由于浮点数计算存在误差，不同的平台（例如x86和ARM）计算的结果可能不一致（指误差不同），因此，StrictMath保证所有平台计算结果都是完全相同的，而Math会尽量针对平台优化计算速度，所以，绝大多数情况下，使用Math就足够了。

Random

Random用来创建伪随机数。所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的。

要生成一个随机数，可以使用nextInt()、nextLong()、nextFloat()、nextDouble()：

Random r = new Random();
r.nextInt(); // 2071575453,每次都不一样
r.nextInt(10); // 5,生成一个[0,10)之间的int
r.nextLong(); // 8811649292570369305,每次都不一样
r.nextFloat(); // 0.54335...生成一个[0,1)之间的float
r.nextDouble(); // 0.3716...生成一个[0,1)之间的double

有童鞋问，每次运行程序，生成的随机数都是不同的，没看出伪随机数的特性来。

这是因为我们创建Random实例时，如果不给定种子，就使用系统当前时间戳作为种子，因此每次运行时，种子不同，得到的伪随机数序列就不同。

如果我们在创建Random实例时指定一个种子，就会得到完全确定的随机数序列：

import java.util.Random;
public class Main {public static void main(String[] args) {Random r = new Random(12345);for (int i = 0; i < 10; i++) {System.out.println(r.nextInt(100));}// 51, 80, 41, 28, 55...}
}

前面我们使用的Math.random()实际上内部调用了Random类，所以它也是伪随机数，只是我们无法指定种子。

SecureRandom

有伪随机数，就有真随机数。实际上真正的真随机数只能通过量子力学原理来获取，而我们想要的是一个不可预测的安全的随机数，SecureRandom就是用来创建安全的随机数的：

SecureRandom sr = new SecureRandom();
System.out.println(sr.nextInt(100));

SecureRandom无法指定种子，它使用RNG（random number generator）算法。JDK的SecureRandom实际上有多种不同的底层实现，有的使用安全随机种子加上伪随机数算法来产生安全的随机数，有的使用真正的随机数生成器。实际使用的时候，可以优先获取高强度的安全随机数生成器，如果没有提供，再使用普通等级的安全随机数生成器：

import java.util.Arrays;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
public class Main {public static void main(String[] args) {SecureRandom sr = null;try {sr = SecureRandom.getInstanceStrong(); // 获取高强度安全随机数生成器} catch (NoSuchAlgorithmException e) {sr = new SecureRandom(); // 获取普通的安全随机数生成器}byte[] buffer = new byte[16];sr.nextBytes(buffer); // 用安全随机数填充bufferSystem.out.println(Arrays.toString(buffer));}
}

SecureRandom的安全性是通过操作系统提供的安全的随机种子来生成随机数。这个种子是通过CPU的热噪声、读写磁盘的字节、网络流量等各种随机事件产生的“熵”。

在密码学中，安全的随机数非常重要。如果使用不安全的伪随机数，所有加密体系都将被攻破。因此，时刻牢记必须使用SecureRandom来产生安全的随机数。

需要使用安全随机数的时候，必须使用SecureRandom，绝不能使用Random！

Java提供的常用工具类有：

Math：数学计算
Random：生成伪随机数
SecureRandom：生成安全的随机数

集合常用工具类

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;public class CollectionsTest {public static void main(String[] args) {List<Integer> list = new ArrayList<Integer>();list.add(12);list.add(-15);list.add(7);list.add(4);list.add(35);list.add(9);System.out.println("源列表：" + list);// 最大值System.out.println("最大值：" + Collections.max(list));// 最小值System.out.println("最小值：" + Collections.min(list));// 替换Collections.replaceAll(list, -15, 12);System.out.println("-15替换12：" + list);// 出现次数System.out.println("12出现次数：" + Collections.frequency(list, 12));// 排序（自然顺序）Collections.sort(list);System.out.println("自然序：" + list);// 逆序Collections.reverse(list);System.out.println("逆序：" + list);// 随机排序Collections.shuffle(list);System.out.println("随机序：" + list);// 定制排序的用法，将int类型转成string进行比较Collections.sort(list, new Comparator<Object>() {@Overridepublic int compare(Object o1, Object o2) {String str1 = String.valueOf(o1);String str2 = String.valueOf(o2);return str1.compareTo(str2);}});System.out.println("定制序：" + list);// 根据指定的距离轮换指定列表中的元素。即旋转，当distance为正数时，将list后distance个元素整体移到前面；当distance为负数时，将list的前distance个元素整体移到后面。Collections.rotate(list, 3);System.out.println("旋转3：" + list);Collections.rotate(list, -3);System.out.println("旋转-3：" + list);Collections.sort(list);      // 二分查找System.out.println("-15下标：" + Collections.binarySearch(list, -15));System.out.println("7下标：" + Collections.binarySearch(list, 7));System.out.println("35下标：" + Collections.binarySearch(list, 35));//copy(List m,List n)方法的使用(含义：将集合n中的元素全部复制到m中,并且覆盖相应索引的元素)。List m = Arrays.asList("one two three four five six siven".split(" "));Collections.swap(m, 2, 3);System.out.println(m);List n = Arrays.asList("我 是 复制过来的哈".split(" "));Collections.copy(m,n);System.out.println(m);Collections.fill(m, "啊啊啊");System.out.println(m);}}

数组常用工具类

Arrays工具类提供了一个方法asList, 使用该方法可以将一个变长参数或者数组转换成List 。但是，生成的List的长度是固定的；能够进行修改操作（比如，修改某个位置的元素）；不能执行影响长度的操作（如add、remove等操作），否则会抛出UnsupportedOperationException异常。

所以 Arrays.asList 比较适合那些已经有数组数据或者一些元素，而需要快速构建一个List，只用于读取操作，而不进行添加或删除操作的场景。

copyOf

拷贝数组元素。底层采用 System.arraycopy() 实现，这是一个native方法。

  public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);

　src:源数组

　　srcPos:源数组要复制的起始位置

　　dest:目的数组

　　destPos:目的数组放置的起始位置

　　length:复制的长度

　　注意：src 和 dest都必须是同类型或者可以进行转换类型的数组。

int[] num1 = {1,2,3};
int[] num2 = new int[3];
System.arraycopy(num1, 0, num2, 0, num1.length);
System.out.println(Arrays.toString(num2));//[1, 2, 3]

    /*** @param original 源数组* @param newLength //返回新数组的长度* @return*/public static int[] copyOf(int[] original, int newLength) {int[] copy = new int[newLength];System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;}

deepEquals

是用来比较两个数组的元素是否相等，不过 deepEquals 能够进行比较多维数组，而且是任意层次的嵌套数组。

         String[][] name1 = {{ "G","a","o" },{ "H","u","a","n"},{ "j","i","e"}};  String[][] name2 = {{ "G","a","o" },{ "H","u","a","n"},{ "j","i","e"}};System.out.println(Arrays.equals(name1,name2));// false  System.out.println(Arrays.deepEquals(name1,name2));// true

fill

该系列方法用于给数组赋值，并能指定某个范围赋值。

    //给a数组所有元素赋值 valpublic static void fill(int[] a, int val) {for (int i = 0, len = a.length; i < len; i++)a[i] = val;}//给从 fromIndex 开始的下标，toIndex-1结尾的下标都赋值 val,左闭右开public static void fill(int[] a, int fromIndex, int toIndex, int val) {rangeCheck(a.length, fromIndex, toIndex);//判断范围是否合理for (int i = fromIndex; i < toIndex; i++)a[i] = val;}

toString 用来打印一维数组的元素

     public static String toString(int[] a) {if (a == null)return "null";int iMax = a.length - 1;if (iMax == -1)return "[]";StringBuilder b = new StringBuilder();b.append('[');for (int i = 0; ; i++) {b.append(a[i]);if (i == iMax)return b.append(']').toString();b.append(", ");}}

Object常用工具类

　　Object 类属于 java.lang 包，此包下的所有类在使用时无需手动导入，系统会在程序编译期间自动导入。Object 类是所有类的基类，当一个类没有直接继承某个类时，默认继承Object类，也就是说任何类都直接或间接继承此类，Object 类中能访问的方法在所有类中都可以调用，下面我们会分别介绍Object 类中的所有方法。

　　Object类在JAVA里面是一个比较特殊的类，JAVA只支持单继承，子类只能从一个父类来继承，如果父类又是从另外一个父类继承过来，那他也只能有一个父类，父类再有父类，那也只能有一个，JAVA为了组织这个类组织得比较方便，它提供了一个最根上的类，相当于所有的类都是从这个类继承，这个类就叫Object。所以Object类是所有JAVA类的根基类，是所有JAVA类的老祖宗。所有的类，不管是谁，都是从它继承下来的。

　　我们知道类构造器是创建Java对象的途径之一，通过new 关键字调用构造器完成对象的实例化，还能通过构造器对对象进行相应的初始化。一个类必须要有一个构造器的存在，如果没有显示声明，那么系统会默认创造一个无参构造器，在JDK的Object类源码中，是看不到构造器的，系统会自动添加一个无参构造器。我们可以通过：

Object obj = new Object()；构造一个Object类的对象。

equals() 方法

Cat c1 = new Cat(1,1,1);

Cat c2 = new Cat(1,1,1);

执行完之后内存之中的布局如下图所示，

　　c1指向一个对象，c2也指向一个对象，c1和c2里面装着的是这两只Cat对象在堆内存里面存储的地址，由于这两只Cat对象分别位于不同的存储空间，因此c1和c2里面装着的地址肯定不相等，因此c1和c2这两个引用对象也肯定不相等。因此执行：“System.out.println(c1==c2);”打印出来的结果肯定是false。因此你new出来了两个对象，你放心，这两个对象的引用永远不一样，一样的话就会把其中一个给覆盖掉了，这个可不成。c1是不是等于c2比较的是c1和c2这两个引用里面装着的内容，因为new出来的两个对象的它们的引用永远不一样，因此c1和c2这两个引用的内容也永远不一样，因此c1永远不可能等于c2。因此通过比较两个对象的引用是永远无法使得两个对象相等的，一模一样的。

　　要想判断两个对象是否相等，不能通过比较两个对象的引用是否相等，这是永远都得不到相等的结果的，因为两个对象的引用永远不会相等，所以正确的比较方法是直接比较这两个对象，比较这两个对象的实质是不是一样的，即这两个对象里面的内容是不是相同的，通过比较这两个对象的属性值是否相同而决定这两个对象是否相等。

　　Object类提供了一个equals()方法来比较两个对象的内容是否相同，因此我们可以采用这个方法去比较两个对象是否在逻辑上“相等”。如：c1.equals(c2);这里是调用从Object类继承下来的equals()方法，通过查阅API文档得到Object类里的equals方法的定义如下：

public boolean equals(Object obj)

　　在Object这个类里面提供的Equals()方法默认的实现是比较当前对象的引用和你要比较的那个引用它们指向的是否是同一个对象，即和“c1==c2”这种写法是一样的，“c1.equals(c2)”与“c1==c2”是完全等价的。因此直接使用继承下来的equals()方法也是无法直接比较两个对象的内容是否相同的，为此，我们必须得重写equals()方法，改变这个方法默认的实现。

== 运算符用于比较基本类型的值是否相同，或者比较两个对象的引用是否相等，而 equals 用于比较两个对象是否相等，这样说可能比较宽泛，两个对象如何才是相等的呢？这个标尺该如何定？

    public boolean equals(Object obj) {return (this == obj);}

　　可以看到，在 Object 类中，== 运算符和 equals 方法是等价的，都是比较两个对象的引用是否相等，从另一方面来讲，如果两个对象的引用相等，那么这两个对象一定是相等的。对于我们自定义的一个对象，如果不重写 equals 方法，那么在比较对象的时候就是调用 Object 类的 equals 方法，也就是用 == 运算符比较两个对象。

下面在Cat类里面重写这个继承下来的equals()方法：

 class Cat {int color, weight, height;public Cat(int color, int weight, int height) {this.color = color;this.weight = weight;this.height = height;}/*** 这里是重写相等从Object类继承下来的equals()方法，改变这个方法默认的实现，* 通过我们自己定义的实现来判断决定两个对象在逻辑上是否相等。* 这里我们定义如果两只猫的color，weight，height都相同，* 那么我们就认为这两只猫在逻辑上是一模一样的，即这两只猫是“相等”的。*/public boolean equals(Object obj){if (obj==null){return false;}else{/*** instanceof是对象运算符。* 对象运算符用来测定一个对象是否属于某个指定类或指定的子类的实例。* 对象运算符是一个组合单词instanceof。* 该运算符是一个双目运算符，其左边的表达式是一个对象，右边的表达式是一个类，* 如果左边的对象是右边的类创建的对象，则运算结果为true，否则为false。*/if (obj instanceof Cat){Cat c = (Cat)obj;if (c.color==this.color && c.weight==this.weight && c.height==this.height){return true;}}}return false;}}

此时在再main方法里面执行打印的命令：

 public static void main(String[] args) {/*** 这里使用构造方法Cat()在堆内存里面new出了两只猫，* 这两只猫的color，weight，height都是一样的，* 但c1和c2却永远不会相等，这是因为c1和c2分别为堆内存里面两只猫的引用对象，* 里面装着可以找到这两只猫的地址，但由于两只猫在堆内存里面存储在两个不同的空间里面，* 所以c1和c2分别装着不同的地址，因此c1和c2永远不会相等。*/Cat c1 = new Cat(1, 1, 1);Cat c2 = new Cat(1, 1, 1);System.out.println("c1==c2的结果是："+(c1==c2));//falseSystem.out.println("c1.equals(c2)的结果是："+c1.equals(c2));//true}

　在Java规范中，对 equals 方法的使用必须遵循以下几个原则：

　　①、自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。

　　②、对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。

　　③、传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。

　　④、一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改

　　⑤、对于任何非空引用值 x，x.equals(null) 都应返回 false。

getClass()方法

class 是一个类的属性，能获取该类编译时的类对象，而 getClass() 是一个类的方法，它是获取该类运行时的类对象。

public class Son extends Parent{}

@Test
public void testClass(){Parent p = new Son();System.out.println(p.getClass());System.out.println(Parent.class);
}

打印结果：

还有一个需要大家注意的是，虽然Object类中getClass() 方法声明是：public final native Class<?> getClass();返回的是一个 Class<?>，但是如下是能通过编译的：

Class<? extends String> c = "".getClass();

也就是说类型为T的变量getClass方法的返回值类型其实是Class<? extends T>而非getClass方法声明中的Class<?>。

什么时候使用 instanceof 运算符，什么时候使用 getClass() 有如下建议：

　　①、如果子类能够拥有自己的相等概念，则对称性需求将强制采用 getClass 进行检测。

　　②、如果有超类决定相等的概念，那么就可以使用 instanceof 进行检测，这样可以在不同的子类的对象之间进行相等的比较。

hashCode() 方法

在Java 中有几种集合类，比如 List,Set，还有 Map，List集合一般是存放的元素是有序可重复的，Set 存放的元素则是无序不可重复的，而 Map 集合存放的是键值对。

　　前面我们说过判断一个元素是否相等可以通过 equals 方法，没增加一个元素，那么我们就通过 equals 方法判断集合中的每一个元素是否重复，但是如果集合中有10000个元素了，但我们新加入一个元素时，那就需要进行10000次equals方法的调用，这显然效率很低。

　　于是，Java 的集合设计者就采用了 哈希表 来实现。

哈希算法也称为散列算法，是将数据依特定算法产生的结果直接指定到一个地址上。这个结果就是由 hashCode 方法产生。这样一来，当集合要添加新的元素时，先调用这个元素的 hashCode 方法，就一下子能定位到它应该放置的物理位置上。

　　①、如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；

　　②、如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了；

　　③、不相同的话，也就是发生了Hash key相同导致冲突的情况，那么就在这个Hash key的地方产生一个链表，将所有产生相同HashCode的对象放到这个单链表上去，串在一起（很少出现）。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

　这里有 A,B,C,D四个对象，分别通过 hashCode 方法产生了三个值，注意 A 和 B 对象调用 hashCode 产生的值是相同的，即 A.hashCode() = B.hashCode() = 0x001,发生了哈希冲突，这时候由于最先是插入了 A，在插入的B的时候，我们发现 B 是要插入到 A 所在的位置，而 A 已经插入了，这时候就通过调用 equals 方法判断 A 和 B 是否相同，如果相同就不插入 B，如果不同则将 B 插入到 A 后面的位置。

　　一、hashCode 要求

　　①、在程序运行时期间，只要对象的（字段的）变化不会影响equals方法的决策结果，那么，在这个期间，无论调用多少次hashCode，都必须返回同一个散列码。

　　②、通过equals调用返回true 的2个对象的hashCode一定一样。

　　③、通过equasl返回false 的2个对象的散列码不需要不同，也就是他们的hashCode方法的返回值允许出现相同的情况。

　　因此我们可以得到如下推论：

　　两个对象相等，其 hashCode 一定相同;

　　两个对象不相等，其 hashCode 有可能相同;

　　hashCode 相同的两个对象，不一定相等;

　　hashCode 不相同的两个对象，一定不相等;

　　这四个推论通过上图可以更好的理解。

　　二、hashCode 编写指导：

　　①、不同对象的hash码应该尽量不同，避免hash冲突，也就是算法获得的元素要尽量均匀分布。

　　②、hash 值是一个 int 类型，在Java中占用 4 个字节，也就是 232 次方，要避免溢出。

　　在 JDK 的 Integer类，Float 类，String 类等都重写了 hashCode 方法，我们自定义对象也可以参考这些类来写。

对于 Map 集合，我们可以选取Java中的基本类型，还有引用类型 String 作为 key，因为它们都按照规范重写了 equals 方法和 hashCode 方法。但是如果你用自定义对象作为 key，那么一定要覆写 equals 方法和 hashCode 方法，不然会有意想不到的错误产生。　　

toString() 方法

　　一个字符串和另外一种类型连接的时候，另外一种类型会自动转换成String类型，然后再和字符串连接。基础的数据类型int，float，double转换成字符串比较简单，按照它们的数字转换过来就成了，可以引用类型呢，Person p = new Person();一个字符串加上这个p，你就不知道要怎么把这个p转换成字符串了，因为这个p是一个引用类型。

    public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}

　getClass().getName()是返回对象的全类名（包含包名）,Integer.toHexString(hashCode()) 是以16进制无符号整数形式返回此哈希码的字符串表示形式。

　　打印某个对象时，默认是调用 toString 方法，比如 System.out.println(person),等价于 System.out.println(person.toString())

 public class TestToString {public static void main(String[] args) {Dog d = new Dog();/*** 如果没有重写toString方法，那么输出来的默认的字符串内容是“类名+哈希编码”,* 如：dog=cn.galc.test.Dog@150bd4d* 这里的d就是一个引用类型，打印的时候，这个引用类型d会自动调用toString()方法将自己转换成字符串然后再与字符串”d:=”相连，* 然后一起被打印出来。d为什么可以自动调用toString()方法呢，Dog类里面也没有声明这个toString()方法。* 这是因为toString()方法是Object类里面的方法，而所有的类都是从Object类继承下来的，* Dog类当然也不例外，所以Dog类继承了Object类里面的toString()方法，* 所以Dog类的对象当然可以直接调用toString()方法了。* 但是Dog类对继承下来的toString()方法很不满意，* 因为使用这个继续下来toString()方法将引用对象转换成字符串输出时输出的是一连串令人看不懂的哈希编码。* 为了使打印出来的信息使得正常人都能看得懂，因此要在Dog类里面把这个继承下来的toString()方法重写，* 使得调用这个toString()方法将引用对象转换成字符串时打印出来的是一些正常的，能看得懂的信息。* 在子类重写从父类继承下来的方法时，从父类把要重写的方法的声明直接copy到子类里面来，* 这样在子类里面重写的时候就不会出错了。*/System.out.println("dog="+d);//打印结果：dog=I’m a cool Dog}}class Dog{/*** 在这里重写了Object类里面的toString()方法后，* 引用对象自动调用时调用的就是重写后的toString()方法了，* 此时打印出来的显示信息就是我们重写toString()方法时要返回的字符串信息了，* 不再是那些看不懂的哈希编码了。*/public String toString() {return "I’m a cool Dog";}}

　任何一个类都是从Object类继承下来的，因此在任何一个类里面都可以重写这个toString()方法。toString()方法的作用是当一个引用对象和字符串作连接的时候，或者是直接打印这个引用对象的时侯，这个引用对象都会自动调用toString()方法，通过这个方法返回一个表示引用对象自己正常信息的字符串，而这个字符串的内容由我们自己去定义，默认的字符串内容是“类名+哈希编码”。因此我们可以通过在类里面重写toString()方法，把默认的字符串内容改成我们自己想要表达的正常信息的字符串内容。

创建对象的5种方式

　　①、通过 new 关键字

　　这是最常用的一种方式，通过 new 关键字调用类的有参或无参构造方法来创建对象。比如 Object obj = new Object();

　　②、通过 Class 类的 newInstance() 方法

　　这种默认是调用类的无参构造方法创建对象。比如 Person p2 = (Person) Class.forName("com.ys.test.Person").newInstance();

　　③、通过 Constructor 类的 newInstance 方法

　　这和第二种方法类时，都是通过反射来实现。通过 java.lang.relect.Constructor 类的 newInstance() 方法指定某个构造器来创建对象。

　　Person p3 = (Person) Person.class.getConstructors()[0].newInstance();

　　实际上第二种方法利用 Class 的 newInstance() 方法创建对象，其内部调用还是 Constructor 的 newInstance() 方法。

　　④、利用 Clone 方法

　　Clone 是 Object 类中的一个方法，通过对象A.clone() 方法会创建一个内容和对象 A 一模一样的对象 B，clone 克隆，顾名思义就是创建一个一模一样的对象出来。

　　Person p4 = (Person) p3.clone();

　　⑤、反序列化

　　序列化是把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。而反序列化则是把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。

clone()方法

clone方法的作用就是复制对象，产生一个新的对象，那么这个新的对象和原对象是什么关系。

Java 中基本类型和引用类型的区别，基本类型也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double，引用类型则包括类、接口、数组、枚举等。

　　Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。

　　上图定义的 a 和 b 都是基本类型，其值是直接存放在栈中的；而 c 和 d 是 String 声明的，这是一个引用类型，引用地址是存放在栈中，然后指向堆的内存空间。

　　下面 d = c；这条语句表示将 c 的引用赋值给 d，那么 c 和 d 将指向同一块堆内存空间。

public class Person implements Cloneable{public String pname;public int page;public Address address;public Person() {}public Person(String pname,int page){this.pname = pname;this.page = page;this.address = new Address();}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}}

这是一个我们要进行赋值的原始类 Person。下面我们产生一个 Person 对象，并调用其 clone 方法复制一个新的对象。

注意：调用对象的 clone 方法，必须要让类实现 Cloneable 接口，并且覆写 clone 方法。

Object 类提供的 clone 是只能实现浅拷贝的。

@Test
public void testShallowClone() throws Exception{Person p1 = new Person("zhangsan",21);p1.setAddress("湖北省", "武汉市");Person p2 = (Person) p1.clone();System.out.println("p1:"+p1);System.out.println("p1.getPname:"+p1.getPname().hashCode());System.out.println("p2:"+p2);System.out.println("p2.getPname:"+p2.getPname().hashCode());p1.display("p1");p2.display("p2");p2.setAddress("湖北省", "荆州市");System.out.println("将复制之后的对象地址修改：");p1.display("p1");p2.display("p2");
}

　打印结果为：

　　首先看原始类 Person 实现 Cloneable 接口，并且覆写 clone 方法,它还有三个属性，一个引用类型 String定义的 pname，一个基本类型 int定义的 page，还有一个引用类型 Address ，这是一个自定义类，这个类也包含两个属性 pprovices 和 city 。

　　接着看测试内容，首先我们创建一个Person 类的对象 p1，其pname 为zhangsan,page为21，地址类 Address 两个属性为湖北省和武汉市。接着我们调用 clone() 方法复制另一个对象 p2，接着打印这两个对象的内容。

　　从第 1 行和第 3 行打印结果:

　　p1:com.ys.test.Person@349319f9

　　p2:com.ys.test.Person@258e4566

　　可以看出这是两个不同的对象。

　　从第 5 行和第 6 行打印的对象内容看，原对象 p1 和克隆出来的对象 p2 内容完全相同。

　　代码中我们只是更改了克隆对象 p2 的属性 Address 为湖北省荆州市（原对象 p1 是湖北省武汉市），但是从第 7 行和第 8 行打印结果来看，原对象 p1 和克隆对象 p2 的 Address 属性都被修改了。

　　也就是说对象 Person 的属性 Address，经过 clone 之后，其实只是复制了其引用，他们指向的还是同一块堆内存空间，当修改其中一个对象的属性 Address，另一个也会跟着变化。

　　浅拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。

　深拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都复制独立的一份。当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。

如何实现深拷贝

　　①、让每个引用类型属性内部都重写clone() 方法

　　既然引用类型不能实现深拷贝，那么我们将每个引用类型都拆分为基本类型，分别进行浅拷贝。比如上面的例子，Person 类有一个引用类型 Address(其实String 也是引用类型，但是String类型有点特殊，我们在 Address 类内部也重写 clone 方法。如下：

 public class Address implements Cloneable{private String provices;private String city;public void setAddress(String provices,String city){this.provices = provices;this.city = city;}@Overridepublic String toString() {return "Address [provices=" + provices + ", city=" + city + "]";}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}}

Person.class 的 clone() 方法：

     @Overrideprotected Object clone() throws CloneNotSupportedException {Person p = (Person) super.clone();p.address = (Address) address.clone();return p;}

　测试还是和上面一样，我们会发现更改了p2对象的Address属性，p1 对象的 Address 属性并没有变化。

　　但是这种做法有个弊端，这里我们Person 类只有一个 Address 引用类型，而 Address 类没有，所以我们只用重写 Address 类的clone 方法，但是如果 Address 类也存在一个引用类型，那么我们也要重写其clone 方法，这样下去，有多少个引用类型，我们就要重写多少次，如果存在很多引用类型，那么代码量显然会很大，所以这种方法不太合适。

　　②、利用序列化

　　序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。

　　注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

//深度拷贝
public Object deepClone() throws Exception{// 序列化ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bos);oos.writeObject(this);// 反序列化ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());ObjectInputStream ois = new ObjectInputStream(bis);return ois.readObject();
}

因为序列化产生的是两个完全独立的对象，所有无论嵌套多少个引用类型，序列化都是能实现深拷贝的。

String常用工具类

String s=null;//null是未分配堆内存空间
String a;//分配了一个内存空间,没存入任何对象
String a="";//分配了一个内存空间,存了一个字符串对象

常用方法

public class StringTest {
public static void main(String[] args) {String str1 = new String();System.out.println(str1);String str2 = new String("asdf");System.out.println(str2);char[] value = {'a','b','c','d'};String str3 = new String(value);System.out.println(str3);String str4 = new String(value, 1, 2);System.out.println(str4);byte[] strb = new byte[]{65,66};String str5 = new String(strb);System.out.println(str5);String str = new String("asdfzxc");int strlength = str.length();System.out.println(strlength);char ch = str.charAt(4);//ch = zSystem.out.println(ch);//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回String str6 = str.substring(2);//str2 = "dfzxc"System.out.println(str6);//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。String str7 = str.substring(2,5);//str3 = "dfz"System.out.println(str7);String str8 = new String("abc");String str9 = new String("ABC");int a = str8.compareTo(str9);//a>0int b = str8.compareToIgnoreCase(str9);//b=0boolean c = str8.equals(str9);//c=falseboolean d = str8.equalsIgnoreCase(str9);//d=true//相当于String str = "aa"+"bb"+"cc";String str10 = "aa".concat("bb").concat("cc");System.out.println(str10);String str11 = "I am a good student";//于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。int aa = str11.indexOf('a');//a = 2int bb = str11.indexOf("good");//b = 7//从fromIndex位置向后查找。int cc = str11.indexOf("w",2);//c = -1//区别在于该方法从字符串的末尾位置向前查找。int dd = str11.lastIndexOf("a");//d = 5int ee = str11.lastIndexOf("a",3);//e = 2String str00 = new String("asDF");String str111 = str00.toLowerCase();//str1 = "asdf"System.out.println(str111);String str222 = str00.toUpperCase();//str2 = "ASDF"System.out.println(str222);String str0 = "asdzxcasd";String str100 = str0.replace('a','g');//str1 = "gsdzxcgsd"String str200 = str0.replace("asd","fgh");//str2 = "fghzxcfgh"String str300 = str0.replaceFirst("asd","fgh");//str3 = "fghzxcasd"String str400 = str0.replaceAll("asd","fgh");//str4 = "fghzxcfgh"//另一种是通过正则表达式替换：String s = "A,,B;C ,D";s.replaceAll("[\\,\\;\\s]+", ","); // "A,B,C,D"String str33 = " a sd ";//使用trim()方法可以移除字符串首尾空白字符。空白字符包括空格，\t，\r，\nString str13 = str33.trim();System.out.println(str13);//另一个strip()方法也可以移除字符串首尾空白字符。它和trim()不同的是，类似中文的空格字符\u3000也会被移除："\u3000Hello\u3000".strip(); // "Hello"" Hello ".stripLeading(); // "Hello "" Hello ".stripTrailing(); // " Hello"//String还提供了isEmpty()和isBlank()来判断字符串是否为空和空白字符串："".isEmpty(); // true，因为字符串长度为0"  ".isEmpty(); // false，因为字符串长度不为0"  \n".isBlank(); // true，因为只包含空白字符" Hello ".isBlank(); // false，因为包含非空白字符String strR = "asdfgh";boolean aA = strR.startsWith("as");//a = trueSystem.out.println(aA);boolean bB = strR.endsWith("gh");//b = trueSystem.out.println(bB);String strC = "student";System.out.println(strC.contains("stu"));//trueSystem.out.println(strC.contains("ok"));//falseString strS = "asd!qwe|zxc#";String[] strss = str.split("!|#");//str1[0] = "asd";str1[1] = "qwe";str1[2] = "zxc";System.out.println(strss.toString()); //拼接字符串使用静态方法join()，它用指定的字符串连接字符串数组：String[] arr = {"A", "B", "C"};String s = String.join("***", arr); // "A***B***C"//字符串转换为基本类型int n = Integer.parseInt("12");System.out.println(n);float f = Float.parseFloat("12.34");System.out.println(f);double D = Double.parseDouble("1.124");System.out.println(D);//基本类型转换为字符串类型String s111 = String.valueOf(12);System.out.println(s111);String s122 = String.valueOf(12.34);System.out.println(s122);//要把字符串转换为其他类型，就需要根据情况。例如，把字符串转换为int类型：int n1 = Integer.parseInt("123"); // 123int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255//要特别注意，Integer有个getInteger(String)方法，它不是将字符串转换为int，而是把该字符串对应的系统变量转换为Integer：Integer.getInteger("java.version"); // 版本号，11//进制转换String binaryString = Long.toBinaryString(7);System.out.println(binaryString);//转换为char[]String和char[]类型可以互相转换，方法是：char[] cs = "Hello".toCharArray(); // String -> char[]String s = new String(cs); // char[] -> String//如果修改了char[]数组，String并不会改变：public static void main(String[] args) {char[] cs = "Hello".toCharArray();String s = new String(cs);System.out.println(s);cs[0] = 'X';System.out.println(s);}
}这是因为通过new String(char[])创建新的String实例时，它并不会直接引用传入的char[]数组，而是会复制一份，所以，修改外部的char[]数组不会影响String实例内部的char[]数组，因为这是两个不同的数组。
从String的不变性设计可以看出，如果传入的对象有可能改变，我们需要复制而不是直接引用。

在Java中，String是一个引用类型，它本身也是一个class。但是，Java编译器对String有特殊处理，即可以直接用"..."来表示一个字符串：

String s1 = "Hello!";

实际上字符串在String内部是通过一个char[]数组表示的，因此，按下面的写法也是可以的：

String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});

因为String太常用了，所以Java提供了"..."这种字符串字面量表示方法。

Java字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的private final char[]字段，以及没有任何修改char[]的方法实现的。

常量池

两种声明一个字符串对象的形式有两种：

　　①、通过“字面量”的形式直接赋值

String str = "hello";

　　②、通过 new 关键字调用构造函数创建对象

String str = new String("hello");

JVM 的内存分布：

　　①、程序计数器：也称为 PC 寄存器，保存的是程序当前执行的指令的地址（也可以说保存下一条指令的所在存储单元的地址），当CPU需要执行指令时，需要从程序计数器中得到当前需要执行的指令所在存储单元的地址，然后根据得到的地址获取到指令，在得到指令之后，程序计数器便自动加1或者根据转移指针得到下一条指令的地址，如此循环，直至执行完所有的指令。

　　②、虚拟机栈：基本数据类型、对象的引用都存放在这。线程私有。

　　③、本地方法栈：虚拟机栈是为执行Java方法服务的，而本地方法栈则是为执行本地方法（Native Method）服务的。在JVM规范中，并没有对本地方法栈的具体实现方法以及数据结构作强制规定，虚拟机可以自由实现它。在HotSopt虚拟机中直接就把本地方法栈和虚拟机栈合二为一。

　　④、方法区：存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。注意：在Class文件中除了类的字段、方法、接口等描述信息外，还有一项信息是常量池，用来存储编译期间生成的字面量和符号引用。

　　⑤、堆：用来存储对象本身的以及数组（当然，数组引用是存放在Java栈中的）。

在 JDK1.7 以后，方法区的常量池被移除放到堆中了，如下：

　　常量池：Java运行时会维护一个String Pool（String池），也叫“字符串缓冲区”。String池用来存放运行时中产生的各种字符串，并且池中的字符串的内容不重复。

　　①、字面量创建字符串或者纯字符串（常量）拼接字符串会先在字符串池中找，看是否有相等的对象，没有的话就在字符串池创建该对象；有的话则直接用池中的引用，避免重复创建对象。

　　②、new关键字创建时，直接在堆中创建一个新对象，变量所引用的都是这个新对象的地址，但是如果通过new关键字创建的字符串内容在常量池中存在了，那么会由堆在指向常量池的对应字符；但是反过来，如果通过new关键字创建的字符串对象在常量池中没有，那么通过new关键词创建的字符串对象是不会额外在常量池中维护的。

　　③、使用包含变量表达式来创建String对象，则不仅会检查维护字符串池，还会在堆区创建这个对象，最后是指向堆内存的对象。

 String str1 = "hello";String str2 = "hello";String str3 = new String("hello");System.out.println(str1==str2);//trueSystem.out.println(str1==str3);//fasleSystem.out.println(str2==str3);//fasleSystem.out.println(str1.equals(str2));//trueSystem.out.println(str1.equals(str3));//trueSystem.out.println(str2.equals(str3));//true

　　对于上面的情况，首先 String str1 = "hello"，会先到常量池中检查是否有“hello”的存在，发现是没有的，于是在常量池中创建“hello”对象，并将常量池中的引用赋值给str1；第二个字面量 String str2 = "hello"，在常量池中检测到该对象了，直接将引用赋值给str2；第三个是通过new关键字创建的对象，常量池中有了该对象了，不用在常量池中创建，然后在堆中创建该对象后，将堆中对象的引用赋值给str3，再将该对象指向常量池。

红色的箭头，通过 new 关键字创建的字符串对象，如果常量池中存在了，会将堆中创建的对象指向常量池的引用。

 String str1 = "hello";String str2 = "helloworld";String str3 = str1+"world";//编译器不能确定为常量(会在堆区创建一个String对象)String str4 = "hello"+"world";//编译器确定为常量，直接到常量池中引用System.out.println(str2==str3);//fasleSystem.out.println(str2==str4);//trueSystem.out.println(str3==str4);//fasle

　　str3 由于含有变量str1，编译器不能确定是常量，会在堆区中创建一个String对象。而str4是两个常量相加，直接引用常量池中的对象即可。

String作为参数的传递

参数为基本类型时是值传递，参数为封装类型时是引用传递。

public class Test {public static void main(String[] args) {String str = "ab";changeString(str);System.out.println("str="+str);}private static void changeString(String str) {str = "cd";}
}

大家猜一下运行结果是什么呢？按照前面的例子，String应该是一个封装类型，它应该是引用传递，是可以改变值得，运行的结果应该是”cd”。我们实际运行一下看看，

str=ab,这如何解释呢？难道String是基本类型？也说不通呀。

这就要从java底层的机制讲起了，java的内存模型分为堆和栈。

1.基本类型的变量放在栈里； 2.封装类型中，对象放在堆里，对象的引用放在栈里。

java在方法传递参数时，是将变量复制一份，然后传入方法体去执行。这句话是很难理解的，也是解释这个问题的精髓。我们先按照这句话解释一下基本类型的传递

虚拟机分配给num一个内存地址，并且存了一个值0.
虚拟机复制了一个num，我们叫他num’，num’和num的内存地址不同，但存的值都是0。
虚拟机讲num’传入方法，方法将num’的值改为1.
方法结束，方法外打印num的值，由于num内存中的值没有改变，还是0，所以打印是0.

我们再解释封装类型的传递：

虚拟机在堆中开辟了一个Product的内存空间，内存中包含proName和num。
虚拟机在栈中分配给p一个内存地址，这个地址中存的是1中的Product的内存地址。
虚拟机复制了一个p，我们叫他p’,p和p’的内存地址不同，但它们存的值是相同的，都是1中Product的内存地址。
将p’传入方法，方法改变了1中的proName和num。
方法结束，方法外打印p中变量的值，由于p和p’中存的都是1中Product的地址，但是1中Product里的值发生了改变，所以，方法外打印p的值，是方法执行以后的。我们看到的效果是封装类型的值是改变的。

最后我们再来解释String在传递过程中的步骤：

虚拟机在堆中开辟一块内存，并存值”ab”。
虚拟机在栈中分配给str一个内存，内存中存的是1中的地址。
虚拟机复制一份str，我们叫str’，str和str’内存不同，但存的值都是1的地址。
将str’传入方法体
方法体在堆中开辟一块内存，并存值”cd”
方法体将str’的值改变，存入5的内存地址
方法结束，方法外打印str，由于str存的是1的地址，所有打印结果是”ab”

这样我们理解了java在方法传参的整个过程。其实还是上面那句比较重要的话。 java在方法传递参数时，是将变量复制一份，然后传入方法体去执行。

三句话总结一下：

1.对象就是传引用

2.原始类型就是传值

3.String，Integer, Double等immutable类型因为没有提供自身修改的函数，每次操作都是新生成一个对象，所以要特殊对待。可以认为是传值。

Integer 和 String 一样。保存value的类变量是Final属性，无法被修改，只能被重新赋值／生成新的对象。当Integer 做为方法参数传递进方法内时，对其的赋值都会导致原Integer 的引用被指向了方法内的栈地址，失去了对原类变量地址的指向。对赋值后的Integer对象做得任何操作，都不会影响原来对象。

String的不可变性

不可变对象的创建一般满足5个原则：

1. 类添加final修饰符，保证类不被继承。
如果类可以被继承会破坏类的不可变性机制，只要继承类覆盖父类的方法并且继承类可以改变成员变量值，那么一旦子类以父类的形式出现时，不能保证当前类是否可变。

2. 保证所有成员变量必须私有，并且加上final修饰
通过这种方式保证成员变量不可改变。但只做到这一步还不够，因为如果是对象成员变量有可能再外部改变其值。所以第4点弥补这个不足。

3. 不提供改变成员变量的方法，包括setter
避免通过其他接口改变成员变量的值，破坏不可变特性。

4.通过构造器初始化所有成员，进行深拷贝(deep copy)

如果构造器传入的对象直接赋值给成员变量，还是可以通过对传入对象的修改进而导致改变内部变量的值。例如：

public final class ImmutableDemo {  private final int[] myArray;  public ImmutableDemo(int[] array) {  this.myArray = array; // wrong  }
}

这种方式不能保证不可变性，myArray和array指向同一块内存地址，用户可以在ImmutableDemo之外通过修改array对象的值来改变myArray内部的值。
为了保证内部的值不被修改，可以采用深度copy来创建一个新内存保存传入的值。正确做法：

public final class MyImmutableDemo {  private final int[] myArray;  public MyImmutableDemo(int[] array) {  this.myArray = array.clone();   }
}

5. 在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝
这种做法也是防止对象外泄，防止通过getter获得内部可变成员对象后对成员变量直接操作，导致成员变量发生改变。

public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence
{/** The value is used for character storage. */private final char value[];/** The offset is the first index of the storage that is used. */private final int offset;/** The count is the number of characters in the String. */private final int count;/** Cache the hash code for the string */private int hash; // Default to 0....public String(char value[]) {this.value = Arrays.copyOf(value, value.length); // deep copy操作}...public char[] toCharArray() {// Cannot use Arrays.copyOf because of class initialization order issueschar result[] = new char[value.length];System.arraycopy(value, 0, result, 0, value.length);return result;}...
}

可以观察到以下设计细节:

String类被final修饰，不可继承
string内部所有成员都设置为私有变量
不存在value的setter
并将value和offset设置为final。
当传入可变数组value[]时，进行copy而不是直接将value[]复制给内部变量.
获取value时不是直接返回对象引用，而是返回对象的copy.

这都符合上面总结的不变类型的特性，也保证了String类型是不可变的类。

String对象的不可变性的优缺点

1.字符串常量池的需要.
字符串常量池可以将一些字符常量放在常量池中重复使用，避免每次都重新创建相同的对象、节省存储空间。但如果字符串是可变的，此时相同内容的String还指向常量池的同一个内存空间，当某个变量改变了该内存的值时，其他遍历的值也会发生改变。所以不符合常量池设计的初衷。

2. 线程安全考虑。
同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。

3. 类加载器要用到字符串，不可变性提供了安全性，以便正确的类被加载。譬如你想加载java.sql.Connection类，而这个值被改成了myhacked.Connection，那么会对你的数据库造成不可知的破坏。

4. 支持hash映射和缓存。
因为字符串是不可变的，所以在它创建的时候hashcode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

缺点：

String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。

Java为了避免在一个系统中产生大量的String对象，引入了字符串常量池。

创建一个字符串时，首先会检查池中是否有值相同的字符串对象，如果有就直接返回引用，不会创建字符串对象；如果没有则新建字符串对象，返回对象引用，并且将新创建的对象放入池中。但是，通过new方法创建的String对象是不检查字符串常量池的，而是直接在堆中创建新对象，也不会把对象放入池中。上述原则只适用于直接给String对象引用赋值的情况。

String str1 = new String("a"); //不检查字符串常量池的

String str2 = "bb"; //检查字符串常量池的

String还提供了intern()方法。调用该方法时，如果字符串常量池中包括了一个等于此String对象的字符串（由equals方法确定），则返回池中的字符串的引用。否则，将此String对象添加到池中，并且返回此池中对象的引用。

在JDK6中，不推荐大量使用intern方法，因为这个版本字符串缓存在永久代中，这个空间是有限了，除了FullGC之外不会被清楚，所以大量的缓存在这容易OutOfMemoryError。

之后的版本把字符串放入了堆中，避免了永久代被挤满。

虽然String对象将value设置为final,并且还通过各种机制保证其成员变量不可改变。但是还是可以通过反射机制的手段改变其值。例如：

    //创建字符串"Hello World"， 并赋给引用sString s = "Hello World"; System.out.println("s = " + s); //Hello World//获取String类中的value字段Field valueFieldOfString = String.class.getDeclaredField("value");//改变value属性的访问权限valueFieldOfString.setAccessible(true);//获取s对象上的value属性的值char[] value = (char[]) valueFieldOfString.get(s);//改变value所引用的数组中的第5个字符value[5] = '_';System.out.println("s = " + s);  //Hello_World

打印结果为：

s = Hello World s = Hello_World

发现String的值已经发生了改变。也就是说，通过反射是可以修改所谓的“不可变”对象的

String,StringBuffer与StringBuilder的区别

String：对String类型的对象操作，等同于重新生成一个新对象，然后讲引用指向它；

StringBuffer：对StringBuffer类型的对象操作，操作的始终是同一个对象；

    public static void main(String[] args) {String str="123";str+="abc";System.out.println(str);}

public class TestStringBuffer {public static void main(String[] args) {StringBuffer sb=new StringBuffer("123");sb.append("abc");System.out.println(sb.toString());}
}

虽然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。

为了能高效拼接字符串，Java标准库提供了StringBuilder，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象：

StringBuffer里始终是一个对象；

总结下：假如定义的字符串内容基本不变或者很少变化，用String效率高；假如定义的字符串内容经常变动，要用StringBuffer；

      public static void main(String[] args) {//构造实例化StringBuffer strbu = new StringBuffer("hello world\t");char[] a = {'l','o','y','o','u'};//调用方法System.out.println(1+"\t"+strbu.append(true));            //append(boolean b);System.out.println(2+"\t"+strbu.append('a'));            //append(char b);System.out.println(3+"\t"+strbu.append(a));                //append(char[] b);System.out.println(4+"\t"+strbu.capacity());            //capacity();System.out.println(5+"\t"+strbu.charAt(10));            //charAt(int index);System.out.println(6+"\t"+strbu.delete(3, 9));            //delete(int start, int end);System.out.println(7+"\t"+strbu.insert(5, false));        //insert(int offset, boolean b);System.out.println(8+"\t"+strbu.substring(7));            //substring(int start)System.out.println(9+"\t"+strbu.reverse() );            //reverse()          }

运行结果

StringBuilder还可以进行链式操作：

public class Main {public static void main(String[] args) {var sb = new StringBuilder(1024);sb.append("Mr ").append("Bob").append("!").insert(0, "Hello, ");System.out.println(sb.toString());}
}

如果我们查看StringBuilder的源码，可以发现，进行链式操作的关键是，定义的append()方法会返回this，这样，就可以不断调用自身的其他方法。

仿照StringBuilder，我们也可以设计支持链式操作的类。例如，一个可以不断增加的计数器：

public class Main {public static void main(String[] args) {Adder adder = new Adder();adder.add(3).add(5).inc().add(10);System.out.println(adder.value());}
}class Adder {private int sum = 0;public Adder add(int n) {sum += n;return this;}public Adder inc() {sum ++;return this;}public int value() {return sum;}
}

注意：对于普通的字符串+操作，并不需要我们将其改写为StringBuilder，因为Java编译器在编译时就自动把多个连续的+操作编码为StringConcatFactory的操作。在运行期，StringConcatFactory会自动把字符串连接操作优化为数组复制或者StringBuilder操作。

你可能还听说过StringBuffer，这是Java早期的一个StringBuilder的线程安全版本，它通过同步来保证多个线程操作StringBuffer也是安全的，但是同步会带来执行速度的下降。

StringBuilder和StringBuffer接口完全相同，现在完全没有必要使用StringBuffer。

StringJoiner

要高效拼接字符串，应该使用StringBuilder。

很多时候，我们拼接的字符串像这样：

// Hello Bob, Alice, Grace!

public class Main {public static void main(String[] args) {String[] names = {"Bob", "Alice", "Grace"};var sb = new StringBuilder();sb.append("Hello ");for (String name : names) {sb.append(name).append(", ");}// 注意去掉最后的", ":sb.delete(sb.length() - 2, sb.length());sb.append("!");System.out.println(sb.toString());}
}

类似用分隔符拼接数组的需求很常见，所以Java标准库还提供了一个StringJoiner来干这个事：

import java.util.StringJoiner;
public class Main {public static void main(String[] args) {String[] names = {"Bob", "Alice", "Grace"};var sj = new StringJoiner(", ");for (String name : names) {sj.add(name);}System.out.println(sj.toString());}
}

慢着！用StringJoiner的结果少了前面的"Hello "和结尾的"!"！遇到这种情况，需要给StringJoiner指定“开头”和“结尾”：

public class Main {public static void main(String[] args) {String[] names = {"Bob", "Alice", "Grace"};var sj = new StringJoiner(", ", "Hello ", "!");for (String name : names) {sj.add(name);}System.out.println(sj.toString());}
}

那么StringJoiner内部是如何拼接字符串的呢？如果查看源码，可以发现，StringJoiner内部实际上就是使用了StringBuilder，所以拼接效率和StringBuilder几乎是一模一样的。

String.join()

String还提供了一个静态方法join()，这个方法在内部使用了StringJoiner来拼接字符串，在不需要指定“开头”和“结尾”的时候，用String.join()更方便：

String[] names = {"Bob", "Alice", "Grace"};
var s = String.join(", ", names);

String也是Immutable类的典型实现，拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。

初始String值为“hello”，然后在这个字符串后面加上新的字符串“world”，这个过程是需要重新在栈堆内存中开辟内存空间的，最终得到了“hello world”字符串也相应的需要开辟内存空间，这样短短的两个字符串，却需要开辟三次内存空间，不得不说这是对内存空间的极大浪费。为了应对经常性的字符串相关的操作，谷歌引入了两个新的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。

StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供append和add方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列，把所有修改数据的方法都加上了synchronized。但是保证了线程安全是需要性能的代价的，和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

在很多情况下我们的字符串拼接操作不需要线程安全，这时候StringBuilder登场了，StringBuilder是JDK1.5发布的，它和StringBuffer本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。

StringBuffer 和 StringBuilder 二者都继承了 AbstractStringBuilder ，底层都是利用可修改的char数组(JDK 9 以后是 byte数组)。

所以如果我们有大量的字符串拼接，如果能预知大小的话最好在new StringBuffer 或者StringBuilder 的时候设置好capacity，避免多次扩容的开销。扩容要抛弃原有数组，还要进行数组拷贝创建新的数组。

我们平日开发通常情况下少量的字符串拼接其实没太必要担心，例如

String str = "aa"+"bb"+"cc";

像这种没有变量的字符串，编译阶段就直接合成"aabbcc"了，然后看字符串常量池（下面会说到常量池）里有没有，有也直接引用，没有就在常量池中生成，返回引用。

如果是带变量的，其实影响也不大，JVM会帮我们优化了。

1、在字符串不经常发生变化的业务场景优先使用String(代码更清晰简洁)。如常量的声明，少量的字符串操作(拼接，删除等)。

2、在单线程情况下，如有大量的字符串操作情况，应该使用StringBuilder来操作字符串。不能使用String"+"来拼接而是使用，避免产生大量无用的中间对象，耗费空间且执行效率低下（新建对象、回收对象花费大量时间）。如JSON的封装等。

3、在多线程情况下，如有大量的字符串操作情况，应该使用StringBuffer。如HTTP参数解析和封装等。

字符编码

在早期的计算机系统中，为了给字符编码，美国国家标准学会（American National Standard Institute：ANSI）制定了一套英文字母、数字和常用符号的编码，它占用两个字节，编码范围从0到127，最高位始终为0，称为ASCII编码。例如，字符'A'的编码是0x41，字符'1'的编码是0x31。

如果要把汉字也纳入计算机编码，很显然一个字节是不够的。GB2132标准使用两个字节表示一个汉字，其中第一个字节的最高位始终为1，以便和ASCII编码区分开。例如，汉字'中'的GB2312编码是0xd6d0。

类似的，日文有Shift_JIS编码，韩文有EUC-KR编码，这些编码因为标准不统一，同时使用，就会产生冲突。

为了统一全球所有语言的编码，全球统一码联盟发布了Unicode编码，它把世界上主要语言都纳入同一个编码，这样，中文、日文、韩文和其他语言就不会冲突。

字符编码的发展历程

　　①、ASCII 码

　　因为计算机只认识数字，所以我们在计算机里面的一切数据都是以数字来表示，因为英文字符有限，所以规定使用的字节的最高位是 0，每一个字节都是以 0-127 之间的数字来表示。比如 A 对应 65，a 对应 97。这便是美国标准信息交换码，ASCII

String str = new String("Aa");
byte[] strASCII = str.getBytes("ASCII");
System.out.println(Arrays.toString(strASCII));//[65, 97]

　　②、GB2312 码

　　随着计算机在全球的普及，很多国家和地区都把自己的字符引入了计算机，比如汉字。此时发现一个字节能表示的数字范围太小，不能包含所有的中文汉字。那么就规定使用两个字节来表示一个汉字。

　　规定：原有的 ASCII 字符的编码保持不变，仍然使用一个字节表示，为了区别一个中文字符与两个 ASCII 码字符相区别。中文字符的每个字节最高位规定为 1（即中文的二进制是负数），这便是 GB2312 编码

String str = new String("Aa帅锅");
byte[] strASCII = str.getBytes("GB2312");
System.out.println(Arrays.toString(strASCII));//[65, 97, -53, -89, -71, -8]

　　③、GBK

　　由于中国汉字太多，在 GB2312 的基础上增加了更多的中文字符，这种编码是 GBK

问题：如果只是在中国，那么大家都认识汉字，但是如果是别的国家，而该国家的码表中是没有收录汉字的。那么计算机在显示的时候就为乱码或是别的字符

解决办法：为了解决各个国家因为本地化字符编码带来的影响，就把全世界所有的字符统一进行编码---Unicode 编码

　　此时某一个字符在全世界任何地方显示都是固定的，比如汉字哥，在任何地方都是以十六进制 54E5 来表示。

　 Unicode 的字符编码都占有两个字节

　　④、UTF-8

　　是一种针对 Unicode 的可变长度字符编码，又称为万国码，是 Unicode 的实现方式之一。编码中的第一个字节仍与 ASCII 兼容，这使得原来处理 ASCII 字符的软件无须或只需做少部分修改，即可继续使用。因此，它逐渐成为电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持 UTF-8 编码

String str = new String("Aa帅锅");
byte[] strASCII = str.getBytes("UTF-8");
System.out.println(Arrays.toString(strASCII));//[65, 97, -27, -72, -123, -23, -108, -123]

存储字母、数字：无论什么字符集都占有 1 个字节

存储汉字：GBK 家族占有 2 个字节。UTF-8 占有 3 个字节

　　　　不能使用单字节的字符集（ASCII/ISO-8859-1）来存储中文

Unicode编码需要两个或者更多字节表示，我们可以比较中英文字符在ASCII、GB2312和Unicode的编码：

英文字符'A'的ASCII编码和Unicode编码：

         ┌────┐
ASCII:   │ 41 │└────┘┌────┬────┐
Unicode: │ 00 │ 41 │└────┴────┘

英文字符的Unicode编码就是简单地在前面添加一个00字节。

中文字符'中'的GB2312编码和Unicode编码：

         ┌────┬────┐
GB2312:  │ d6 │ d0 │└────┴────┘┌────┬────┐
Unicode: │ 4e │ 2d │└────┴────┘

那我们经常使用的UTF-8又是什么编码呢？因为英文字符的Unicode编码高字节总是00，包含大量英文的文本会浪费空间，所以，出现了UTF-8编码，它是一种变长编码，用来把固定长度的Unicode编码变成1～4字节的变长编码。通过UTF-8编码，英文字符'A'的UTF-8编码变为0x41，正好和ASCII码一致，而中文'中'的UTF-8编码为3字节0xe4b8ad。

UTF-8编码的另一个好处是容错能力强。如果传输过程中某些字符出错，不会影响后续字符，因为UTF-8编码依靠高字节位来确定一个字符究竟是几个字节，它经常用来作为传输编码。

在Java中，char类型实际上就是两个字节的Unicode编码。如果我们要手动把字符串转换成其他编码，可以这样做：

byte[] b1 = "Hello".getBytes(); // 按ISO8859-1编码转换，不推荐
byte[] b2 = "Hello".getBytes("UTF-8"); // 按UTF-8编码转换
byte[] b2 = "Hello".getBytes("GBK"); // 按GBK编码转换
byte[] b3 = "Hello".getBytes(StandardCharsets.UTF_8); // 按UTF-8编码转换

注意：转换编码后，就不再是char类型，而是byte类型表示的数组。

如果要把已知编码的byte[]转换为String，可以这样做：

byte[] b = ...
String s1 = new String(b, "GBK"); // 按GBK转换
String s2 = new String(b, StandardCharsets.UTF_8); // 按UTF-8转换

始终牢记：Java的String和char在内存中总是以Unicode编码表示。

对于不同版本的JDK，String类在内存中有不同的优化方式。具体来说，早期JDK版本的String总是以char[]存储，它的定义如下：

public final class String {private final char[] value;private final int offset;private final int count;
}

而较新的JDK版本的String则以byte[]存储：如果String仅包含ASCII字符，则每个byte存储一个字符，否则，每两个byte存储一个字符，这样做的目的是为了节省内存，因为大量的长度较短的String通常仅包含ASCII字符：

public final class String {private final byte[] value;private final byte coder; // 0 = LATIN1, 1 = UTF16

对于使用者来说，String内部的优化不影响任何已有代码，因为它的public方法签名是不变的。

小结

Java字符串String是不可变对象；
字符串操作不改变原字符串内容，而是返回新字符串；
Java使用Unicode编码表示String和char；
转换编码就是将String和byte[]转换，需要指定编码；
转换为byte[]时，始终优先考虑UTF-8编码。

字符的编码和解码

　　信息在计算机网络中传输是以字节的形式。那么如何变为字节？这就是编码的过程。那么计算机接收了这个编码，如何让使用者认识呢？那必须要将字节转换为人所识别的字符串形式，这就是解码的过程。

　　编码：将字符串转换为 byte 数组

　　解码：把 byte 数组转换为字符串

注意：①、编码格式和解码格式必须一致，否则乱码

String str = new String("Aa帅锅");//编码操作byte[] strByte = str.getBytes("GBK");System.out.println(Arrays.toString(strByte));//[65, 97, -53, -89, -71, -8]//解码操作 //注意编码的字符集和解码的字符集格式必须一致（是其扩展字符集也可以），否则会乱码//第一种：编码格式为 GBK，解码格式为 ISO-8859-1  那么就会乱码String str2 = new String(strByte,"ISO-8859-1");System.out.println(str2); //Aa?§??//第二种：编码和解码格式一致String str3 = new String(strByte,"GBK");System.out.println(str3); //Aa帅锅

　②、有时候编码为和解码格式一致了，但是还是乱码，这是因为在数据在传输过程中经过服务器的处理，而这个服务器可能是外国人编写的，那么就会将数据转换为别的字符格式，那么你如果还是直接转为自己想要的格式是会乱码的。

　　解决办法：先获取经过服务器之后的数据还原编码，然后在进行解码

String str = new String("Aa帅锅");//编码操作byte[] strByte = str.getBytes("UTF-8");System.out.println(Arrays.toString(strByte));//[65, 97, -27, -72, -123, -23, -108, -123]//中间经过了服务器的传输，编码格式转成了 ISO-8859-1String str2 = new String(strByte,"ISO-8859-1");//解码操作  ,此时如果直接进行解码，那么会乱码String str3 = new String(str2.getBytes(),"UTF-8");System.out.println(str3); //Aa???????//对于上面的乱码，我们必须先还原服务器之前的编码格式，然后在进行解码。那么就不会乱码byte[] strByte2 = str2.getBytes("ISO-8859-1");String str4 = new String(strByte2,"UTF-8");System.out.println(str4); //Aa帅锅

Integer常用工具类

　　①、自动装箱

　　一般我们创建一个类的时候是通过new关键字，比如：

Object obj = new Object();

　但是对于 Integer 类，我们却可以这样：

Integer a = 128;

　　为什么可以这样，通过反编译工具，我们可以看到，生成的class文件是：

Integer a = Integer.valueOf(128);

　　这就是基本数据类型的自动装箱，128是基本数据类型，然后被解析成Integer类。

　　注意：自动装箱规范要求 byte<= 127、char<=127、-128<=short <=127、-128<=int <=127都被包装到固定的对象中（缓存）。

　　②、自动拆箱

　　我们将 Integer 类表示的数据赋值给基本数据类型int，就执行了自动拆箱。

Integer a = new Integer(128);int m = a;

　　反编译生成的class文件：

Integer a = new Integer(128);int m = a.intValue();

　　简单来讲：自动装箱就是Integer.valueOf(int i);自动拆箱就是 i.intValue();

public class IntegerTest {
public static void main(String[] args) {//用于将字符串转换成基本数据类型(int)，要求字符串必须是数字格式。String num = "2018";int i = Integer.parseInt(num);System.out.println(i/2);//将字符串s按照radix进行转换相应的进制数，然后运行的结果都是以十进制的形式打印。String year = "1110";String age = "A";//指定year的进制为2进制int ii = Integer.parseInt(year,2);//指定age的进制为16进制int i2 = Integer.parseInt(age,16);    System.out.println(ii);System.out.println(i2);//任何类型+"" 变成String类型int src = 3;String dest = src + "";System.out.println(dest+1);int srcc = 32;//将int整数转换成指定的进制数String destt = Integer.toString(srcc,2);    System.out.println(destt);System.out.println("Long最大值是："+Long.MAX_VALUE);System.out.println("Long最小值是："+Long.MIN_VALUE);System.out.println("Double最大值是："+Double.MAX_VALUE);System.out.println("Double最小值是："+Double.MIN_VALUE);int src2 = 7;String Binary = Integer.toBinaryString(src2);String OctalNumberSystem = Integer.toOctalString(src2);String Hexadecimal = Integer.toHexString(src);System.out.printf("%d的二进制是：%s,八进制是:%s,十六进制是：%s\n",src2,Binary,OctalNumberSystem,Hexadecimal);    //将构造方法中的字符串转成基本数据类型String s1 = new String("1000");Integer src1 = new Integer(s1);int dest1 = src1.intValue();System.out.println(dest1--);System.out.println(--dest1); //自动装箱和自动拆箱Integer src4 = 100; //这里就是自动装箱的过程，相当于Integer src = new Integer(100);int dest2 = src4 + 5; //我们知道src本身是引用数据类型，不能直接跟基本数据类型运算，首先它会自动进行拆箱操作，相当于：int dest = src.intValue() + 5 ;System.out.println(dest2);//还可以直接跟引用数据类型进行运算，但是它也存在一个弊端，即可能出现空指针异常。Integer src = null;  }
}

因为int和Integer可以互相转换

int i = 100;
Integer n = Integer.valueOf(i);
int x = n.intValue();

所以，Java编译器可以帮助我们自动在int和Integer之间转型：

Integer n = 100; // 编译器自动使用Integer.valueOf(int)
int x = n; // 编译器自动使用Integer.intValue()

这种直接把int变为Integer的赋值写法，称为自动装箱（Auto Boxing），反过来，把Integer变为int的赋值写法，称为自动拆箱（Auto Unboxing）。

注意：自动装箱和自动拆箱只发生在编译阶段，目的是为了少写代码。

装箱和拆箱会影响代码的执行效率，因为编译后的class代码是严格区分基本类型和引用类型的。并且，自动拆箱执行时可能会报NullPointerException：

不变类

所有的包装类型都是不变类。我们查看Integer的源码可知，它的核心代码如下：

public final class Integer {private final int value;
}

因此，一旦创建了Integer对象，该对象就是不变的。

对两个Integer实例进行比较要特别注意：绝对不能用==比较，因为Integer是引用类型，必须使用equals()比较：

public class Main {public static void main(String[] args) {Integer x = 127;Integer y = 127;Integer m = 99999;Integer n = 99999;System.out.println("x == y: " + (x==y)); // trueSystem.out.println("m == n: " + (m==n)); // falseSystem.out.println("x.equals(y): " + x.equals(y)); // trueSystem.out.println("m.equals(n): " + m.equals(n)); // true}
}

仔细观察结果的童鞋可以发现，==比较，较小的两个相同的Integer返回true，较大的两个相同的Integer返回false，这是因为Integer是不变类，编译器把Integer x = 127;自动变为Integer x = Integer.valueOf(127);，为了节省内存，Integer.valueOf()对于较小的数，始终返回相同的实例，因此，==比较“恰好”为true，但我们绝不能因为Java标准库的Integer内部有缓存优化就用==比较，必须用equals()方法比较两个Integer。

按照语义编程，而不是针对特定的底层实现去“优化”。

因为Integer.valueOf()可能始终返回同一个Integer实例，因此，在我们自己创建Integer的时候，以下两种方法：

方法1：Integer n = new Integer(100);
方法2：Integer n = Integer.valueOf(100);

方法2更好，因为方法1总是创建新的Integer实例，方法2把内部优化留给Integer的实现者去做，即使在当前版本没有优化，也有可能在下一个版本进行优化。

我们把能创建“新”对象的静态方法称为静态工厂方法。Integer.valueOf()就是静态工厂方法，它尽可能地返回缓存的实例以节省内存。

创建新对象时，优先选用静态工厂方法而不是new操作符。

如果我们考察Byte.valueOf()方法的源码，可以看到，标准库返回的Byte实例全部是缓存实例，但调用者并不关心静态工厂方法以何种方式创建新实例还是直接返回缓存的实例。

public static void main(String[] args) {Integer i = 10;Integer j = 10;System.out.println(i == j);Integer a = 128;Integer b = 128;System.out.println(a == b);int k = 10;System.out.println(k == i);int kk = 128;System.out.println(kk == a);Integer m = new Integer(10);Integer n = new Integer(10);System.out.println(m == n);
}

答案是：

　　首先，直接声明Integer i = 10，会自动装箱变为Integer i = Integer.valueOf(10)；Integer i 会自动拆箱为 i.intValue()。

　　①、第一个打印结果为 true

　　对于 i == j ,我们知道这是两个Integer类，他们比较应该是用equals，这里用==比较的是地址，那么结果肯定为false，但是实际上结果为true，这是为什么？

　　我们进入到Integer 类的valueOf()方法：

　　分析源码我们可以知道在 i >= -128 并且 i <= 127 的时候，第一次声明会将 i 的值放入缓存中，第二次直接取缓存里面的数据，而不是重新创建一个Ingeter 对象。那么第一个打印结果因为 i = 10 在缓存表示范围内，所以为 true。

　　②、第二个打印结果为 false

　　从上面的分析我们知道，128是不在-128到127之间的，所以第一次创建对象的时候没有缓存，第二次创建了一个新的Integer对象。故打印结果为false

　　③、第三个打印结果为 true

　　Integer 的自动拆箱功能，也就是比较两个基本数据类型，结果当然为true

　　④、第四个打印结果为 true

　　解释和第三个一样。int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比较。

　　⑤、第五个打印结果为 false

　　因为这个虽然值为10，但是我们都是通过 new 关键字来创建的两个对象，是不存在缓存的概念的。两个用new关键字创建的对象用 == 进行比较，结果当然为 false。

Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;Integer e = 321;
Integer f = 321;Long g = 3L;
Long h = 2L;System.out.println(c == d);
System.out.println(e == f);
System.out.println(c == (a + b));
System.out.println(c.equals((a+b)));
System.out.println(g == (a+b));
System.out.println(g.equals(a+b));
System.out.println(g.equals(a+h));

反编译结果：

　　打印结果为：

true
false
true
true
true
false
true

　　分析：第一个和第二个结果没什么疑问，Integer类在-128到127的缓存问题；

　　第三个由于 a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法）,==比较符又将左边的自动拆箱，因此它们比较的是数值是否相等。

　　第四个对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。

　　第五个对于 g == (a+b)，首先计算 a+b,也是先调用各自的intValue方法，得到数值之后，由于前面的g是Long类型的，也会自动拆箱为long，==运算符能将隐含的将小范围的数据类型转换为大范围的数据类型，也就是int会被转换成long类型，两个long类型的数值进行比较。

　　第六个对于 g.equals(a+b),同理a+b会先自动拆箱，然后将结果自动装箱，需要说明的是 equals 运算符不会进行类型转换。所以是Long.equals(Integer)，结果当然是false

　　第七个对于g.equals(a+h),运算符+会进行类型转换，a+h各自拆箱之后是int+long，结果是long，然后long进行自动装箱为Long，两个Long进行equals判断。

进制转换

Integer类本身还提供了大量方法，例如，最常用的静态方法parseInt()可以把字符串解析成一个整数：

int x1 = Integer.parseInt("100"); // 100
int x2 = Integer.parseInt("100", 16); // 256,因为按16进制解析

Integer还可以把整数格式化为指定进制的字符串：

public class Main {public static void main(String[] args) {System.out.println(Integer.toString(100)); // "100",表示为10进制System.out.println(Integer.toString(100, 36)); // "2s",表示为36进制System.out.println(Integer.toHexString(100)); // "64",表示为16进制System.out.println(Integer.toOctalString(100)); // "144",表示为8进制System.out.println(Integer.toBinaryString(100)); // "1100100",表示为2进制}
}

注意：上述方法的输出都是String，在计算机内存中，只用二进制表示，不存在十进制或十六进制的表示方法。int n = 100在内存中总是以4字节的二进制表示：

┌────────┬────────┬────────┬────────┐
│00000000│00000000│00000000│01100100│
└────────┴────────┴────────┴────────┘

我们经常使用的System.out.println(n);是依靠核心库自动把整数格式化为10进制输出并显示在屏幕上，使用Integer.toHexString(n)则通过核心库自动把整数格式化为16进制。

这里我们注意到程序设计的一个重要原则：数据的存储和显示要分离。

Java的包装类型还定义了一些有用的静态变量

// boolean只有两个值true/false，其包装类型只需要引用Boolean提供的静态字段:
Boolean t = Boolean.TRUE;
Boolean f = Boolean.FALSE;
// int可表示的最大/最小值:
int max = Integer.MAX_VALUE; // 2147483647
int min = Integer.MIN_VALUE; // -2147483648
// long类型占用的bit和byte数量:
int sizeOfLong = Long.SIZE; // 64 (bits)
int bytesOfLong = Long.BYTES; // 8 (bytes)

最后，所有的整数和浮点数的包装类型都继承自Number，因此，可以非常方便地直接通过包装类型获取各种基本类型：

// 向上转型为Number:
Number num = new Integer(999);
// 获取byte, int, long, float, double:
byte b = num.byteValue();
int n = num.intValue();
long ln = num.longValue();
float f = num.floatValue();
double d = num.doubleValue();

处理无符号整型

在Java中，并没有无符号整型（Unsigned）的基本数据类型。byte、short、int和long都是带符号整型，最高位是符号位。而C语言则提供了CPU支持的全部数据类型，包括无符号整型。无符号整型和有符号整型的转换在Java中就需要借助包装类型的静态方法完成。

例如，byte是有符号整型，范围是-128~+127，但如果把byte看作无符号整型，它的范围就是0~255。我们把一个负的byte按无符号整型转换为int：

public class Main {public static void main(String[] args) {byte x = -1;byte y = 127;System.out.println(Byte.toUnsignedInt(x)); // 255System.out.println(Byte.toUnsignedInt(y)); // 127}
}

因为byte的-1的二进制表示是11111111，以无符号整型转换后的int就是255。

类似的，可以把一个short按unsigned转换为int，把一个int按unsigned转换为long。

Java核心库提供的包装类型可以把基本类型包装为class；

自动装箱和自动拆箱都是在编译期完成的（JDK>=1.5）；

装箱和拆箱会影响执行效率，且拆箱时可能发生NullPointerException；

包装类型的比较必须使用equals()；

整数和浮点数的包装类型都继承自Number；

包装类型提供了大量实用方法。

BigInteger

在Java中，由CPU原生提供的整型最大范围是64位long型整数。使用long型整数可以直接通过CPU指令进行计算，速度非常快。

如果我们使用的整数范围超过了long型怎么办？这个时候，就只能用软件来模拟一个大整数。java.math.BigInteger就是用来表示任意大小的整数。BigInteger内部用一个int[]数组来模拟一个非常大的整数：

BigInteger bi = new BigInteger("1234567890");
System.out.println(bi.pow(5)); // 2867971860299718107233761438093672048294900000

对BigInteger做运算的时候，只能使用实例方法，例如，加法运算：

BigInteger i1 = new BigInteger("1234567890");
BigInteger i2 = new BigInteger("12345678901234567890");
BigInteger sum = i1.add(i2); // 12345678902469135780

和long型整数运算比，BigInteger不会有范围限制，但缺点是速度比较慢。

也可以把BigInteger转换成long型：

BigInteger i = new BigInteger("123456789000");
System.out.println(i.longValue()); // 123456789000
System.out.println(i.multiply(i).longValueExact()); // java.lang.ArithmeticException: BigInteger out of long range

使用longValueExact()方法时，如果超出了long型的范围，会抛出ArithmeticException。

BigInteger和Integer、Long一样，也是不可变类，并且也继承自Number类。因为Number定义了转换为基本类型的几个方法：

转换为byte：byteValue()
转换为short：shortValue()
转换为int：intValue()
转换为long：longValue()
转换为float：floatValue()
转换为double：doubleValue()

因此，通过上述方法，可以把BigInteger转换成基本类型。如果BigInteger表示的范围超过了基本类型的范围，转换时将丢失高位信息，即结果不一定是准确的。如果需要准确地转换成基本类型，可以使用intValueExact()、longValueExact()等方法，在转换时如果超出范围，将直接抛出ArithmeticException异常。

如果BigInteger的值甚至超过了float的最大范围（3.4x1038），那么返回的float是什么呢？

// BigInteger to float
import java.math.BigInteger;
public class Main {public static void main(String[] args) {BigInteger n = new BigInteger("999999").pow(99);float f = n.floatValue();System.out.println(f);}
}

BigInteger用于表示任意大小的整数；

BigInteger是不变类，并且继承自Number；

将BigInteger转换成基本类型时可使用longValueExact()等方法保证结果准确。

BigDecimal

和BigInteger类似，BigDecimal可以表示一个任意大小且精度完全准确的浮点数。

BigDecimal bd = new BigDecimal("123.4567");
System.out.println(bd.multiply(bd)); // 15241.55677489

BigDecimal用scale()表示小数位数，例如：

BigDecimal d1 = new BigDecimal("123.45");
BigDecimal d2 = new BigDecimal("123.4500");
BigDecimal d3 = new BigDecimal("1234500");
System.out.println(d1.scale()); // 2,两位小数
System.out.println(d2.scale()); // 4
System.out.println(d3.scale()); // 0

通过BigDecimal的stripTrailingZeros()方法，可以将一个BigDecimal格式化为一个相等的，但去掉了末尾0的BigDecimal：

BigDecimal d1 = new BigDecimal("123.4500");
BigDecimal d2 = d1.stripTrailingZeros();
System.out.println(d1.scale()); // 4
System.out.println(d2.scale()); // 2,因为去掉了00BigDecimal d3 = new BigDecimal("1234500");
BigDecimal d4 = d1.stripTrailingZeros();
System.out.println(d3.scale()); // 0
System.out.println(d4.scale()); // -2

如果一个BigDecimal的scale()返回负数，例如，-2，表示这个数是个整数，并且末尾有2个0。

可以对一个BigDecimal设置它的scale，如果精度比原始值低，那么按照指定的方法进行四舍五入或者直接截断：

import java.math.BigDecimal;
import java.math.RoundingMode;
public class Main {public static void main(String[] args) {BigDecimal d1 = new BigDecimal("123.456789");BigDecimal d2 = d1.setScale(4, RoundingMode.HALF_UP); // 四舍五入，123.4568BigDecimal d3 = d1.setScale(4, RoundingMode.DOWN); // 直接截断，123.4567System.out.println(d2);System.out.println(d3);}
}

对BigDecimal做加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断：

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("23.456789");
BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小数并四舍五入

在比较两个BigDecimal的值是否相等时，要特别注意，使用equals()方法不但要求两个BigDecimal的值相等，还要求它们的scale()相等：

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("123.45600");
System.out.println(d1.equals(d2)); // false,因为scale不同
System.out.println(d1.equals(d2.stripTrailingZeros())); // true,因为d2去除尾部0后scale变为2
System.out.println(d1.compareTo(d2)); // 0

必须使用compareTo()方法来比较，它根据两个值的大小分别返回负数、正数和0，分别表示小于、大于和等于。

总是使用compareTo()比较两个BigDecimal的值，不要使用equals()！

如果查看BigDecimal的源码，可以发现，实际上一个BigDecimal是通过一个BigInteger和一个scale来表示的，即BigInteger表示一个完整的整数，而scale表示小数位数：

public class BigDecimal extends Number implements Comparable<BigDecimal> {private final BigInteger intVal;private final int scale;
}

BigDecimal也是从Number继承的，也是不可变对象。

BigDecimal用于表示精确的小数，常用于财务计算；

比较BigDecimal的值是否相等，必须使用compareTo()而不能使用equals()。