JavaSE总结(上)

程序

计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合

Java 技术体系平台

• JavaSE（标准版）

• 提供了完整的Java核心API

• JavaEE（企业版）

• 是为开发企业环境下应用程序的一套解决方案，主要针对于Web应用程序开发。

• JavaME（小型版）

• 支持Java程序运行在移动终端，加入了对移动端的支持

Java 重要特点

1. Java 语言是面向对象的(oop)

2. Java 语言是健壮的。Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证

3. Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台]

4. Java 语言是解释型的[了解]

1. 解释性语言：javascript,PHP, java 编译性语言: c / c++

2. 区别是：解释性语言，编译后的代码，不能直接被机器执行,需要解释器来执行, 编译性语言, 编译后的代码, 可以直接被机器执行, c /c++

Java 常见的开发工具

• idea

• 下载地址(opens new window)

• eclipse

• 下载地址(opens new window)

• notepad++

• sublime

• editplus

JVM

JVM（Java虚拟机）是Java 核心机制，JVM 是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器，包含在JDK 中，对于不同的平台，有不同的虚拟机。Java 虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”。

什么是 JDK，JRE

• JDK 的全称(Java Development Kit Java 开发工具包)

• JDK = JRE + java 的开发工具 [java, javac,javadoc,javap等]

• JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE 了。

• jdk下载地址：https://www.oracle.com/java/technologies/downloads/

• JRE(Java Runtime Environment Java 运行环境)

• JRE = JVM + Java 的核心类库[类]

• 包括 Java 虚拟机(JVM Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。

JDK = JRE + 开发工具集（例如 Javac,java 编译工具)
JRE = JVM + Java SE 标准类库（java 核心类库)
如果只想运行开发好的 .class 文件 只需要JRE

Java 常用的转义字符

• \t

• 一个制表位，实现对齐的功能

• \n

• 换行符

• \\

• 一个\

• \"

• 一个"

• \'

• 一个'

• \r

• 一个回车

Java 中的注释类型

用于注解说明解释程序的文字就是注释，注释提高了代码的阅读性（可读性）；注释是一个程序员必须要具有的良好编程习惯。
被注释的文字，不会被 JVM（java 虚拟机）解释执行

• 单行注释//

• 多行注释/* ...*/

• 文档注释/** ...*/

Java 变量

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。

变量必须先声明,后使用,即有顺序

数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

• byte

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；

• 默认值是 0；

• short

• short 数据类型是 16 位、有符号的以二进制补码表示的整数

• 默认值是 0；

• int

• int 数据类型是32位、有符号的以二进制补码表示的整数；

• 默认值是 0 ；

• long

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；

• 默认值是 0L；

• float

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；

• 默认值是 0.0f；

• double

• double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；

• 默认值是 0.0d；

• boolean

• boolean数据类型表示一位的信息；

• 只有两个取值：true 和 false；

• 默认值是 false；

• char

• char 类型是一个单一的 16 位 Unicode 字符；

• char 数据类型可以储存任何字符；

ASCII码

1. ASCII码:上个世纪60年代，美国制定了一套字符编码(使用一个字符)，对英语字符与二进制之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，只占用了一个字节的后面7位，最前面的1位统一规定为0。

2. 缺点：不能表示所有字符。

Unicode 编码

1. UTF-8是在互联网上使用最广的一种Unicode的实现方式(改进)

2. UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。

3. 使用大小可变的编码字母占1个字节，汉字占3个字节。

基本数据类型转换

自动类型转换

当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换。

Java 运算符

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

• 算术运算符

• 算术运算符是对数值类型的变量进行运算的，在 Java 程序中使用的非常多。

• 赋值运算符

• 关系运算符[比较运算符]

• 关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false

• 关系表达式 经常用在 if 结构的条件中或循环结构的

• 逻辑运算符

• 用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。

• && 和 & 使用区别:&&短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高。& 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低

• || 和 | 使用区别：||短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高。| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低。

