001 - Java基础

前端编译

后端编译

图解两步编译

图解两步编译

Java 的平台无关性实现主要作用于以上阶段

对于不同的硬件和操作系统，最主要的区别就是指令不同。

比如同样执行a+b，A 操作系统对应的二进制指令可能是10001000，而B 操作系统对应的指令可能是11101110。

上图是Oracle 官网下载JDK 的指引，不同的操作系统需要下载对应的Java 虚拟机。

有了Java 虚拟机，想要执行a+b 操作，A 操作系统上面的虚拟机就会把指令翻译成10001000，B 操作系统上面的虚拟机就会把指令翻译成11101110。

Java 中基本数据类型的值域和行为都是由其自己定义的。

举一个简单的例子：对于int 类型，在Java 中，int 占4 个字节，这是固定的。

基本数据类型是由它的占位宽度决定的，占位宽度则是由所在平台决定的。

在不同的平台中，对于同一个C++程序的编译结果会出现不同的行为。

举一个简单的例子：对于int 类型，在C++中却不是固定的了。

Hello World In Kotlin

即能够让编译器能够在程序员没有明确说明的时候推断出变量的类型。

实际上，Groovy 编译器是可以接受完全纯粹的Java 语法格式的。

它的语法风格与Java很像，Java 程序员能够很快的熟练使用Groovy，

大多数Java 代码也匹配Groovy 的语法规则，尽管可能语义不同。

Hello World In Groovy

Hello World In Scala

Hello World In Jruby

Hello World In Jython

.NET Common Language Runtime

JavaScript 

Java Runtime Environment(JRE)

Hello World In Fantom

Hello World In Clojure

Hello World In Rhino

Hello World In Ceylon

面向过程

比如

public class Hello {
     public static void main (String args[]) {
    System.out.println("这是一个简单的Java应用程序");
    }
} 

注
1．应用程序的主类是Hello
2．源文件的命名 :Hello.java

当保存了Hello.java源文件后，就要使用Java编译器（javac.exe）对其进行编译。 

如果源文件没有错误，编译源文件将生成扩展名为.class的字节码文件，其文件名与该类的名字相同，被存放在与源文件相同的目录中。

子主题

编译例1-1中Hello.java源文件将得到Hello.class。

如果对源文件进行了修改，必须重新编译，再生成新的字节码文件。

如果编译出现错误提示，必须修改源文件，然后再进行编译。

使用Java虚拟机中的Java解释器（java.exe）来解释执行其字节码文件。

Java应用程序总是从主类的main方法开始执行。

因此，需进入主类字节码所在目录，如C:\chapter1，然后使用Java解释器(java.exe)运行主类的字节码

使用Java虚拟机中的Java解释器（java.exe）来解释执行其字节码文件。

子主题

1 byte = 8 bits,

最小值：10000000 （-128）(-2^7) 

最大值：01111111（127）(2^7-1)

范围为-128(-2^7)到127(2^7-1)，

在变量初始化时，byte 类型的默认值为0。

Java中不存在byte型常量的表示法，但可以把一定范围内的int型常量赋值给byte型变量。  

使用关键字byte来声明byte 型变量  

例如： byte x= -12,tom=28,漂亮=98; 

 对于byte型内存分配给1个字节，占8位 。

用2 个字节存储

在变量初始化时，short 类型的默认值为0

和byte型类似，Java中也不存在short型常量的表示法，

但可以把一定 范围内的int型常量赋值给short型变量。

使用关键字short来声明short型变量

例如： short x=12,y=1234;例如： short x=12,y=1234;

对于short型变量，内存分配给2个字节，占16位.

int 用4 个字节存储

在变量初始化时，int 类型的默认值为0。

123，6000（十进制），077（八进制），0x3ABC（十六进制）

使用关键字int来声明int型变量，声明时也可以赋给初值

例如： int x= 12,平均=9898,jiafei;

对于int型变量，内存分配给4个字节（byte），-231~231-1

用8 个字节存储

在变量初始化时，long 类型的默认值为0L 或0l，也可直接写为0。

long型常量用后缀L来表示，

例如：108L(十进制)、07123L(八进制)、0x3ABCL(十六进制) 。 

使用关键字long来声明long型变量，

 例如： long width=12L,height=2005L,length;

对于long型变量，内存分配给8个字节，占64位。

单精度浮点数在计算机存储器中占用4 个字节（32 bits），利用“浮点”（浮动小数
点）的方法，可以表示一个范围很大的数值。

双精度浮点数

需要特别注意的是：常量后面必须要有后缀“f”或“F”。

453.5439f，21379.987F，231.0f（小数表示法），2e40f（2乘10的40次方，指数表示法）

使用关键字float来声明float型变量，

例如：float x=22.76f,tom=1234.987f,weight=1e-12F;

对于float型变量，内存分配给4个字节，占32位。

 精度：float变量在存储float型数据时保留8位有效数字，实际精度取决于具体数值。 

2389.539d，2318908.987，0.05（小数表示法），1e-90（1乘10的-90次方，指数表示法）。

对于double常量，后面可以有后缀“d”或“D”，但允许省略该后缀。

使用关键字double来声明double型变量， 

 例如：double height=23.345,width=34.56D,length=1e12; 

对于double型变量，内存分配给8个字节，占64位 。

精度:double变量在存储double型数据时保留16位有效数字，实际精度取决于具体数值。

常量：‘A’，‘b’，‘?’，‘!’，‘9’，‘好’，‘\t’，‘き’，‘モ’等，

即用单引号扩起的Unicode表中的一个字符。

使用关键字char来声明char型变量，

例如：char ch=‘A’,home=‘家’,handsome=‘酷’; 

对于char型变量，内存分配给2个字节，占16位 

有些字符（如回车符）不能通过键盘输入到字符串或程序中，就需要使用转意字符常量,

例如：\n（换行），\b（退格），\t（水平制表），  \‘（单引号），\“（双引号），\\（反斜线）等。 

public class example {
      public static void main (String args[ ])   {
           char ch1='国',ch2='庆';
           int p1=969,p2=12353;
           System.out.println(ch1+"在Unicode表中的位置:"+(int)ch1);
           System.out.println(ch2+"在Unicode表中的位置:"+(int)ch2); 
           System.out.println("第"+p1+"个位置上的字符是:"+(char)p1);
           System.out.println("第"+p2+"个位置上的字符是:"+(char)p2); 
   }
}

输出

true或者是false

使用关键字boolean来声明逻辑变量， 声明时也可以赋给初值，

例如：boolean x,ok=true,关闭=false;

构造方法 ：Byte(byte num)

调用byteValue()方法返回该对象含有的基本型数据

构造方法 ： Integer(int num)

调用intValue()方法返回该对象含有的基本型数据

构造方法： Short(short num)

调用shortValue()方法返回该对象含有的基本型数据

构造方法： Long(long num)

调用longValue ()方法返回该对象含有的基本型数据

实现了对float基本型数据的类包装

构造方法：   Float(float num)

