1 解释下什么是面向对象？面向对面和面向过程的区别？2 面向对象的三大特征？分别解释下？3 JDK、JRE、JVM三者之间的关系？4 重载和重写的区别？5 java是否可以重写一个private或static方法？6 构造方法有哪些特性？7 在java中定义一个不做事且没有参数的构造方法有什么用？（无参构造方法）8 java中创建对象的几种方式？9 抽象类和接口有什么区别？10 静态变量和实例变量的区别？11 short s1 =1；s1 = s1 + 1； 有什么错？ 那么 short s1 = 1；s1 += 1； 有没有错？12 Integer和int的区别？13 装箱和拆箱的区别14 switch语句能否作用在byte上，能否作用在long上，能否作用在String上？15 final、finally、finalize的区别？16 == 和equals的区别？17 两个对象的hashCode()相同，则equals()也一定为true吗？18 为什么重写equals()就一定得重写hashCode()方法？19 & 和 && 的区别？20 java中的参数传递是传值呢？还是传引用？21 java中的Math.round(-1.5)等于多少？22 两个二进制数的异或结果是什么？23 如果实现对象的克隆24 深克隆和浅克隆的区别25 什么是java的序列化，如果实现java的序列化？26 什么情况下需要序列化？27 java的泛型是如何工作的？什么是类型擦除？28 什么是泛型中的限定通配符和非限定通配符？29 List< ? extends T > 和 List< ? super T> 之间有什么区别？30 java中的反射是什么意思？有哪些应用场景？31 反射的优缺点？32 java中的动态代理是什么？有哪些应用？33 怎么实现动态代理？34 static关键字的作用？35 super关键字的作用？36 字节和字符的区别？37 String为什么设置为不可变类？38 String、StringBuilder、StringBuffer的区别？39 String字符串修改实现的原理？40 String str = "i" 和 String str = new String("i")一样吗？41 String类的常用方法有哪些？42 final修饰StringBuffer后可以使用append方法吗？43 java中的IO流的分类？说出几个你熟悉的实现类？44 字节流和字符流有什么区别？45 BIO、NIO、AIO有什么区别？46 transient关键字的作用？
1 解释下什么是面向对象？面向对面和面向过程的区别？面向对象是一种“万物皆对象”的编程思想。以对象为中心，以消息为驱动。
任何事物都可以抽象成一个对象来对待，之后再对这个对象进行相关操作。
面向对象和面向过程的区别：
处理问题的角度不同：
面向对象 = 注重事情有哪些参与者，及各自需要做什么
面向过程 = 注重事情的每个步骤以及顺序编程思路不同：
面向对象 = 抽象出类、属性、方法 =》 实例化类、执行方法
面向过程 = 以实现功能的函数开发为主封装性：
都具有封装性
面向对象 = 封装的是数据和功能。
面向过程 = 封装的是功能。具有属性不同：
面向对象 有 继承性、多态性
面向过程 没有 继承性、多态性
扩展：
OOP = object Oriented Programming 面向对象的编程，
OOD = object Oriented Design 面向对象的设计，
OOA = object Oriented Analysis 面向对象的分析
封装、继承、多态。
封装：隐藏对象的属性和实施细节，仅对外提供公共访问方式。
提高复用性和安全性。
继承：从已有类中得到继承信息创建新类的过程。提供继承信息的类是父类（超类、基类）；得到继承信息的类是子类（派生类）。
继承是多态的前提。提高代码复用性。
多态： 父类或接口定义的引用变量 可以指向 子类或具体实现类的实例对象。
同一对象，在不同时刻表现出来的不同形态。
实现前提：①继承或实现关系 等号前后两个类的关系 父类 = 子类；接口 = 具体实现类 ；
②重写父类中的方法。
③父类引用变量指向子类的实现类对象。（父类型引用子类型对象）
JDK = java development kit ，java程序开发工具，包括JRE、java工具、java基础库
JRE = java runntime environment，java运行时环境，包括JVM和核心类库
JVM = java virtual machine，java虚拟机，是java实现跨平台的核心
所有的java程序会首先被编译为.class的类文件，这种类文件可以在JVM上运行。
重载：编译时多态，同一个类中同名的方法 具有 不同参数（类型、数量），不能根据返回值区分方法。
重写（覆盖）：运行时多态，子类与父类之间、子类重写父类的方法具有相同的返回值类型。
目的：在于父类引用可以根据子类对象的运行时实际类型不同而调用不同的实现代码。
java不能重写一个private方法。
因为private修饰的变量或方法只能在当前类中使用，如果是其他的类继承了当前类是不能访问到private修饰的变量或方法的，更不能重写。
java不能重写一个static方法。
static方法可以被继承，但是不能被重写。方法重写（覆盖）是基于运行时动态绑定的，而static方法是编译器一开始就确定的静态绑定。
1 构造方法名 和 类名 必须保持一致
2 在执行的时候，无参构造方法会自动生成；如果类中定义了带参构造方法，则不会自动生成无参构造方法
3 构造方法无返回值类型（void 也不行）
4 构造方法不能被继承
5 构造方法的调用是在创建一个对象时使用new操作符进行的，作用是初始化对象
6 多个构造方法之间的关系是 方法重载
7 构造方法不能被static final abstract synchronized native等修饰符修饰
java中不做事且没有参数的构造方法 = 无参构造方法
1 【子类继承父类场景】java程序在执行子类的构造方法之前，如果没有使用super()来调用父类指定的构造方法，则会调用父类中的无参构造方法
此时，父类中没有无参构造方法，则编译时会发生错误。
2 【初始化】无参构造方法 一般用来初始化：为变量赋值、初始化对象等。
java创建对象有四种方式：new、反射使用newInstrance、clone、反序列化创建对象
new
具体的实现是：
类名 对象名 = new 类名(); 多态的形式 父类名 对象名 = new 子类名(); 接口名 对象名 = new 接口实现类名();
newInstrance
获得Class对象 有三种方式 Class类的静态方法forName、class属性、以及对象的getClass方法
1 通过Class类的静态方法 forName()获得 类的字节码文件对象
Class c = Class.forName("类的路径");
2 通过对象的getClass方法获得Class类对象
Class c = 对象.getClass();
3 通过类的class属性 获得Class类对象
Class c = 类名.class;
利用Class对象的getConstructor()方法获得指定的构造器
constructor con = c.getConstructor();
调用Constructor的newInstance()方法创建java对象
Object obj = con.newInstance();
反序列化创建对象
使用反序列化创建对象，首先要使用序列化创建对象，并实现对象的序列化。
序列化创建对象
1 创建序列化对象
objectOutputStream oos = new objectOutputStream(new FileOutputStream("文件路径"));
2 创建对象
类名 obj = new 类名();
3 写入序列化流对象
oos.writeObject(obj);
4 释放资源
oos.close();
反序列化创建对象
1 创建反序列化对象
objectInputStream ois = new objectInputStream(new FileOutputStream("文件路径"));
2 使用方法readObject()读取对象
Object obj = ois.readObject();
3 释放资源
ois.close();
clone()
使用的是java.lang.Object类中的方法clone()，由于java中所有的类都默认继承java.lang.Object类，所有所有类创建的对象都可以调用clone方法。
1 通过类创建对象 类名 对象名1 = new 类名(); 2 使用clone()创建对象 类名 对象名2 = (类名)对象名1.clone();9 抽象类和接口有什么区别？
| 区别 | 抽象类 | 接口 |
|---|---|---|
| 成员变量 | 可以是变量、常量， 修饰符可以是pubilc、默认、protected | 只能是常量 且修饰符是public static final |
| 成员方法 | 抽象方法 public abstract 修饰 | 抽象方法 public abstract |
| 具体方法 修饰符可以是public、默认、protected | 默认修饰符只能是default | |
| 可以有静态方法 | JDK8可以有静态方法，必须实现且只能使用public修饰或省略不写 | |
| 构造方法 | 可以定义构造方法 | 不可以定义构造方法 |
| 设计理念 | 对类的行为、属性 进行抽象 | 对类的行为 进行抽象 |
| 继承 | 可以继承一个类 并且 实现多个接口 | 可以实现一个或多个接口 |
| 添加新的方法 | 给抽象类添加新方法，提供默认实现，就不需要改现有代码 | 接口中添加新方法，必须修改该接口的实现类 |
理解分析：
JDK1.8之前接口中不允许出现静态方法，因为接口不可以实现方法，只可以定义方法，而静态方法需要被实现，所以接口不能含有静态方法。实现 的含义是 方法有方法体，且有具体的内容。 10 静态变量和实例变量的区别？
| 区别 | 静态变量 | 实例变量 成员变量 |
|---|---|---|
| 语法定义 | 被static关键字修饰 | 没有 |
| 程序运行 | 属于类而不属于具体对象，没有创建具体的对象，加载类也会分配内存空间，只分配一次 | 属于某个对象，必须创建了具体对象，才会被分配内存空间 |
| 共享性 | 被所有对象所共有，其中一个改变其值，其他对象访问则是改变后的值 | 被对象所私有，某个对象改变其值后，不影响其他对象 |
| 调用形式 | 类名.变量名 | 对象名.变量名 |
共享性测试：
// 类
public class Demo {
static int a = 1;//静态变量
public int j = 1; // 实例变量
// 构造方法，
public Demo() {
a++;
j++;
System.out.println(a + ", " + j);
}
// 输出结果是 2, 2
// 3, 2
// 前者是静态变量，对象1 做了+1操作 对象2 又进行了+1操作 由于共享变量，所以a的值最终变成3
// 后者是实例变量，属于每个不同的对象，所以都是从1 开始做+1操作，最终输出都是2
}
// 测试类
public class DemoTest {
public static void main(String[] args) {
Demo t1 = new Demo();
Demo t2 = new Demo();
}
}
11 short s1 =1；s1 = s1 + 1； 有什么错？ 那么 short s1 = 1；s1 += 1； 有没有错？
short s1 =1；s1 = s1 + 1；
有错，错误的根本原因是算术运算符+号底层没有包含强制类型转换。s1 = s1 + 1；的计算会将s1的类型自动提升为int类型，那么计算过程就为short = int + int，此时会报不兼容类型的错误：从int类型到short类型会有数据损失。
short s1 = 1；s1 += 1；
没有错，因为扩展地赋值运算符底层包含了强制类型转换。s1 += 1；计算过程中，会将等号右侧int类型转换为short类型。
| 区别 | Integer | int |
|---|---|---|
| 类型 | int的包装类 | 基本数据类型 |
| 使用 | 必须实例化后才能使用 | 可以直接使用 |
| 本质 | 是对象的引用，new Integer()产生一个指针指向此对象 | 直接存储数据 |
| 默认值 | null | 0 |
扩展分析：
非new生成Integer对象的形式是： Integer 变量名 = 变量值;
由于Integer变量本质是对Integer对象的引用，所以通过new Integer创建的变量不可能相等，因为不同的对象存储地址不同；Integer变量和int类型变量进行比较，只要两者值是相等的，结果就是true。因为包装类integer和基本类型int比较，java会默认执行拆箱操作，将Integer变量 变成 int类型变量，然后进行比较；非new生成的Integer对象 Integer i = 100 和 new Integer()生成的变量进行比较，结果为false。
① 变量值 在-128~127之间时 Integer 变量名 = 具体值 生成的变量指向的是java常量池中的对象；而new Integer()生成的变量指向的是堆中新建的对象；两者的内存地址不同；② 变量值不在-128~127之间时 Integer i = 200 这种形式创建对象时，java API中最终会按照new Integer()形式创建对象，所以两者的内存地址还是不同；两个非new生成Integer对象，值相同进行比较。两个变量的值在-128~127之间，结果为true；反之，结果为false；
两个变量的值在-128~127之间，说明两者同时执行java常量池中的对象，内存地址相同，结果为true；
两个变量的值不在-128~127之间，说明变量最终会通过new Integer()创建，产生两个不同的对象，内存地址不同，结果为false；
13 装箱和拆箱的区别
每一种基本数据类型，都有其相对应的包装类。byte–Byte，char–character，short–Short，int–Integer，long–Long，float–Float，double–Double。
以Integer 对象 ii 和 int 变量 i 为例
| 区别 | 装箱 | 拆箱 |
|---|---|---|
| 概念 | 将基本数据类型封装成对应的包装类 | 将包装类 转换成 对应的基本数类型 |
| 手动实现 | Integer ii = Integer.valueof( 100 ) | int i = ii.intValue() |
| 自动实现 | Integer ii= 100 | ii += 200 包含自动拆箱 ii + 200,自动装箱 ii = ii + 200的赋值过程 |
switch语句能作用在byte上，jdk7之后可以作用于String，不能作用于long。
switch语句的表达式只能是整数表达式或枚举类型，整数表达式主要是int基本数据类型或Integer包装类。
switch语句不仅能作用于btye，而且还有char、short 类型，因为它们都可以隐式转化为int类型。
| 对比项 | 说明 |
|---|---|
| final | 用于声明属性-表示属性不可变（常量） 方法-表示不可覆盖（重写） 类-不可继承 |
| finally | 异常处理语句的一部分，表示总是执行 常用于异常处理时的所有清除操作，比如IO流中的释放资源操作 |
| finalize | Object类的一个方法，在垃圾回收时会调用被回收对象的finalize |
==
基本数据类型：数值是否相等引用数据类型：比较对象的地址是否相等
equals
对象内容：比较对象内容是否相等不能比较基本数据类型的变量是否相等equals方法没有重写，比较的是引用类型的变量所指向的对象的地址equals大部分情况下被重写，比如String、Integer等把它变成了值比较，所以一般情况下equals比较的是值是否相等 17 两个对象的hashCode()相同，则equals()也一定为true吗？
两个对象的hashCode()相同，equals()不一定为true。因为在哈希表中，hashCode()相等表示两个键值对的哈希值相等，然而哈希值相等，不一定能得出键值对相等（散列冲突）。
散列冲突 表示： 在key1！=key2的时候，经过哈希函数处理，hash（key1） = hash（key2）.原因是：再好的哈希函数，由于哈希值是非负的，总量是有限的，而在现实中所需要处理的键是无限的，将无限的集合映射到有限的的集合中，肯定避免不了冲突。
散列表 = HashTable，哈希表。散列函数 = 哈希函数。
基本原理：通过哈希函数 将元素的键映射为数组下标（散列值或哈希值）
前提 如果没有用到HashMap()、HashSet等集合，即用不到哈希表的时候，仅重写equals()也是可以的；
但是一般情况下，实际场景中会用到哈希表的，所以java官方建议重写equals()就一定重写HashCode()。
原因 为了保证是同一对象，在equals比较相同的情况下，hashcode值必定相同。
实际情况分析
进行集合对象的判重，如果一个集合中有10,000个对象，仅使用equals()方法，对于一个对象的判重就需要进行10,000次比较，随着集合规模的增大，时间开销很大。同时使用哈希表的话，能快速定位到对象的大概存储位置，后续比较中，如果对象的hashCode()不同，则就不用调用equals()方法，减少了equals()的比较次数。
扩展：hashCode() 和 equals()的相关性
两个对象相等，则hashCode值一定相等两个对象相等，对两个对象分别调用equals方法都返回true两个对象有相同的hashCode值，两个对象不一定相等equals方法被覆盖过，则hashCode方法也必须被覆盖hashCode方法默认的行为是对堆上的对象产生独特值，如果没有重写hashCode方法，则该class类的两个对象无论如何都不会相等（即使连个对象指向相同的数据） 19 & 和 && 的区别？
逻辑& 短路逻辑&&
当两侧的表达式都是true的时候，整个运算结果才是true，否则是false。
两者的区别是：
短路逻辑&& 只要左侧表达式是false，则右侧表达式就不会计算了。
逻辑& 左侧表达式无论结果是true还是false，右侧表达式都会计算。
还可以进行按位运算，两边不是boolean类型时，表示按位运算。
java中的参数传递是以值传递的形式传入方法。
传递的是基本数据类型（数字及布尔值）：一个方法不可能修改一个基本数据类型参数的值
传递的是引用数据类型：一个方法可以修改一个引用数据类型参数所指向对象的值
Math.rounde(-1.5)结果是-1，因为在数轴上，中间值0.5是向右取整，都会向大的方向走，那么正数会向上取整，负数则会直接舍去（也是向大的方向取整）；
比如 Math.round(-1.5) => -1 ，Math.round(-1.2) => -1，Math.round(-1.8) => -2
两个二进制数的异或结果是 两个二进制数差的绝对值，表达式：a^b = |a - b|
案例：如果a = 1001 b= 1011 ，则a^b=0010 = 2（十进制） |a-b| = |9-11| = 2
实现克隆的方式有两种：
① 实现Cloneable接口并重写clone()方法；
1 被克隆对象所属类必须实现Cloneable接口
public class 类名 implements Cloneable{}
2 所属类必须重写Object类的clone方法
@Override
public Object clone() throws CloneNotSupportedException{
类名 obj =(类名)super.clone(); // 浅克隆
obj.属性名 = (属性类)属性名.clone(); //深克隆
return obj；
}
②实现Serializable接口，通过对象的序列化和反序列化实现克隆；
// 要序列化对象所属类 需要实现Serializable接口
public class 类名 implements Serializable{}
// 序列化
1 创建序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("文件路径"));
2 创建对象
类名 obj = new 类名();
3 使用序列化流的writeObject方法将对象写入指定的ObjectOutputStream流中
oos.writeObject(obj);
4 释放资源
oos.close();
// 反序列化
1 创建反序列化流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("文件路径"));
2 使用反序列化流的readObject方法从ObjectInputStream流中读取一个对象
Object obj = ois.readObject();
3 强制转化对象类型
类型 obj1 = (类型)obj;
4 释放资源
ois.close();
24 深克隆和浅克隆的区别
两者的区别是：克隆的新对象和原始对象的引用类型属性是否是同一个对象。
浅克隆：新对象和原始对象的引用类型属性是同一个对象，只是复制了对象的引用地址，两个对象指向同一个内存地址；
深克隆：新对象和原始对象的引用类型属性不是同一个对象，修改其中一个对象的引用类型属性，另一个不受影响。
对象的序列化 = 将对象状态转化为字节流。
反序列化 = 从字节流转化为对象。
实现序列化：
1 被序列化的类实现Serializable接口
pubilc class 类名 implements Serializable{}
2 创建对象序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("文件路径"));
3 创建类的对象
类名 obj = new 类名();
4 使用write方法将对象写入序列化流对象中
oos.writeObject(obj);
5 释放资源
oos.close();
26 什么情况下需要序列化？
想把内容中的对象状态保存到一个文件或数据库中的时候想使用套接字在网络上传输对象的时候想通过RMI传输对象的时候
扩展：
套接字 = Socket，可以看成网络中不同主机上的应用进程之间进行双向通信的端点的抽象。
RMI（Remote Method Invocation），远程方法调用，是运行在一个java虚拟机上的对象调用运行在另一个java虚拟机上对象的方法。
泛型：是通过类型擦除来将变量变为一个类型，编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。
泛型的本质是参数化类型，等价于 所操作的数据类型被指定为一个参数。类型擦除：泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，专业术语称之为类型擦除。
在泛型类被类型擦除之前，泛型类中的类型参数如果没有指定上限，即< T >则会被直接转意为Object类型；如果制定了上限，即< T extends String >则类型参数会被直接替换成类型上限String。
扩展：
案例：
List28 什么是泛型中的限定通配符和非限定通配符？list = new ArrayList (); 解释： 1 两个String只有第一起作用，但是省略后一个String的形式JDK7之后才允许。 2 第一个String，表示List存储的是String。
限定通配符 对类型进行了限定。有两种类型：
< ? extends T > 表示类型必须是T的子类 或者 T类型< ? super T > 表示类型必须是T的父类 或者 T类型
非限定通配符 没有对类型进行限定。
< ? > 表示用任何类型来替代 29 List< ? extends T > 和 List< ? super T> 之间有什么区别？
两个都是限定通配符。
List< ? extends T > 可以接受任何 继承自T类型（T类型的子类或者T类型） 的List
List< ? super T > 可以接受任何 T的父类 构成的List
扩展：
Array不支持泛型，要用List代替Array，因为List可以提供编译器的类型安全保证，而Array却不能。
反射反射机制：在运行状态中，对于一个类，能够知道类的所有属性和方法；对于一个对象，能够调用它的任意一个方法和属性。
动态获取的信息 以及 动态调用对象的方法 的功能称为反射机制。
应用场景：模块化的开发（通过反射去调用对应的字节码）、动态代理、框架的设计（Spring、Hibernate）、工厂模式（使用反射机制根据全限定类名获得某个类的Class实例）。
优点：
运行期类型的判断，动态加载类，提高代码灵活度缺点：
性能瓶颈：反射相当于一系列解释操作，涉及动态类型的解析，JVM无法对代码进行优化，性能比直接的java代码要慢很多
安全问题：可以动态操作改变类的属性同时也增加了类的安全隐患。反射技术要求程序必须在一个没有安全限制的环境中运行。
内部暴露：反射操作允许执行一些正常情况下不被允许的操作（比如：访问私有方法或属性），可能会导致代码失调并破坏可移植性和抽象性，当平台发生改变，代码的行为可能会随之改变。
32 java中的动态代理是什么？有哪些应用？
动态代理
给实现了某个接口的类中的方法添加额外处理，给这个类创建代理，即创建一个新的类。新的类不仅具有原来类方法的功能，而且还添加了额外处理的新功能。
在程序运行时，运用反射机制动态创建而成，动态代理类的字节码在程序运行时由java反射机制动态生成，无需程序员手动编写它的源代码。
应用
Spring的AOP、加事务、加权限、加日志。
具体作用：
| 具体作用 | 说明 |
|---|---|
| 静态变量 类变量 | 变量属于类，类的所有实例都共享静态变量，可以通过类名直接访问 静态变量在内存中只存在一份 |
| 静态方法 | 类加载的时候就存在，不依赖与任何实例 静态方法必须实现，不能是抽象方法 只能访文所属类的静态属性和静态方法，方法中不能有this和super关键字 |
| 静态语句块 | 在类初始化时运行一次 |
| 静态内部类 | 不能访问外部类的非静态的变量和方法 非静态内部类依赖于外部类的实例，静态内部类不需要 |
具体静态xxx
// idea_face-test2-StaticDemo
public class StaticDemo {
public static String staticFieldString = "静态变量";
static{
System.out.println("静态语句块");
}
public String field = "实例变量";
{
System.out.println("普通语句块");
}
public StaticDemo(){
System.out.println("构造方法");
}
}
初始化顺序：
普通类：
静态变量和静态语句块 优先于 实例变量和普通语句块，而静态变量和静态语句块的初始化顺序取决于他们代码中的顺序。存在继承的初始化顺序：父类、子类都存在静态变量、静态语句块、实例变量、普通语句块、构造函数
①父类（静态变量，静态语句块）②子类（静态变量，静态语句块）③父类（实例变量、普通语句块）④父类（构造方法）⑤子类（实例变量、普通语句块）⑥子类（构造方法）
35 super关键字的作用？
访问父类的构造方法：super()
使用super()方法访问父类的构造方法；访问父类的成员方法：super.成员方法()
如果子类重写了父类的某个方法，可以通过使用super关键字来引用父类的方法实现；访问父类的成员变量：super.成员变量名
扩展：
【this和super不能同时出现在一个构造函数中】
理解如下：
准确来说是 this调用本类构造器，super调用父类构造器时，不能同时出现。
也就是 this调用本类属性或方法 super调用父类属性或方法 的时候，可以同时出现。
java规定，在执行构造函数之前，必须执行父类的构造函数，直到这个类是java.lang.Object类的构造函数
假如函数的入口是子类的构造方法，任何函数的构造方法第一句都是执行父类的构造函数。如果没有添加super关键字，系统会默认添加super（）语句；如果有super关键字显示的调用父类构造方法，那么就会使用指定的父类构造方法，否则使用无参构造方法。
假如构造方法中存在this（）和super（）。this会调用本类其他的构造方法，按照递归，最终还是会调用父类的构造方法，那么两者同时存在，就会造成初始化父类的两次不安全操作。
字节是存储容量的基本单位。
字符是数字、字母、汉字以及其他语言的各种字符。
1 字节 = 8个二进制单位，一个字符由一个字节或多个字节的二进制单位组成。
原因如下：
字符串常量池的需要。
字符串常量池是java堆内存的特殊存储区域。创建一个String对象的时候，假如字符串值已经存在于常量池中，则不会再创建一个新的对象，而是引用已经存在的对象。允许String对象缓冲HashCode。
java中的String对象的哈希值被频繁地使用（比如：HashMap等容器中），字符串不变性保证了hash码的唯一性，因此可以放心地进行缓存。String被许多java类（库）用来当做参数。
比如：网络连接地址URL、文件路径path、反射机制所需要的String参数，如果String不是固定不变的，将会引起各种安全隐患。
38 String、StringBuilder、StringBuffer的区别？
| 类型 | 说明 |
|---|---|
| String | 字符串常量（线程安全） |
| StringBuilder | 字符串变量（线程不安全） 字符串缓冲区 |
| StringBuffer | 字符串变量（线程安全） 对方法加了同步锁 |
使用区别：
String字符串内容不可变，修改String字符串的内容实际上是在堆内存中重新开辟内存存储新的字符串，并将内存地址赋值给String字符串变量；StringBuilder字符串内容是可变的，修改字符串是修改字符串变量对应内存地址存储的字符串，不会造成内存空间的浪费；在修改字符串操作比较多的时候使用StringBuilder或StringBuffer，要求线程安全使用StringBuffer，不要求线程安全使用StringBuilder。三者的执行效率：StringBuilder > StringBuffer > String 39 String字符串修改实现的原理？
对String字符串进行修改的步骤是：
1 创建String类型字符串
String s = "abcxxxx";
2 创建StringBuilder对象
StringBuilder sb = new StringBuilder(s);
3 使用StringBuilder对象的append方法，实现字符串的添加
sb.append("");
4 使用StringBuilder对象的toString方法，实现StringBuilder =》 String类型
sb.toString();
40 String str = “i” 和 String str = new String(“i”)一样吗？
不一样。内存的分配方式不一样。String str = "i"方式，java虚拟机会将其分配到常量池中（常量池位于堆内存）；String str = new String(“i”)方式，java虚拟机会将其分配到堆内存中。
String str = “i” ； String str2 = “i”
表示把i在内存中的地址赋值给str变量，如果有String str2 = “i” ，由于i在常量池中已经存在，所以会将i在常量池中的地址赋值给str2。两个引用的是同一个地址，共享同一个内存空间。String str3 = new String(“i”) ；String str4 = new String(“i”)
表示将new String出来的新对象存储的地址赋值给str3，新对象存储在堆栈中。String str4 = new String(“i”)表示又创建一个新对象，并将对象的地址赋值给str4
41 String类的常用方法有哪些？
| 方法名 | 说明 |
|---|---|
| int indexOf() | 返回指定字符的索引 有四个方法 参数可以是：int ch / int ch，int fromIndex / String str / String str，int fromIndex |
| char charAt(int index) | 返回指定索引处的字符 |
| String replace(String oldstr，String newstr) | 字符串替换 |
| String trim() | 去除字符串两端空白 |
| String[] split(String regex,int limit) | 分割字符串，返回一个分割后的字符串数组 |
| byte[] getBytes() | 返回字符串的Byte类型数组 |
| int length() | 返回值字符串的长度 |
| String toLowerCase() | 将字符串转成小写字母 |
| String toUpperCase() | 将字符串转成大写字母 |
| String substring(int beginIndex，int endIndex) | 截取字符串 |
| Boolean equals(String str) | 字符串比较 |
可以使用append()方法。
因为final修饰一个引用类型，表示变量的引用地址不能改变，即所指向的对象不变，但是对象中的属性可以改变。通过append可以改变对象的属性值。
java中IO流分类：
按照功能分：输入流（Input）、输出流（Output）
按照类型分：字节流、字符流
字节流：按8位传输，以字节为单位输入输出数据；
字符流：按16位传输，以字符为单位输入输出数据；（java默认UTF-8编码）（如果是GBK编码，则字符流是24位）
不管是网络传输 还是 文件读写，信息的最小保存单位是字节。
扩展
由于网络传输、文件读写最终的信息的最小保存单位是字节，那么字节是如何解码出字符的呢？
若干个字节 》 选择某种解码方式 》 解码 》 索引字符集 》 映射到一个字符
备注：案例一排水壶烧水
| 模式 | BIO | NIO | AIO |
|---|---|---|---|
| 名词含义 | Block IO同步阻塞式IO | New IO同步非阻塞IO | Asynchronous IO 异步非阻塞式IO |
| 概念 | 服务端需要对某个客户端的每个请求处理完毕之后，才能继续接收别的客户端的情请求 | 使用单线程或只是用少量的多线程，一个请求一个线程，多个连接共用一个线程 | 操作基于事件和回调机制。应用操作之后会直接返回，不会阻塞在那里，后台处理完成之后，操作系统会通知相应的线程进行后续的操作。 |
| 举例说明 | 一个线程停留在一个水壶那里，知道水壶烧开，再去处理下一个水壶 | 一个线程在循环观察水壶的情况，根据每个水壶的情况去处理 | 每个水壶上装一个开关，当水开之后会提醒对应的线程去处理 |
| 优点 | 模型简单，编码简单 | 性能瓶颈高 | |
| 缺点 | 性能瓶颈低，不适合高并发 | 模型复杂，编码复杂 | |
| 应用场景 | Apache、Tomcat，主要用于并发量要求不高的场景 | Nginx、Netty，主要是高并发量要求的场景 | 技术不是很成熟 |
| 区别 | NIO | AIO |
|---|---|---|
| 发出IO请求后具体操作 | 发出IO请求后，由线程不断尝试去获取IO权限，获得权限通知应用程序执行相应的IO操作 | 发出IO请求后，由操作系统自己去获取IO权限并执行IO操作 |
| IO操作 | 程序自己从内核中将数据复制到用户空间，并自己调用相应的逻辑处理 | 帮助程序从内核中复制数据到用户空间，并调用程序传入的回调方法 |
对于不想进行序列化的变量，使用transient关键字修饰。
可以实现阻止实例中用transient关键字修饰的变量被序列化。当变量被反序列化时，被transient修饰的变量值不会被持久化和恢复。
transient只能修饰变量，不能修饰类和方法。
参考连接