• 位运算符[需要二进制基础]

• java 中有 7 个位运算(&、|、^、~、>>、<<和>>>）

• 左移乘以2，右移除以2

• 三元运算符

• 条件表达式 ? 表达式 1: 表达式2;

Java 程序控制结构

在程序中，程序运行的流程控制决定程序是如何执行的，主要有三大流程控制语句。

• 顺序控制

• 分支控制

• 循环结构

分支控制 if-else

让程序有选择的的执行,分支控制有三种

• 单分支if

• 双分支 if-else

• 多分支 if-else if -....-else

switch 和 if 的比较

• 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。

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

for循环控制

for(循环变量初始化;循环条件;循环变量迭代){
    循环操作(可以多条语句);
}

while循环控制

循环变量初始化;
while(循环条件){
    循环体(语句);
    循环变量迭代;
}

do...while循环控制

循环变量初始化;
do{
    循环体(语句);
    循环变量迭代;
}while(循环条件);

break、continue和return

• break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环[for , while , do-while]

• continue 语句用于结束本次循环，继续执行下一次循环。

• return 使用在方法，表示跳出所在的方法，注意：如果 return 写在 main 方法，退出程序。

Java 数组

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。

使用方式

• 数据类型 数组名=new 数据类型[大小];

• 数据类型 数组名 = {1,2...}

多维数组-二维数组

使用方式

• 类型[][] 数组名=new 类型[大小][大小];

• 定义类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}};

Java 面向对象

• 类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型

• 对象是具体的，实际的，代表一个具体事物, 即是实例

• 类是对象的模板，对象是类的一个个体，对应一个实例

类和对象的内存分配机制

• Java内存的结构分析

1. 栈 一般存放基本数据类型(局部变量)

2. 堆： 存放对象(Cat cat , 数组等)

3. 方法区：常量池(常量，比如字符串)， 类加载信息

方法重载(OverLoad)

Java中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致!返回类型：无要求

可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现

访问修饰符 返回类型 方法名(数据类型... 形参名){

}

可变参数的实参可以为0个或任意多个
可变参数的 实参可以为数组
可变参数 本质就是数组
一个形参列表只能出现 一个可变参数
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在 最后

包

包可以区分相同名字的类，当类很多时，可以很好的管理类，控制访问范围。

包的命名一般是小写字母+小圆点，只能包含数字、字母、下划线、小圆点..,但不能用数字开头，不能是关键字或保留字。

一个包下，包含很多的类，Java中常用的有:

• java.lang.* //lang包是基本包，默认引入，不需要再引入

• java.util.* //util包，系统提供的工具包，工具类，使用Scanner

• java.net.* //网络包，网络开发

• java.awt.* //是做java的界面开发，GUI

如何引入包？

语法:import 包;

访问修饰符

java提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限(范围)

• 公开级别:用public修饰，对外公开

• 受保护级别:用protected修饰，对子类和同一个包中的类公开

• 默认级别:没有修饰符号，向同一个包的类公开

• 私有级别:用private修饰，只有类可以本身可以访问，不对外公开

封装

封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。

继承

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中 抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可。

语法

class 子类 extends 父类{

}

• 子类就会自动拥有父类定义的属性和方法

• 父类又叫超类，基类

• 子类又叫派生类

好处

• 代码的复用性提高了

• 代码的扩展性和维护性提高了

子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
子类必须调用父类的构造器， 完成父类的初始化
super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
java 所有类都是 Object 类的子类, Object 是所有类的基类.
子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制

super 关键字

super 代表父类的引用，用于 访问父类的属性、方法、构造器

语法

访问父类的属性，但不能访问父类的private属性

    super.属性名;

访问父类的方法，不能访问父类的private方法

    super.方法名(参数列表);

访问父类的构造器

    super(参数列表);

方法重写/覆盖(override)

简单地说:方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法

多态

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的

多态的具体表现

• 方法的多态

• 重写和重载就体现多态