Float对象调用floatValue()方法可以返回该对象含有的float型数据。

实现了对double基本型数据的类包装

构造方法：Double(double num)

Double对象调用doubleValue()方法可以返回该对象含有的double型数据。

实现了对char基本型数据的类包装

构造方法：Character(char c)

常用类方法：

Integer i = new Integer(10);

public static void main(String[]args) {
       Integer integer=1; //装箱
       int i=integer; //拆箱
}

public static void main(String[]args) {
         Integer integer=Integer.valueOf(1);
         int i=integer.intValue();
}

int 的自动装箱都是通过Integer.valueOf()方法来实现的，

Integer 的自动拆箱都是通过integer.intValue 来实现的。

先来看个自动装箱的代码

反编译后代码如下:

从反编译得到内容可以看出

装箱过程是通过调用包装器的valueOf 方法实现的

再来看个自动拆箱的代码：

反编译后代码如下：

从反编译得到内容可以看出

拆箱过程是通过调用包装器的xxxValue 方法实现的。

对象相等比较

在Java 5 中，在Integer 的操作上，引入了一个新功能，来节省内存和提高性能。

整型对象，通过使用相同的对象引用，实现了缓存和重用。

适用于整数值区间-128 至+127。

只适用于自动装箱。使用构造函数创建对象不适用。

代码为什么会不报错呢

将上面代码进行反编译

看以下代码：

反编译后的代码

实例代码

反编译后的代码

反编译后代码

子主题

看以下代码，猜测一下输出结果

普遍认为上面的两个判断的结果都是false。

虽然比较的值是相等的，但是由于比较的是对象，而对象的引用不一样，所以会认为两个if 判断都是false 的。

在Java 中，==比较的是对象应用，而equals 比较的是值。

所以，在这个例子中，不同的对象有不同的引用，所以在进行比较的时候都将返回false。

奇怪的是，这里两个类似的if 条件判断返回不同的布尔值。

integer1 == integer2
integer3 != integer4

在创建对象之前先从IntegerCache.cache 中寻找。如果没找到才使用new 新建对象。

子主题

子主题

变量p 的值

Boolean success
boolean isSuccess
Boolean success
Boolean isSuccess

前两种和后两种的主要区别是变量的类型不同，前者使用的是boolean，后者使用的是Boolean。

第一种和第三种在定义变量时，变量命名是success，而另外两种使用isSuccess 来命名的。

子主题

以上代码的setter/getter 是使用IDEA自动生成的，仔细观察以上代码，你会发现以下规律：

 基本类型自动生成的getter 和setter 方法，名称都是isXXX()和setXXX()形式的。
 包装类型自动生成的getter 和setter 方法，名称都是getXXX()和setXXX()形式的。

关于Java Bean 中的getter/setter 方法的定义其实是有明确的规定的，根据JavaBeans(TM) Specification 规定，

如果是普通的参数propertyName，要以下方式定义其setter/getter：

但是，布尔类型的变量propertyName 则是单独定义的：

通过对照这份JavaBeans 规范发现，在Model4 中，变量名为isSuccess，如果严格按照规范定义的话，他的getter 方法应该叫isIsSuccess。

但是很多IDE 都会默认生成为isSuccess。

在一般情况下，其实是没有影响的。

但是有一种特殊情况就会有问题，那就是发生序列化的时候。

关于序列化和反序列化请参考Java 对象的序列化与反序列化。我们这里拿比较常用的JSON 序列化来举例，

看看看常用的fastJson、jackson 和Gson 之间有何区别：

以上代码输出结果：

在fastjson 和jackson 的结果中，原来类中的isSuccess 字段被序列化成success，并且其中还包含hollis 值。

而Gson 中只有isSuccess 字段。

fastjson 和jackson

Gson

可以看到，由于不同的序列化工具，在进行序列化的时候使用到的策略是不一样的，

所以，对于同一个类的同一个对象的序列化结果可能是不同的。

前面提到的关于对getHollis 的序列化只是为了说明fastjson、jackson 和Gson 之间的序列化策略的不同，

我们暂且把他放到一边，我们把他从Model3 中删除后，重新执行下以上代码，得到结果：

现在，不同的序列化框架得到的json 内容并不相同，

以上代码，输出结果：Model3[isSuccess=false]

这和预期的结果完全相反，原因是因为JSON 框架通过扫描所有的getter 后发现
有一个isSuccess 方法，然后根据JavaBeans 的规范，解析出变量名为success，把
model 对象序列化城字符串后内容为{"success":true}。

根据{"success":true}这个json 串，Gson 框架在通过解析后，通过反射寻找Model
类中的success 属性，但是Model 类中只有isSuccess 属性，所以，最终反序列化后的
Model 类的对象中，isSuccess 则会使用默认值false。

但是，一旦以上代码发生在生产环境，这绝对是一个致命的问题。

所以，作为开发者，我们应该想办法尽量避免这种问题的发生，

对于POJO 的设计者来说，只需要做简单的一件事就可以解决这个问题了，那就是把isSuccess改为success。

这样，该类里面的成员变量时success，getter 方法是isSuccess，这是完全符合JavaBeans 规范的。

无论哪种序列化框架，执行结果都一样。就从源头避免了这个问题。

对于这个规定的评价

boolean success
Boolean success

以上代码输出结果为：default model : Model[success=null, failure=false]

可以看到，当没有设置Model 对象的字段的值时，Boolean 类型的变量会设置默认值为null，而boolean 类型的变量会设置默认值为false。

即对象的默认值是null，boolean 基本数据类型的默认值是false。

我们做一个扣费系统，扣费时需要从外部的定价系统中，读取一个费率的值，预期该接口的返回值中会包含一个浮点型的费率字段。

当取到这个值得时，就使用公式：金额*费率=费用进行计算，计算结果进行划扣。

如果由于计费系统异常，他可能会返回个默认值

如果扣费系统对于该费率返回值没做特殊处理的话，拿到null 值进行计算会直接报错，阻断程序。

拿到0.0 可能就直接进行计算，得出接口为0 后进行扣费了。这种异常情况就无法被感知。

用来接收调用该函数时传入的参数

在调用函数时，实参将赋值给形参

右边的值可以是任何常 数、变量或者表达式

左边的值必须是一个明确的，已经定义的变量。比如int a = 4

对于对象来说，复制的不是对象的值，而是对象的引用

将一个对象复制绐另一个对象，实际上是将一个对象的引用赋值给另一个对象。

二目运算符

结合方向是从左到右

操作元是整型或浮点型数据

优先级是4级

二目运算符

结合方向是从左到右

操作元是整型或浮点型数据

优先级是3级

图解算数运算符

用算术符号和括号连接起来的符合java语法规则的式子 

当一个表达式中存在多个操作符时，操作符的优先级顺序就 决定了计算顺序

最简单的规则就是先乘除后加减，（）的优先级最高

没必要记住所有的优先级顺 序，不确定的直接用0就可以了

精度从“低”到“高”排列顺序

Java在计算算术表达式的值时，使用下列计算精度规则