• 对象的多态

• 一个对象的编译类型和运行类型可以不一致

• 编译类型看定义时=号的左边，运行类型看=号的右边

多态的向上/向下转型

• 多态的向上转型

• 语法:父类类型 引用名=new 子类类型();

• 多态的向下转型

• 语法：子类类型 引用名=(子类类型) 父类引用;

Object类常见方法

• equals方法

• 是Object类中的方法，只能判断引用类型

• ==:既可以判断基本类型，又可以判断引用类型

• hashCode方法

• 两个引用，如果指向的同一个对象，则哈希值是一样的，反之，则不一样

• 哈希值主要根据地址号来的，不能完全将哈希值等价于地址

• toString方法

• 默认返回:全类名+@+哈希值的十六进制，子类往往重写toString方法，用于返回对象的属性信息

• 重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式

• finalize方法

• 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作

• 当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 方法。

• 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制

代码块

代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过0包围起来。但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

语法

[修饰符]{

}

• 修饰符可选，要写的话，也只能写static

• 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块

好处

• 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

• 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的复用性

单例设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

单例模式有两种方式

1. 饿汉式

2. 懒汉式

二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。
饿汉式不存在线程安全问题，懒汉式存在线程安全问题。
饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式

final 关键字

final 可以修饰类、属性、方法和局部变量，包装类(Integer,Double,Float,Boolean等都是final),String也是final类

• 当不希望被继承时，可以使用final修饰

• 当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰

• 当不希望类的某个属性的值被修改，可以用final修饰

• 当不希望某个局部变量被修改，可以使用final修饰

抽象类

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰类就是抽象类

语法

访问修饰符 abstract 类名{

}

抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类

抽象类最佳实现

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。

当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴霞出去,让子类去实现
编写一个抽象父类,父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式

接口

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【jdk7.0】。接口体现了程序设计的多态和高内聚低偶合的设计思想。Jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

语法

interface 接口名{

​ //属性

​ //抽象方法

}

class 类名 implements 接口{

​ 自己属性;

​ 自己方法;

​ 必须实现的接口的抽象方法

}

接口不能继承其他的类，但是可以继承多个别的接口
一个类同时可以实现多个接口

内部类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

语法

class Outer{ //外部类

​ class Inner{ //内部类

​ }

}

class Other{ //外部其他类

}

匿名内部类

匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

语法

new 类或接口(参数列表){

​ 类体

};

枚举和注解

枚举

枚举属于一种特殊的类，里面只包含一组有限的特定的对象，是一组常量的集合，对应英文(enumeration, 简写 enum)

实现方式

• 自定义类实现枚举

• 构造器私有化

• 本类内部创建一组对象

• 对外暴露对象（为对象添加 public final static 修饰符）

• 可以提供 get 方法，但是不要提供 set

• 使用 enum 关键字实现枚举

• 当我们使用 enum 关键字开发一个枚举类时，默认会继承 Enum 类, 而且是一个 final 类

注解

• 注解(Annotation)也被称为元数据(Metadata)，用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息。

• 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。

• 在 JavaEE 中注解占据了更重要的角色

• 三个基本的 Annotation

• @Override: 限定某个方法，是重写父类方法, 该注解只能用于方法

• @Deprecated: 用于表示某个程序元素(类, 方法等)已过时

• @SuppressWarnings: 抑制编译器警告

JDK 的元 Annotation

JDK 的元 Annotation 用于修饰其他 Annotation

元注解的种类

• Retention 指定注解的作用范围，三种 SOURCE,CLASS,RUNTIME

• Target 指定注解可以在哪些地方使用

• Documented 指定该注解是否会在 javadoc 体现

• Inherited 子类会继承父类注解

异常-Exception

Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)

异常分类

• Error(错误)

• Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如: StackOverflowError[栈溢出]和OOM(out ofmemory). Error是严重错误，程序会崩溃。

• Exception

• 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等等

• Exception 分类

• 运行时异常[程序运行时，发生的异常]，可以不作处理

• 编译时异常[编程时,编译器检查出的异常]，是编译器要求必须处置的异常

常见的运行时异常

• NullPointerException 空指针异常

• ArithmeticException 数学运算异常

• ArrayIndexOutOfBoundsException 数组下标越界异常

• ClassCastException 类型转换异常

• NumberFormatException 数字格式不正确异常

编译异常

编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译

常见的编译异常

• SQLException/操作数据库时，查询表可能发生异常

• IOException//操作文件时，发生的异常

• FileNotFoundException//当操作一个不存在的文件时，发生异常

• ClassNotFoundException//加载类,而该类不存在时,异常

• EOFException//操作文件，到文件未尾,发生异常

• lllegalArguementException//参数异常

异常处理

异常处理就是当异常发生时，对异常处理的方式。

处理异常的方式

1. try-catch-finally

• 程序员在代码中捕获发生的异常，自行处理

• 如果没有出现异常，则执行try块中所有语句，不执行catch块中语句，如果有finally，最后还需要执行finally里面的语句

• 如果出现异常，则try块中异常发生后，try块剩下的语句不再执行。将执行catch块中的语句，如果有finally,最后还需要执行finally里面的语句

2. throws

• 将发生的异常抛出，交给调用者(方法)来处理，最顶级的处理者就是JVM

自定义异常

当程序中出现了某些“错误”，但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类,用于描述该错误信息。

//自定义的一个异常
//1.一般情况下，我们自定义异常是继承 RuntimeException
//2.即把自定义异常继承运行时异常 好处 我们可以使用默认处理机制
class AgeException extends RuntimeException{
    public AgeException(String message) {
        super(message);
    }
}

throw 和 throws 的区别

• throws

• 异常处理的一种方式

• throw

• 手动生成异常对象的关键字

常用类

包装类

• Boolean

• 基本数据类型boolean的包装类

• Character

• 基本数据类型char的包装类

• Byte

• 基本数据类型byte的包装类

• Short

• 基本数据类型short的包装类

• Integer

• 基本数据类型int的包装类

• Long

• 基本数据类型long的包装类

• Float

• 基本数据类型float的包装类

• Double

• 基本数据类型double的包装类

包装类和基本数据的转换

• jdk5之前的手动装箱和拆箱方式，装箱:基本类型->包装类型,反之，拆箱

• jdk5以后(含jdk5)的自动装箱和拆箱方式

• 自动装箱底层调用的是valueOf方法，比如Integer.valueOf

package com.study.wrapper;

public class Integer01 {
    public static void main(String[] args) {
        //演示int->Integer
        //jdk5前是手动装箱和拆箱
        //手动装箱
        int n1=100;
        Integer integer=new Integer(n1);
        Integer integer1=Integer.valueOf(n1);
        //手动拆箱
        //Integer->int
        int i=integer.intValue();
        //jdk5之后 就可以自动装箱和自动拆箱了
        int n2=200;
        //自动装箱->Integer
        Integer integer2=n2;//底层是用的是Integer.valueOf(n2)
        //自动拆箱
        int n3=integer2;//底层使用的是Integer.intValue()
    }
}

包装类型和 String 类型的相互转换

package com.study.wrapper;

public class WrapperVSString {
    public static void main(String[] args) {
        //演示一下 包装类(Integer)->String
        Integer i=100;//自动装箱
        //方式1
        String str=i+"";
        //方式2
        String str2=i.toString();
        //方式3
        String str3=String.valueOf(i);

        //String ->Integer
        String str4="12345";
        Integer i2=Integer.parseInt(str4);//自动装箱
        Integer i3 = new Integer(str4);//构造器
        System.out.println("ok");
    }
}

String类

• String 对象于保存字符中，也就是一组字符序列

• "Jack"字符串常量，双引号括起的字符序列

• String有很多的构造器

• String 类实现了接口Serializable （String可以串行化，可以在网络上传输）