子主题

子主题

由于java和C语言的不同处理机制导致的：

if()语句括号中为比较表达式，返回值要么是true，要么是false，

if(x=y)是将y赋值给x，但是数据类型是int类型的，编译不能通过，
如果把代码改为这样：
boolean x = false;
boolean y = ture;
if(x=y){...}这样就就不会报错了，编译正常通过。
1、Java中，赋值是有返回值的 ，赋什么值，就返回什么值。比如这题，x=y，返回y的值，所以括号里的值是1。
2、Java跟C的区别，C中赋值后会与0进行比较，如果大于0，就认为是true；而Java不会与0比较，而是直接把赋值后的结果放入括号。

与、或、非

&&，||，!

逻辑运算符对应的true/false符号表

逻辑运算符对应的true/false符号表

&是逻辑与，&&是短路与。

短路与只要与左边的条件为false就能判断整个条件为false，而逻辑与两边都需要判断。

图解

如果比较的双方是数字，那么进行比较就会变成按位运算符

按位进行与运算（AND）

两个操作数中位都为1,结果才为1,否则结果为0。

需要首先把比 较双方转换成二进制再按每个位进行比较

“按位与”运算符“&”是双目运算符

按位进行或运算（OR）

两个位只要有一个为1,那么结果就是1,否则就为0。

“按位或”运算符：“|”是二目运算符

按位进行异或运算（XOR）

如果位为0,结果是1,如果位为1,结果是0。

“按位非”运算符：“~”是单目运算符。

按位进行取反运算（NOT）

两个操作数的位中，相同则结果为0,不同则结果为1。

“按位异或”运算符：“^”是二目运算符。 

图解

instanceof是双目运算符

类似于==，>，< 等操作符。

instanceof 是Java 的一个二元操作符，

instanceof运算符是Java独有的运算符号。

演示Java instanceof 关键字用法

举例

举例

说明

这是instanceof操作符一个很重要的特性，使得对类型强制转换检查很有用

静态变量为null调用静态方法不会抛出NullPointerException。因为静态方法使用了静态绑定。

例如

number没有赋值，所以默认为null

使用String.value(number)静态方法，没有抛出空指针异常，

但是使用toString()却抛出了空指针异常。

如下所示：null判断

if条件语句

if...else条件语句

if...else if多分支语句

一种比if...else if语句更优雅的方式是使用switch多分支语句

switch 语句是单条件多分支的开关语句，： 

switch(整数){
    case 整数值 1: 语句; break;
    case 整数值 2: 语句; break;
    case 整数值 3: 语句; break;
    ……………………..
    default: 语句;
}

switch(表达式) {
   case 常量值1:
               若干个语句
               break;
   case  常量值2:
               若干个语句
               break;
    ...
   case  常量值n:
              若干个语句
              break;
   default:
         若干语句
}