• String 是final类 不能被继承

• String 有属性 private final char value[];用于存放字符串内容

• value 是final类型 不可以修改 即value不能指向新的地址 但是单个字符内容是可以变化的

创建 String 对象的两种方式

• 方式一：直接赋值 String s="abc";

• 方式二：调用构造器 String s=new String("abc");

常见方法

• equals 区分大小写，判断内容是否相等

• equalslgnoreCase 忽略大小写的判断内容是否相等length//获取字符的个数，字符串的长度

• indexOf 获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1

• lastIndexOf 获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1

• substring 截取指定范围的子串

• trim 去前后空格

• charAt 获取某索引处的字符，注意不能使用Str[index]这种方式.

• toUpperCase

• toLowerCaseconcat

• replace替换字符串中的字符

• split 分割字符串,对于某些分割字符，我们需要转义比如|\\等

• 案例: String poem="锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";和文件路径.

• compareTo //比较两个字符串的大小toCharArray l/转换成字符数组

• format//格式字符串,%s字符串%c字符%d整型%.2f 浮点型

StringBuffer 类

• StringBuffer的直接父类 AbstractStringBuilder

• StringBuffer 实现了Serializable,即StringBuilder的对象可以串行化

• 在父类中AbstractStringBuilder有属性char[] value,不是final，该value数组存放字符串内容，引出存放在堆中

• StringBuffer是final类 不可被继承

String VS StringBuffer

• String保存的是字符串常量,里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[];

• StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高//char[] value;//这个放在堆.

String 和 StringBuffer 相互转换

package com.study.stringbuffer_;

public class StringAndStringBuffer {
    public static void main(String[] args) {
        //String->StringBuffer
        String str="hello tom";
        //方式一 使用构造器
        //注意：返回的才是StringBuffer对象，对str本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式二 使用append方法
        StringBuffer stringBuffer1 = new StringBuffer();
       stringBuffer1=stringBuffer1.append(str);

       //StringBuffer->String
        StringBuffer stringBuffer2=new StringBuffer("frx");
        //方式一 使用StringBuffer提供的toString方法
        String s=stringBuffer2.toString();
        //方式二 使用构造器 来搞定
        String s1 = new String(stringBuffer);
    }
}

常见方法

package com.study.stringbuffer_;

public class StringBufferMethod {
    public static void main(String[] args) {
        //1.append追加 返回的还是StringBuffer
        StringBuffer stringBuffer = new StringBuffer("hello");
        stringBuffer.append("a");
        stringBuffer.append("n");
        stringBuffer.append("c").append("c");
        System.out.println(stringBuffer.toString());
        //2.delete 删除  [1,3)
        //删除>=start&&<end的字符串
        System.out.println(stringBuffer.delete(1, 3));
        //3.replace 替换 [2,4)
        System.out.println(stringBuffer.replace(2,4,"x"));
        //4.indexOf 查找指定的字符串第一次出现的位置 如果找不到 返回-1
        int index=stringBuffer.indexOf("x");
        System.out.println(index);
        //5.insert 插入 原来索引为的位置自动后移
        System.out.println(stringBuffer.insert(5,"obj"));

    }
}

StringBuilder 类

• 一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步(StringBuilder 不是线程安全)。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类因为在大多数实现中，它比 StringBuffer要快

• 在 StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。

String、StringBuffer和StringBuilder 的比较

• StringBuilder 和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样

• String:不可变字符序列,效率低,但是复用率高。

• StringBuffer:可变字符序列、效率较高(增删)、线程安全,看源码

• StringBuilder:可变字符序列、效率最高、线程不安全

String、StringBuffer 和 StringBuilder 的选择

• 如果字符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder

• 如果字符串存在大量的修改操作,并在单线程的情况,使用 StringBuilder

• 如果字符串存在大量的修改操作，并在多线程的情况,使用 StringBuffer

• 如果我们字符串很少修改，被多个对象引用,使用String,比如配置信息等

Math 类

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

Math 类常见方法应用案例

package com.study.math_;

public class MathMethod {
    public static void main(String[] args) {
        //abs 绝对值
        int abs=Math.abs(-9);
        System.out.println(abs);
        //2.pow 求幂
        double pow=Math.pow(2,6);//2的6次方
        System.out.println(pow);
        //3.ceil 向上取整  返回>=该参数的最小整数
        double ceil=Math.ceil(2.54646);
        System.out.println(ceil);//2.0
        //4.floor 向下取整 返回<=改参数的最小整数
        double floor=Math.floor(4.0001);
        System.out.println(floor);//4.0
        //5.round 四舍五入
        long round=Math.round(5.5);
        System.out.println(round);//6.0
        //6.sqrt 开方
        double sqrt=Math.sqrt(4);
        System.out.println(sqrt);
        //7. random 求随机数
        //random 是返回 0<=x<1
        //返回一个 a<=x<=b
        //(int)(a)<=x<=(int)(a+Math.random()*(b-a+1))
        System.out.println((int)(0+(Math.random()*68)));
        int min=Math.min(6,9);
        int max=Math.max(1,90);
        System.out.println(min+" "+max);
    }

}

Arrays 类

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)

• toString返回数组的字符串形式

• Arrays.toString(arr)

• sort排序(自然排序和定制排序)

• binarySearch通过二分搜索法进行查找,要求必须排好序

• copyOf 数组元素的复制

• fill数组元素的填充

• equals比较两个数组元素内容是否完全一致

• asList将一组值，转换成list

System 类

• exit 退出当前程序

• arraycopy:复制数组元系，比较适合底层调用,一般使用Arrays.copyOf完成复制数组.

• currentTimeMillens:返回当前时间距离1970-1-1的毫秒数

• gc:运行垃圾回收机制System.gc0);

BigInteger 和 BigDecimal 类

• BigInteger适合保存比较大的整型

• BigDecimal适合保存精度更高的浮点型(小数)

日期类

• Date 精确到毫秒，代表特定的瞬间

• SimpleDateFormat 格式和解析日期的类。他允许进行格式化（日期->文本）、解析（文本->日期）

• Calendar类(日历)

package com.study.date_;

import java.util.Calendar;

public class Calendar_ {
    public static void main(String[] args) {
        //1.Calender是一个抽象类，并且构造器是private
        //2.可以通过 getInstance()来获取实例
        //3.提供大量的方法和字段提供给程序员
        //4.Calendar没有提供相应的格式化的类，因此需要程序员自己组合来输出(灵活)
        //5.如果我们需要按照 24小时进制来获取时间， Calender.HOUR==改成=> Calender.HOUR_OF_DAY

        Calendar c=Calendar.getInstance();//创建日历对象//比较简单，自由
        System.out.println("c="+c);
        //2.获取  日历对象的某个日历字段
        System.out.println("年:"+c.get(Calendar.YEAR));
        //这里为什么要加 1 因为Calender 返会月的时候，是按照0开始编号
        System.out.println("月:"+(c.get(Calendar.MONTH)+1));
        System.out.println("日:"+c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时:"+c.get(Calendar.HOUR));
        System.out.println("分钟:"+c.get(Calendar.MINUTE));
        System.out.println("秒:"+c.get(Calendar.SECOND));
        //Calender 没有专门的格式化方法，所以需要程序员自己来组合显示
        System.out.println(c.get(Calendar.YEAR)+"-"+(c.get(Calendar.MONTH)+1)+"-"+
                c.get(Calendar.DAY_OF_MONTH)+"  "+c.get(Calendar.HOUR_OF_DAY)+":"+
                c.get(Calendar.MINUTE)+":"+c.get(Calendar.SECOND));



    }
}

• LocalDate(日期/年月日)

• LocalTime(时间/时分秒)

• LocalDateTime(日期时间/年月日时分秒)