(其中break语句是可选的）

while循环语句

do...while 循环

for循环语句

for-each 语句

break、continue和return

用关键break或continue加上分号构成的语句

在循环体中可以使用break语句和continue语句

break语句

continue 语句

return语句

如：  import java.util.Date;

如：import tom.jiafei.*;

如果一个源文件使用了一个无名包中的A类，同时又用import语句引入了某个有包名的同名的类，如tom.jiafei中的A类，就可能引起类名的混淆。 

如果一个源文件引入了两个包中同名的类，那么在使用该类时，不允许省略包名 。

package 包名; 

package sunrise;

package sun.com.cn;

例如：package tom.jiafei;

…\tom\jiafei

如c:\1000\tom\jiafei

c:\1000\tom\jiafei中

tom.jiafei

…\tom\jiefei

tom\jiefei

静态变量只能使用static关键字进行修饰

静态变量可以通过类名.变量名进行访问

方法声明

方法体

局部变量不能使用访问修饰符

例如

“class Vehicle”称作类声明；

“Vehicle”是类名。

变量的声明

方法的定义

属性

局部变量

参数

非静态属性也就被称为实例变量，因为它们的值是相对于每个实例来说的。

换句话说，对于每个对象来讲，实例变量的值都是唯一的；

定义在构造方法、代码块、方法外的变量被称为实例变量

实例变量的副本数量和实例的数量一样。

类变量就是使用static修饰符声明的字段

 这就会告诉编译器：无论该类被实例化了多少次， 该变量只存在一个副本。

另外， 可以添加关键字final来表示常量。

没有特殊的关键字将制定的变量声明为局部变量、确定其声明的完全取决于声明变量的位置。

定义在方法、构造方法、代码块内的变量被称为局部变量；

定义在方法参数中的变量被称为参数

平常用到最多的方法是什么方法?当然是main方法啊，

参数也没有关键字进行声明，标识其为参数也只是取决于其声明位置。

子主题

package strategy;
public class Main {
    public static void main(String[] args) {
        if (LevelEnum.LEVEL1.equals(1)) {
            SupervisorControl supervisorControl = new SupervisorControl(new Supervisor1());
            supervisorControl.execute(1);
        }
        if (LevelEnum.LEVEL2.equals(2)) {
            SupervisorControl supervisorControl = new SupervisorControl(new Supervisor2());
            supervisorControl.execute(2);
        }
        if (LevelEnum.LEVEL3.equals(3)) {
            SupervisorControl supervisorControl = new SupervisorControl(new Supervisor3());
            supervisorControl.execute(3);
        }
    }
}

package strategy;

public enum LevelEnum {
    LEVEL1, LEVEL2, LEVEL3
}

package strategy;

public interface Supervisor {
    void examine(int supervisorId);
}

package strategy;
public class Supervisor1 implements Supervisor {
    public void examine(int supervisorId) {
        System.out.println("去做一些和1级supervisor相关的工作");
    }
}

package strategy;
public class Supervisor2 implements Supervisor {
    public void examine(int supervisorId) {
        System.out.println("去做一些和2级supervisor相关的工作");
    }
}

package strategy;
public class Supervisor3 implements Supervisor {
    public void examine(int supervisorId) {
        System.out.println("去做一些和3级supervisor相关的工作");
    }
}

package strategy;

public class SupervisorControl {
    Supervisor supervisor;
    public SupervisorControl(Supervisor supervisor) {
        this.supervisor = supervisor;
    }
    public void execute(int id) {
        supervisor.examine(id);
    }
}

创建黑白双方的对象负责演算，棋盘的对象负责画布，规则的对象负责判断，

例子可以看出，面向对象更重视不重复造轮子，即创建一次,重复使用。

开始—黑走—棋盘—判断—白走—棋盘—判断—循环。

只需要关注每一步怎么实现即可。

占用资源相对高,速度相对慢。

占用资源相对低,速度相对快

class Jerry {
   void g() {
       Tom cat=new Tom();
       cat.weight=23f;    //非法
       float sum=cat.f(3,4);   //非法
    }
}

class Jerry {
  void g() { 
        Tom cat=new Tom();
         cat.weight=23f;     //合法
         float sum=cat.f(3,4);   //合法
    }
}

class Jerry {  
   void g() {
        Tom cat=new Tom();
        cat.weight=23f;       //合法
        float sum=cat.f(3,4);   //合法
    }
}

class Jerry {  
   void g() {
        Tom cat=new Tom();
        cat.weight=23f;      //合法
        float sum=cat.f(3,4); //合法
    }
}

一个类A中的protected成员变量和方法可以被它的直接子类和间接子类继承

如B是A的子类，C是B的子类，D又是C的子类，那么B、C和D类都继承了A类的protected成员变量和方法。

如果用D类在D中创建了一个对象,该对象总是可以通过“.”运算符访问继承的或自己定义的protected变量和protected方法的,但是,如果在另外一个类中,如在Other类中用D类创建了一个对象object，该对象通过“.”运算符访问protected变量和protected方法的权限如所述。

（1）对于子类D中声明的protected成员变量和方法，如果object要访问这些protected成员变量和方法，只要Other类和D类在同一个包中就可以了。

（2）如果子类D的对象的protected成员变量或protected方法是从父类继承的，那么就要一直追溯到该protected成员变量或方法的“祖先”类，即A类，如果Other类和A类在同一个包中，那么object对象能访问继承的protected变量和protected方法。

因为要复用

需要定义一个标准

图解多态的必要条件

这样，就实现了多态，同样是Parent 类的实例，p.call 调用的是Son 类的实现、p1.call 调用的是Daughter 的实现。

有人说，你自己定义的时候不就已经知道p 是son，p1 是Daughter 了么。但是，有些时候你用到的对象并不都是自己声明的啊。

比如Spring 中的IOC 出来的对象，你在使用的时候就不知道他是谁，或者说你可以不用关心他是谁。根据具体情况而定。

例如， import java.io.*; 

所有的方法隐含的都是抽象的

类如果要实现一个接口，它必须要实现接口声明的所有方法。

Java接口中声明的变量默认都是final的。

接口内不能有构造方法

接口是绝对抽象的，不可以被实例化。

访问修饰符

数量

可同时包含抽象和非抽象的方法

类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

抽象类可以在不提供接口方法实现的情况下，实现接口。

抽象类可以包含非final的变量。

抽象类可以有构造方法

抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

数量

访问修饰符

在继承结构中，父类的内部细节对于子类是可见的。

通常也可以说通过继承的代码复用是一种白盒式代码复用。

（如果基类的实现发生改变，那么派生类的实现也将随之改变。这样就导致了子类行为的不可预知性。）

通过对现有的对象进行拼装（组合）产生新的、更复杂的功能

因为在对象之间，各自的内部细节是不可见的

所以我们也说这种方式的代码复用是黑盒式代码复用。

（因为组合中一般都定义一个类型，所以在编译期根本不知道具体会调用哪个实现类的方法）

在写代码的时候就要指名具体继承哪个类，所以，在编译期就确定了关系。

（从基类继承来的实现是无法在运行期动态改变的，因此降低了应用的灵活性。）

组合，在写代码的时候可以采用面向接口编程

所以，类的组合关系一般在运行期确定。

组合和继承是有区别的

子主题

子主题

“class Vehicle”称作类声明；

“Vehicle”是类名。

变量的声明

方法的定义

（1）声明对象时的内存模型

rectangle1在内存中还没有任何数据

声明对象变量rectangle1后，rectangle1在内存中还没有任何数据，称这时的rectangle1是一个空对象。

空对象不能使用，必须再进行为对象分配变量的步骤。

new的意思，绐我一个新对象　

（2）对象分配内存后的内存模型

为对象分配变量后的内存模型

get Result就是方法名称

方法的名字

()里面表示方法接收的参数

有一种特殊的参数类型，void，表示方法无返 回值。

方法的参数

方法的返回类型

return表示方法的返回值

方法的返回值必须和方法的参数类型保持一致

当对象调用实例方法时，该方法中出现的实例变量就是分配给该对象的实例变量；

该方法中出现的类变量也是分配给该对象的变量，只不过这个变量和所有的其他对象共享而已。

类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。

和实例方法不同的是，类方法不可以操作实例变量，这是因为在类创建对象之前，实例成员变量还没有分配内存。

static修饰变量

static String name = "cxuan";

 public class StaicBlock {
    static{
       System.out.println（"I'm A static code block"）;
    }
}

在一个方法定义中加上static关键字进行修饰

最常用的

与静态变量一样，静态方法是属于类，而不是实例。

可以在不用创建对象的前提下，就能够访问static方法

static方法就是没有this的方法， 在static内部不能调用非静态方法，

由于静态方法不依赖于任何对象就可以直接访问，因此对于静态方法来说，是没有this关键字的，实例变量都会有this关键字。

静态方法能够直接使用类名.方法名进行调用。

可以在不用创建对象的前提下，就能够访问static方法

如何做到呢?

通常静态方法，通常用于想给其他的类使用而不需要创建实例。

在静态方法中不能访问类的非静态成员变量和非静态方法，

一个静态方法只能使用静态变量和调用静态方法

图解

非静态方法内部可以调用static静态方法

由于静态代码块随着类的加载而执行

因此，很多时候会将只需要进行一次的初始化操作放在static代码块中进行。

static关键字可以用来修饰代码块， 

static修饰的代码块被称为静态代码块。

静态代码块可以置于类中的任何地方

类中可以有多个static块

在类初次被加载时， 会按照static代码块的顺序来执行

每个static修饰的代码块只能执行一次。

Java 的静态块是一组指令在类装载的时候在内存中由Java ClassLoader 执行。

静态块常用于初始化类的静态变量。

大多时候还用于在类装载时候创建静态资源。

Java 不允许在静态块中使用非静态变量。

一个类中可以有多个静态块，尽管这似乎没有什么用。

静态代码块的例子

只会在类加载时执行一次。

静态块只在类装载入内存时，执行一次。

因为static修饰的变量保存在方法区中， 只有堆内存才会被序列化。

防止对象进行序列化操作

是什么？

transient 关键字的作用是控制变量的序列化

使用情况

如果线程t1执行到singleton==null后， 判断对象为null， 此时线程把执行权交给了t2， t2判断对象
为null， 锁住Singleton类对象， 进行下面的判断和实例化过程。

如果不进行第二次判断的话， 那么t1在进行第一次判空后，也会进行实例化过程，此时仍然会创建多个对象。

从JVM指令角度去看

生成StaticTest的字节码

JVM规范,invokespecial指令

https：//docs.oracle.com/javase/specs/jvms/se7/htm/jvms-6.html#jvms-6.5.invoke static

如：
final class A {
…
} 

final class Parent {
}

以上类不能被继承！

class Parent{
     final void name() {
     System.out.println("Hollis");
}}

当定义以上类的子类时，无法覆盖其name 方法，会编译失败。

子主题

String也是一种对象，对象的初始值都为null，

其中也包括基本类型的包装类。

指定a的初始化值不是0,而是11。

this必须放在构造方法的第一行，否则编译不通过

在构造方法中使用this

main方法中传递了一个int值为10的参数，

它表示的就是苹果的数量，并把这个数量赋绐了 num全 局变量。

所以num的值现在就是10。

在“严格求值”中，函数调用过程中，给函数的实际参数总是在应用这个函数之前求值。

所以，我们本文只关注严格求值。

在严格求值中有几个关键的求值策略是我们比较关心的

传值调用（Call by value）（值传递）

传引用调用（Call by reference）（引用传递）

传共享对象调用（Call by sharing）（共享对象传递）

可以看到，对象类型在被传递到pass 方法后，在方法内改变了其内容，最终调用方main 方法中的对象也变了。

所以，很多人说，这和引用传递的现象是一样的，就是在方法内改变参数的值，会影响到调用方。

如果没有明确，那么就是Object以及任意的Java类了

向下限定，E及其子类

向上限定，E及其父类

无法保证传入的值为合法

"你好"、"12.97"、"boy"

String str = "Hollis";

String s;

s=new String("we are students");

String str = new String("Hollis")；

例如： String tom=String(s); 

可缓存hashcode、

使用更加便利

使用更加安全

String s = "abcd";

String s2 = s;

s = s.concat("ef");

substring(int start ,int end)

substring(int beginIndex, int endIndex)方法

截取字符串并返回其[beginIndex,endIndex-1]范围内的内容。

String tom = "我喜欢篮球";
String s = tom.substring(1,3);

输出内容：bc

因为x 是不可变的，当使用x.substring(1,3)对x 赋值时，它会指向一个全新的字符串

指向一个全新的字符串

然而，这个图不是完全正确的表示堆中发生的事情。

因为在jdk6 和jdk7 中，调用substring 时发生的事情并不一样。

了解他们的区别可以帮助你更好的使用他

JDK 6 中的substring，使用不当，字符数组一直在被引用，无法被回收会导致内存泄露的问题

JDK 7 中的substring，创建了一个新字符串，避免对老字符串的引用，从而解决了内存泄露问题

所以，如果生产环境中使用的JDK 版本小于1.7，使用String 的subString方法时，一定要注意，避免内存泄露。

注：tom == jerry的值是false

内存示意图

indexOf(String s ,int startpoint)

lastIndexOf (String s)

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

没有重写equals时，是直接用==判断的，而String中重写了equals方法。

子主题

元字符

限定符

match：正则表达式的字符串匹配

String类的match方法

用replacement 替换所有的target，两个参数都是字符串。

replace()替换字符串

replace：用于字符串替换

System.out.println("abac".replace("a", "\a")); //\ab\ac

用replacement 替换所有的regex 匹配项，regex 很明显是个正则表达式，replacement 是字符串。

字符串对象调用replaceAll方法返回一个字符串，

该字符串是当前字符串中。

替换符合正则的所有文字

替换的内容不同，替换所有匹配的字符

代码

基本和replaceAll 相同，区别是只替换第一个匹配项。

替换第一个符合正则的数据

替换的内容不同，仅替换第一次出现的字符。

代码

以下例子参考：http://www.51gjie.com/java/771.html

split：字符串分割

字符串调用split使用参数指定的正则表达式regex做为分隔标记分解出其中的单词，并将分解出的单词存放在字符串数组中。

对于字符串 str=“1931年09月18日晚, 日本发动侵华战争, 请记住这个日子！”;

使用正则表达式：String regex="\\D+"; 

做为分隔标记分解出str中的单词： String digitWord[]=str.split(regex);

那么，digitWord[0]、digitWord[1]和digitWord[2]就分别是"1931"、"09"和"18"。

使用String.split分割字符串，注意处理分隔符中的一些特殊字符

使用StringTokenizer分割字符串

利用字符串和数组的关系，使用一个字符串password作为密码对另一个字符串sourceString进行加密

操作过程如下

例如：
    int x; 
    String s = "876"; 
       x = Integer.parseInt(s); 

等价与String i1 = (new StringBuilder()).append(i).toString();

public static String valueOf（byte n）

把对象转换为字符串

可以使用String 类的valueOf方法，将形如123、1232.98等数值转化为字符串。

String.valueOf(i)也是调用Integer.toString(i)来实现的

本质上和String.valueOf(i);一样

静态方法：static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的String。

ch=ch.copyValueOf(arr); 

System.out.println(ch);

 构造方法：String(char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列

String result=new String (arr);

 System.out.println(result);

static String valueOf(char[] data)
返回 char 数组参数的字符串表示形式。

mString = mString.valueOf(mArray);

在String的函数中，提供了indexOf（subStr）方法，返回子串subStr第一次出现的位置，如果不存在则返回-1。

//包含Java
assertEquals(7, "Pkslow Java".indexOf("Java"));
//如果包含多个，返回第一次出现位置
assertEquals(0, "Java Java".indexOf("Java"));
//大小写敏感
assertEquals(-1, "Google Guava".indexOf("guava"));

最直观判断的方法是contains（subStr），返回类型为boolean，如果包含返回true，不包含则返回false。

实际上，String的contains方法是通过调用indexOf方法来判断的，源码如下：
public boolean contains(CharSequence s) {
             return indexOf(s.toString()) > -1;
}

//包含Java
assertTrue("code in Java".contains("Java"));
//大小写敏感，不包含GO
assertFalse("Let's go".contains("GO"));
//转为大写后包含
assertTrue("Let's go".toUpperCase().contains("GO")); 

通过强大的正则匹配来判断，虽然有点杀鸡用牛刀的感觉，但也不是不能用，

Pattern pattern = Pattern.compile("Java");
//包含Java
Matcher matcher1 = pattern.matcher("Python, Java, Go, C++");
assertTrue(matcher1.find());
//不包含Java
Matcher matcher2 = pattern.matcher("Python, C, Go, Matlab");
assertFalse(matcher2.find());

Apache的commons-lang3提供许多开箱即用的功能，StringUtils就提供了许多与字符串相关的功能

//包含sub
assertTrue(StringUtils.contains("String subString", "sub"));
//大小写敏感
assertFalse(StringUtils.contains("This is Java", "java"));
//忽略大小写
assertTrue(StringUtils.containsIgnoreCase("This is Java", "java"));

性能最好的是String的indexOf方法和contains方法，建议使用contains方法，性能好，跟indexOf相比，更直观，更不容易犯错。

毕竟让每个人时刻记住返回-1代表不存在也不是一件容易的事。

在String的函数中，提供了indexOf（subStr）方法，返回子串subStr第一次出现的位置，如果不存在则返回-1。

例子如下：

最直观判断的方法是contains（subStr），返回类型为boolean，如果包含返回true，不包含则返回false。

例子如下

实际上，String的contains方法是通过调用indexOf方法来判断的

通过强大的正则匹配来判断，虽然有点杀鸡用牛刀的感觉，但也不是不能用

例子如下

Apache的commons-lang3提供许多开箱即用的功能，StringUtils就提供了许多与字符串相关的功能

例子如下

org.openjdk.jmh
 jmh-core
 ${openjdk.jmh.version}
 
 
 org.openjdk.jmh
 jmh-generator-annprocess
 ${openjdk.jmh.version}

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class StringContainsPerformanceTest {
    @State(Scope.Thread)
    public static class MyState {
        private String text = "If you want to be smart; read. If you want to be really smart; read a lot.";
        Pattern pattern = Pattern.compile("read");
    }
 
    @Benchmark
    public int indexOf(MyState state) {
        return state.text.indexOf("read");
    }
 
    @Benchmark
    public boolean contains(MyState state) {
       return state.text.contains("read");
    }
 
    @Benchmark
    public boolean stringUtils(MyState state) {
        return StringUtils.contains(state.text, "read");
    }
 
    @Benchmark
    public boolean pattern(MyState state) {
        return state.pattern.matcher(state.text).find();
    }
 
    public static void main(String[] args) throws Exception {
        Options options = new OptionsBuilder()
                .include(StringContainsPerformanceTest.class.getSimpleName())
                .threads(6)
                .forks(1)
                .warmupIterations(3)
                .measurementIterations(6)
                .shouldFailOnError(true)
                .shouldDoGC(true)
                .build();
        new Runner(options).run();
    }
}

Benchmark    Mode  Cnt    Score    Error  Units
contains     avgt    6   11.331 ±  1.435  ns/op
indexOf      avgt    6   11.250 ±  1.822  ns/op
pattern      avgt    6  101.196 ± 12.047  ns/op
stringUtils  avgt    6   29.046 ±  3.873  ns/op

最快的就是indexOf方法，其次是contains方法，二者应该没有实际区别，contains是调用indexOf来实现的。。

Apache的StringUtils为第三方库，相对慢一些。

最慢的是使用了正则的Pattern的方法，这不难理解，正则引擎的匹配是比较耗性能的

这个序列化接口没有任何方法和域， 仅用于标识序列化的语意。

实现了Comparable的接口可用于内部比较两个对象的大小

字符串序列接口

CharSequence是一个可读的char值序列

提供了几个对字符序列进行只读访问的方法

StringBuilder和StringBuffer也继承了这个接口

intern()方法是一个native方法

它底层由C/C++实现

把字符串缓存起来

各个线程共享的内存区域

用于存储虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

static修饰的变量存储在方法区中

又被称为Runtime Constant Pool

这块区域是方法区的一部分

它的名字非常有意思，它并不要求常量一定只有在编译期才能产生

并非编译期间将常量放在常量池中， 运行期间也可以将新的常量放入常量池中，

 String的intern方法就是一个典型的例子。

堆是线程共享的数据区

所有的对象实例， 包括实例变量都在堆上进行相应的分配。

线程私有的数据区

Java虚拟机栈的生命周期与线程相同

虚拟机栈也是局部变量的存储位置。

方法在执行过程中， 会在虚拟机栈种创建一个栈帧(stack frame) 。

线程私有的数据区

这部分区域用于存储线程的指令地址

用于判断线程的分支、循环、跳转、异常、线程切换和恢复等功能，这些都通过程序计数器来完成。

线程私有的数据区

本地方法栈存储的区域主要是Java中使用native关键字修饰的方法所存储的区域

把方法区放到了永久代(Java堆的一部分)

永久代的空间是有限的

 除了Full GC外， 其他收集并不会释放永久代的存储空间，

常量池是分配在方法区中永久代(Parmanent Generation) 内的

 而永久代和Java堆是两个完全分开的区域中， 并且返回此String对象的引用。

如果字符串常量池中已经包含一个等于此String对象的字符串， 则返回常量池中这个字符串的String对象

 否则， 将此String对象包含的字符串添加到常量池

一些人把方法区称为永久代， 这种说法不准确， 仅仅是Hotspot虚拟机设计团队选择使用永久代来实现方法区而已。

将字符串常量池移到了堆内存中

去永久代， 字符串常量池已经被转移至Java堆中，开发人员也对intern方法做了一些修改。

因为字符串常量池和new的对象都存于Java堆中， 为了优化性能和减少内存开销， 当调用intern方法时，

false true true false

intem方法的官方解释

输出什么?false， 为什么呢?

a.intern返回的是常量池中的ab， 而b是直接返回的是堆中的ab.地址不一样， 肯定输出false

图解

都返回的是字符串常量池中的ab， 地址相同，所以输出true

图解

a不会变，因为常量池中已经有了ab，

所以c不会再创建一个ab字符串，这是编译器做的优化，为了提高效率。

图解

子主题

图解

switch 对整型的支持是怎么实现的呢？

对字符型是怎么实现的呢？

String 类型呢？

switch 对String 的支持是使用

定义一个int 型变量a，然后使用switch 语句进行判断。执行这段代码输出内容为5，

样例代码

对代码进行反编译

反编译后的代码和之前的代码比较，除了多了两行注释以外没有任何区别，

switch 对整型int的判断是直接比较整数的值。

样例代码

对代码进行反编译

样例代码

对代码进行反编译

字符串的switch 是通过equals()和hashCode()方法来实现的。

记住，switch 中只能使用整型，比如byte，short，char(ackii 码是整型)以及int。

还好hashCode()方法返回的是int，而不是long。通过这个很容易记住hashCode返回的是int 这个事实。

这个检查是必要的，因为哈希可能会发生碰撞。

因此它的性能是不如使用枚举进行switch 或者使用纯整数常量，但这也不是很差。

因为Java 编译器只增加了一个equals 方法，如果你比较的是字符串字面量的话会非常快，

比如”abc”==”abc”。

因为字符串一旦创建了，它就会把哈希值缓存起来。

因此如果这个switch 语句是用在一个循环里的，比如逐项处理某个值，或者游戏引擎循环地渲染屏幕，

这里hashCode()方法的调用开销其实不会很大。

import java.io.UnsupportedEncodingException;

/**
 * 转换字符串的编码
 */
public class ChangeCharset {
 /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */
 public static final String US_ASCII = "US-ASCII";

 /** ISO 拉丁字母表 No.1，也叫作 ISO-LATIN-1 */
 public static final String ISO_8859_1 = "ISO-8859-1";

 /** 8 位 UCS 转换格式 */
 public static final String UTF_8 = "UTF-8";

 /** 16 位 UCS 转换格式，Big Endian（最低地址存放高位字节）字节顺序 */
 public static final String UTF_16BE = "UTF-16BE";

 /** 16 位 UCS 转换格式，Little-endian（最高地址存放低位字节）字节顺序 */
 public static final String UTF_16LE = "UTF-16LE";

 /** 16 位 UCS 转换格式，字节顺序由可选的字节顺序标记来标识 */
 public static final String UTF_16 = "UTF-16";

 /** 中文超大字符集 */
 public static final String GBK = "GBK";

 /**
  * 将字符编码转换成US-ASCII码
  */
 public String toASCII(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, US_ASCII);
 }
 /**
  * 将字符编码转换成ISO-8859-1码
  */
 public String toISO_8859_1(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, ISO_8859_1);
 }
 /**
  * 将字符编码转换成UTF-8码
  */
 public String toUTF_8(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_8);
 }
 /**
  * 将字符编码转换成UTF-16BE码
  */
 public String toUTF_16BE(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_16BE);
 }
 /**
  * 将字符编码转换成UTF-16LE码
  */
 public String toUTF_16LE(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_16LE);
 }
 /**
  * 将字符编码转换成UTF-16码
  */
 public String toUTF_16(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_16);
 }
 /**
  * 将字符编码转换成GBK码
  */
 public String toGBK(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, GBK);
 }
 
 /**
  * 字符串编码转换的实现方法
  * @param str  待转换编码的字符串
  * @param newCharset 目标编码
  * @return
  * @throws UnsupportedEncodingException
  */
 public String changeCharset(String str, String newCharset)
   throws UnsupportedEncodingException {
  if (str != null) {
   //用默认字符编码解码字符串。
   byte[] bs = str.getBytes();
   //用新的字符编码生成字符串
   return new String(bs, newCharset);
  }
  return null;
 }
 /**
  * 字符串编码转换的实现方法
  * @param str  待转换编码的字符串
  * @param oldCharset 原编码
  * @param newCharset 目标编码
  * @return
  * @throws UnsupportedEncodingException
  */
 public String changeCharset(String str, String oldCharset, String newCharset)
   throws UnsupportedEncodingException {
  if (str != null) {
   //用旧的字符编码解码字符串。解码可能会出现异常。
   byte[] bs = str.getBytes(oldCharset);
   //用新的字符编码生成字符串
   return new String(bs, newCharset);
  }
  return null;
 }

 public static void main(String[] args) throws UnsupportedEncodingException {
  ChangeCharset test = new ChangeCharset();
  String str = "This is a 中文的 String!";
  System.out.println("str: " + str);
  String gbk = test.toGBK(str);
  System.out.println("转换成GBK码: " + gbk);
  System.out.println();
  String ascii = test.toASCII(str);
  System.out.println("转换成US-ASCII码: " + ascii);
  gbk = test.changeCharset(ascii,ChangeCharset.US_ASCII, ChangeCharset.GBK);
  System.out.println("再把ASCII码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String iso88591 = test.toISO_8859_1(str);
  System.out.println("转换成ISO-8859-1码: " + iso88591);
  gbk = test.changeCharset(iso88591,ChangeCharset.ISO_8859_1, ChangeCharset.GBK);
  System.out.println("再把ISO-8859-1码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf8 = test.toUTF_8(str);
  System.out.println("转换成UTF-8码: " + utf8);
  gbk = test.changeCharset(utf8,ChangeCharset.UTF_8, ChangeCharset.GBK);
  System.out.println("再把UTF-8码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf16be = test.toUTF_16BE(str);
  System.out.println("转换成UTF-16BE码:" + utf16be);
  gbk = test.changeCharset(utf16be,ChangeCharset.UTF_16BE, ChangeCharset.GBK);
  System.out.println("再把UTF-16BE码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf16le = test.toUTF_16LE(str);
  System.out.println("转换成UTF-16LE码:" + utf16le);
  gbk = test.changeCharset(utf16le,ChangeCharset.UTF_16LE, ChangeCharset.GBK);
  System.out.println("再把UTF-16LE码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf16 = test.toUTF_16(str);
  System.out.println("转换成UTF-16码:" + utf16);
  gbk = test.changeCharset(utf16,ChangeCharset.UTF_16LE, ChangeCharset.GBK);
  System.out.println("再把UTF-16码的字符串转换成GBK码: " + gbk);
  String s = new String("中文".getBytes("UTF-8"),"UTF-8");
  System.out.println(s);
 }
}

ResultSet rs;
bytep[] bytes = rs.getBytes();
String str = new String(bytes, "gb2312");

ResultSet rs;
String str = rs.getString();
str = new String(str.getBytes("iso8859-1"), "gb2312");

这种编码转换方式效率底。

全局字符串常量池

英文

保存在JVM内存的方法区中

在每个VM中只有一份

在HotSpotVM里实现的string pool功能的是一个StringTable类

它是一个哈希表，里面存的是key（字面量“abc”, 即驻留字符串）-value（字符串"abc"实例对象在堆中的引用）键值对

也就是说在堆中的某些字符串实例被这个StringTable引用之后，就等同被赋予了”驻留字符串”的身份。

这个StringTable在每个HotSpot VM的实例只有一份，被所有的类共享（享元模式）

当代码中出现双引号形式（字面量）创建字符串对象时，JVM 会先对这个字符串进行检查

如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回

否则，创建新的字符串对象，然后将这个引用放入字符串常量池，并返回该引用。

除了以上方式（字符串驻留或池化机制）之外，还有一种可以在运行期，将字符串内容放置到字符串常量池的办法，那就是使用intern。

在每次赋值时，使用String 的intern 方法，如果常量池中有相同值，就会重复使用该对象，返回对象引用。

JDK 7之前

JDK7

JDK 8

从编译说起

字节码（ByteCode）

字节码解除了Java 虚拟机和Java 语言间的耦合

当java文件被编译成class文件之后，就是会生成class常量池

通过javac 命令，生成class 文件

解读HelloWorld.class 文件（版本号后面的就是Class 常量池入口）

通过javap 命令，查看Class 文件中常量池

Java 虚拟机指令集

符号表

若干其他辅助信息

类的版本、字段、方法、接口等描述信息

常量池(constant pool table)

在《深入理解Java 虚拟》中有这样的表述：

Class 是用来保存常量的一个媒介场所，并且是一个中间场所。

在JVM 真的运行时，需要把常量池中的常量加载到内存中。

Runtime Constant Pool

运行时的内容，从常量池转化而来。

是每一个类或接口的常量池（Constant_Pool）的运行时表示形式。

将每个class常量池中的符号引用值转存到运行时常量池中，

也就是说，每个class都有一个运行时常量池，类在解析之后，将符号引用替换成直接引用，与全局常量池中的引用值保持一致。

它包括了若干种不同的常量：从编译期可知的数值字面量到必须运行期解析后，才能获得的方法或字段引用。

扮演了类似传统语言中符号表（ SymbolTable）的角色，不过它存储数据范围比通常意义上的符号表要更为广泛。

每一个运行时常量池都分配在Java 虚拟机的方法区之中，在类和接口被加载到虚拟机后，对应的运行时常量池就被创建出来。

字面量

符号引用

jvm在加载某个类时，必须经过装载、连接、初始化，而连接又包括验证、准备、解析三个阶段。

而当类加载到内存中后，jvm就会将class常量池中的内容存放到运行时常量池中，故运行时常量池也是每个类都有一个。

class常量池中存的是字面量和符号引用，也就是说Class常量池存的并不是对象的实例，而是对象的符号引用值。

而经过解析（resolve）之后，也就是把符号引用替换为直接引用，

解析的过程会去查询全局字符串池，也就是StringTable，以保证运行时常量池所引用的字符串与全局字符串池中所引用的是一致的。

根据Java 虚拟机规范约定：

每一个运行时常量池都在JVM方法区中分配，在加载类和接口到虚拟机后，就创建对应的运行时常量池。

在不同版本的JDK 中，运行时常量池所处的位置也不一样

以HotSpot 为例：

运行时常量池中包含了若干种不同的常量：

运行时常量池中的内容包含

想要搞清楚这个问题，首先我们需要翻阅一下String 的源码，看下其中是否有关于长度的限制或者定义。

String 类中有很多重载的构造函数，其中有几个是支持用户传入length 来执行长度的：

那么，是不是就可以认为String 能支持的最大长度就是这个值了呢？

错误: 常量字符串过长

明明String构造函数指定的长度是可以支持2147483647(2^31 - 1)，为什么以上无法编译呢？

那么问题就来了，因为要进入常量池，就要遵守常量池的有关规定。

javac 是将Java 文件编译成class 文件的一个命令，那么在Class 文件生成过程中，就需要遵守一定的格式。

常量池的定义

Class 文件中常量池的格式规定了，其字符串常量的长度不能超过65535。

尝试使用以下方式定义字符串

如果我们尝试以65534 个字符定义字符串，则会发现可以正常编译。

其实，关于这个值，在《Java 虚拟机规范》也有过说明：

上面提到的这种String 长度的限制是编译期的限制，也就是使用String s= “”;这种字面值方式定义的时候才会有的限制。

那么，String 在运行期有没有限制呢

int 是一个32 位变量类型，取正数部分来算的话，他们最长可以有：

编译时最大长度都要求小于65535 了，运行期怎么会出现大于65535 的情况呢

字符串有长度限制，在编译期，要求字符串常量池中的常量不能超过65535，并且在javac 执行过程中控制了最大值为65534。

在运行期，长度不能超过Int 的范围，否则会抛异常。

StringBuilder不是线程安全的

继承自AbstractStringBuilder

StringBuffer是线程安全的

可以在多线程场景下使用

StringBuffer比StringBuilder多了synchronized修饰符。

在单线程场景下，效率比较低， 因为有锁的开销。

线程安全的，为了解决String的操作产生很多中间String对象的问题。

同步方法是在对应的操作方法中简单粗暴的加上syncronized关键字。

StringBuffer append(long n)

StringBuffer append(boolean n)

StringBuffer append(float n)

StringBuffer append(double n)

StringBuffer append(char n)

deleteCharAt(int index)

删除当前StringBuffer对象实体的字符串中index位置处的一个字符。

这是一段很普通的代码，只不过对字符串s进行了+操作

通过反编译代码来看一下

所以， 执行几次后的结果如下

由于大量StringBuilder创建在堆内存中， 肯定会造成效率的损失

append

insert

delete

replace

charAt

StringBuilder 类也封装了一个字符数组

定义如下：char[] value;

char value； //存储字符数组

使用value表示存储的字符数组 

与String 不同的是，它并不是final 的，所以他是可以修改的。

字符数组中不一定所有位置都已经被使用，

它有一个实例变量，表示数组中已经使用的字符个数

使用count表示存储的字符串使用的计数

int count； //字符串使用的计数

定义如下：int count;

char value； //存储字符数组

int count； //字符串使用的计数

序列化接口， 表示对象可以被序列化

字符串序列接口

CharSequence是一个可读的char值序列

提供了几个对字符序列进行只读访问的方法

StringBuilder和StringBuffer也继承了这个接口

jdk自带的反汇编工具

对代码进行反汇编操作

根据class字节码文件， 反汇编出当前类对应的code区(汇编指令) 、本地变量表、异常表和代码行偏移量映射表、常量池等等信息。

其实最后我们得到的s 已经是一个新的字符串了。

s 中保存的是一个重新创建出来的String 对象的引用。

有人把Java 中使用+拼接字符串的功能理解为运算符重载。

其实并不是，Java 是不支持运算符重载的。

这其实只是Java 提供的一个语法糖。

Java 开发手册中不建议在循环体中使用+进行字符串拼接

其实只是Java 提供的一个语法糖

把他生成的字节码进行反编译，看看结果。

concat 方法的源代码

这段代码首先创建了一个字符数组，长度是已有字符串和待拼接字符串的长度之和，

再把两个字符串的值复制到新的字符数组中，并使用这个字符数组创建一个新的String 对象并返回。

通过源码可以看到，经过concat 方法，其实是new 了一个新的String，这也就呼应到前面说的字符串的不变性问题上了。

最主要的功能是：

其实它是通过StringBuilder来实现的。

其实它是通过StringBuilder来实现的。

StringBuilder<StringBuffer<concat<+<StringUtils.join

在StringBuilder 的基础上，做了同步处理，

所以在耗时上会相对多一些。

也是使用了StringBuilder，

并且其中还是有很多其他操作，所以耗时较长，这个也容易理解

更擅长处理字符串数组或者列表的拼接。

其实使用+拼接字符串的实现原理也是使用的StringBuilder

那为什么结果相差这么多，高达1000 多倍呢？

所以， Java 开发手册建议：循环体内，字符串的连接方式，使用StringBuilder 的append 方法进行扩展。而不要使用+。

其他版本

compareTo方法不同于equals方法，

compareTo方法的返回值是一个int类型

而equals方法返回的是boolean类型

NullPointerException：如果对象o为null， 抛出空指针异常

ClassCastException：如果需要类型转换之后进行比较， 可能会抛出ClassCastException

代码段2

false true false false

NullPointerException：如果对象o为null， 抛出空指针异常

ClassCastException：如果需要类型转换之后进行比较， 可能会抛出ClassCastException

输出数据后换行

输出数据后不换行

System.out.printf("格式控制部分"，表达式1，表达式2，…表达式n)

%d：输出int类型数据值

%c：输出char型数据

%f：输出浮点型数据，小数部分最多保留6位

%s：输出字符串数据

例如：

方法区(Method Area)

虚拟机栈(VM Stack)

本地方法栈(Native Method Stack)

堆(Heap)

⼀般是运⾏时异常， 继承⾃RuntimeException

RuntimeException是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。

非受检异常（ unchecked exception）

代码原因以及程序员的错误】

RuntimeException举例如：NullPointerException发⽣空指针异常、ArrayIndexOutOfBoundsException数组越界、ClassCastException类型转换异常；

检查异常CheckedException

如I/O错误导致的IOException、SQLException、FileNotFoundException。

这种异常在IO 操作中⽐较多

以FileNotFoundException为例

所以说， 当我们希望我们的⽅法调⽤者， 明确的处理⼀些特殊情况的时候， 就应该使⽤受检异常。

一般是外部错误，这种异常都发生在编译阶段

Java编译器会强制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行try catch

该类异常一般包括几个方面

⼀定要对该异常进⾏处理（ 捕获或者向上抛出），否则是⽆法编译通过的

举例：如I/O错误导致的IOException、SQLException、FileNotFoundException。