Java从入门到精通思维导图模板_ProcessOn思维导图、流程图

初始Java

Java介绍

Java是一门高级的面向对象的程序设计语言。

Java语言的特性

1.简单

2.面向对象

3.分布性

4.可移植性

5.解释性

6.安全性

7.健壮性

8.多线程

9.高性能

10.动态

搭建Java环境

下载JDK

JDK8和JDK11为长更新版本

熟悉eclipse开发工具

熟悉eclipse

下载eclipse

下载网址：https://www.eclipse.org/downloads/

使用eclipse

配置与启动

安装好后在桌面设置快捷方式，双击打开

创建Java项目

创建Java文件

输入类名

编写Java代码

运行Java代码

运行

生成结果

程序调试

调试Java代码

Java语言基础

Java主类结构

包声明

一个Java应用程序是由若干个类组成的

声明成员变量和局部变量

通常将类的属性称为类的全局变量（成员变量）将方法中的属性称为局部变量

编写主方法

main（）方法就是类体中的主方法。

导入API类库

在Java语言中可以通过import关键字导入相关的类，API文档是程序开发人员不可或缺的工具

基本数据类型

整数类型

整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正数也可以是负数。

整型数据类型

根据内存大小不同可分为：

int型

byte型

short型

long型

浮点类型

浮点类型简称浮点型，用来存储含有小数部分的数值。浮点类型分为单精度浮点类型和双精度浮点类型

浮点型数据类型

想使用float型小数需要在小数后面添加F或f。也可在后缀d或D来明确表明这是一个double类型数据，定义float变量时不加F或f系统会认为是double数据而出错

创建BMIexponent类，声明double型变量height来记录身高，声明int型变量weight记录体重

字符类型

char 型

字符类型char用于存储单个字符，占用16位字节的内存空间。在定义字符型变量时要以单引号表示。如：'s' 表示一个字符"s"表示一个字符串

转义字符

转义字符是一种特殊的字符变量，它以反斜杠"\"开头，后跟一个或多个字符。转义字符具有特定的含义，不同与字符原有的意义，故称“转义”例如：printf函数的格式串中用到的"\n"就是一个转义字符，意思是“回车换行”。

布尔类型

布尔类型又称逻辑类型，简称布尔型。通过关键字Boolean来定义布尔类型变量。布尔类型只有true和false两个值，分别代表“真”和“假”。布尔类型不能与整数类型进行转换。

变量与常量

标识符和关键字

标识符

用来标识类名、变量名、方法名、数组名、文件名的有效字符序列

关键字

程序所打出的代码中显示器所显示的所有彩色字符都是关键字

声明变量

声明变量就是要告诉编译器这个变量的数据类型，这样编译器才知道需要配置多少空间给它

声明常量

在程序运行过程中一直不会改变的量称为常量，也被称为final变量。常量只能赋一次值

变量的有效范围

成员变量

在类体中所声明的变量被称为成员变量，在整个类中都有效

局部变量

在类的方法体中声明的变量只在当前代码块中有效

运算符

赋值运算符

赋值运算符以符号"="表示，它是一个二元运算符（对两个数做处理），其功能是将右方操作数所含的值赋给左方的操作数

算术运算符

Java中的算数运算符主要有+（加）,-（减），*（乘），/（除）,%（求余）其中+和-还可以作为正负号使用

自增和自减运算符

符号在前先运算后使用，符号在后先使用后运算，放在操作元前面的自增自减运算符，会先将变量值加1或减1再参与表达式的运算。 ++a(--a)//先算后用 a++(a--)//先用后算

比较运算符

比较运算符的结果是boolean型，运算结果不是true就是false。

逻辑运算符

逻辑运算符包括：&（&&）（逻辑与）、||（逻辑或）、！（逻辑非）

逻辑运算符的操作元必须是Boolean型数据。 两者都为真结果才是真 只要有一者为真结果就是真 非真即假，非假即真

当第一个表达式为false时则不会去判断第二个表示式，直接输出结果，通常将这种在逻辑运算中从左端可推出整个表达式值的情况称为“短路” 而那些始终需要执行逻辑运算符两边的表达式才可以推断出整个值的称为“非短路”

位运算符

三元运算符

三元运算符的运算规则为：若条件式的值为true,则整个表达式取值1，否则取值2。 语法：返回值=判断公式 ？ 结果1 ： 结果2 返回公式是true是结果1，是false则取结果2

运算符优先级

运算符优先级决定了表达式中运算执行的先后顺序。优先级由高到低依次是：

增量与减量运算

算数运算

比较运算

逻辑运算

赋值运算

如果两个运算有相同的优先级，那么左边的表达式要比右边的表达式先被处理

数据转换类型

隐式类型转换

低精度数据类型转高精度数据类型永远不会溢出，总是成功的。称隐式\自动类型转换 一定不会丢失数据

显示类型转换

把高精度转向低精度时则会信息丢失，有可能失败。称显示\强制类型转换 有可能会丢失数据

类型转换是将一个值从一种类型更改为另一种类型的过程

这些类型按精度从低到高排序为byte<short<int<long<float<double

代码注释与编码规范

代码注释

单行注释

"//"为单行注释标记，从符号"//"开始直到换行为止的所有内容均作为注释而被编译器忽略

多行注释

"/*  */"为多行注释标记，符号"/*"与"*/"之间的所有内容均为注释内容，注释中的内容可以换行

文档注释

"/**  */"为文档注释标记

编码规范

每条语句尽量单独占一行，每条语句都要以分号结束。

空格仅提供分隔使用

为方便维护尽量不使用技术高。难懂，易混淆语句

方法必须写在类的{ }之内。方法的{ }内不可以创建其他方法

流程控制

复合语句

复合语句由开括号"{"开始，闭括号"}"结束，复合语句中的每个语句都是从上到下被执行。 复合语句以整个块为单位，能够用在任何单位，任何一个单独语句可以使用的地方。并且在复合语句中还可以嵌套复合语句。

条件语句

if条件语句

if条件语句是一个重要的编程语句，用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行另外的语句。

if...else语句

if..else  if多分支语句

if....else if多分支语句执行过程

Switch多分支语句

switch语句中表达式的值必须是整型、字符型、字符串类型或枚举类型，常量值1-n的数据类型必须与表达式的值的类型相同。

Switch语句执行过程

循环语句

while循环语句

while 语句也称条件判断语句，它的循环方式为利用一个条件来控制是否要继续反复执行这个语句。 是条件判断语句，当表达式的返回值为真是，则执行语句，重新判断条件表达式的返回值，知道返回值的结果为假时，退出循环。

while语句执行过程

while条件表达式

do..while循环语句

for循环语句

while嵌套do...while

do...while嵌套while

for嵌套while

do...while和for嵌套循环

循环控制

break语句

使用break语句可以跳出Switch结构。也可跳出当前循环语句，从而中断当前循环

continue语句

continue语句是针对break语句补充 continue不是立即跳出循环体，而是跳过本次循环

数组

数组是具有相同数据类型的一组数据集合。

一维数组

创建一维数组

1.先声明，在用new关键字进行内存分配                                                                  数组元素类型决定了数据类型，数组名字为一个合法的标识符，符号"[  ]"指明该变量是一个数组类型变量。单个"[  ]"表示要创建的数组是一个一维数组

2.声明的同时为数组分配内存                                                                                  数组元素类型 数组名=new数组元素的类型[数组元素的个数];

初始化一维数组

数组与基本数据类型一样可以进行初始化操作。数组的初始化可以分别初始化数组中的每个元素。 数组的初始化有两种方式： int arr[]=new int[]{1,2,3,5,25}; int arr2[]={34,12,6};

使用一维数组

二维数组

如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标代表元素所在的列

创建二维数组

先声明，再用new关键字进行内存分配，声明二维数组语法如下： 数组元素的类型 数组名字[] []; 数组元素的类型[] [] 数组名字;

初始化二维数祖

二维数组的初始化与一维数组初始化类似，同样可以使用大括号完成。 type arrayme[][]={value1,value2……,valuen}; type:数组数据类型 arrayname:数组名称，一个合法的标识符 value:二维数组中各元素，都代表一个一维数组

使用二维数祖

数组的基本操作

遍历数组

遍历数祖就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。

填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型。 替换数组 Arrays.fill(数组名，值)； 替换数组部分元素：前改后不改 Arrays.fill(数组名，前索引，后索引，值)；索引=下标

对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序.Java中的string类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

复制数组

复制数组元素：空位补0溢出去掉 新数组名=Arrays.copyof(旧数组名，新数组长度）

查询数组

查询数组：先排序再查询 索引=Arrays.binarys search(数组名，前索引，后索引，元素）； 查询数组元素：先排序再查询，前含后不含 索引=Arrays.binarys search(数组名，前索引，后索引，元素）；

数组排序算法

冒泡排序

基本思想

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部

算法演示

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置

算法实现

直接排序

基本思想

直接排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。与冒泡排序的区别，不是交换元素，而是满足条件的元素与指定的排序位置元素交换，这样排序好的位置逐渐扩大，直至整个数组都变成已排序好的格式

算法示例

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序的放在已排好的数列的最后，直到全部待排序的数据元素排完

算法实现

反转排序

基本思想

反转排序的基本思想比较简单，就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换

算法示例

反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如数组长度为7，那么for循环只需要循环3次

类和对象

面向对象概述

对象

现实世界中，随处可见的一种事物就是对象。对象是事物存在的实体，如人，课桌高楼大厦等等

类

类是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。 在Java语言中，类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法

封装

封装提高代码的复用性.封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想

继承

子类可直接使用父类代码

多态

多态表现出不同的形态 将父类对象应用于子类的特征就是多态

类

成员变量

在Java中对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围

成员方法

权限修饰符

Java中的权限修饰符主要包括public、protect、default、private,这些修饰符控制着对类和类的成员变量以及成员方法的访问。

局部变量

局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否者会出现编译错误 。

局部变量的有效范围

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。

this关键字

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用this可以调用成员变量和成员方法还可以作为方法的返回值

类的构造方法

构造方法是一个与类同名的方法，对象的构建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

构造方法的特定如下： 构造方法没有返回值 构造方法的名称要与本类的名称相同。

构造方法的定义语法格式如下： public Book( ){ … //构造方法体 } public:构造方法修饰符 Book：构造方法的名称

静态变量和静态方法

静态变量与静态方法的作用通常是为了提供了共享数据或方法，如数学计算公式等，尽管使用这种方法调用静态成员比较方法方便，但静态成员同样遵循着public，private，和protected修饰符的约束

总结以下使用static关键字要注意的几点： <ul><li>在静态方法中不可使用this关键字。</li><li>在静态方法中不可以直接调用非静态方法。</li><li>局部变量不可以使用static关键字声明。</li><li>主方法必须用static声明。</li><li>只有内部类可以使用static关键字声明。</li></ul>

类的主方法

在主方法的定义中可以看到其具有以下特性： <ul><li>主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。</li><li>主方法没有返回值。</li><li>主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数</li></ul>

对象

引用

对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收在其他语言中，需要用户手动回收废弃的对象，JAVA拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源

继承，多态，抽象类与接口

类的继承

继承在面向对象开发思想中是一个非常重要的概念，它可以提高软件的可维护性和可扩展性。Java只支持单继承，即一个类只能有一个父类。

"extends"java中只支持单继承，即一个类只能有一个父类"super"： 所有类的构造方法第一行都有一个隐藏的super（）； 作用是在执行构造方法之前调用父类的构造方法

方法的重写：返回参数相同，方法名相同，传入参数相同，只有方法体不同，子类可重写父类方法

object类

Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。自定义的类也都继承于Object类。由于所有类都是Object类的子类，所以任何类都可以重写Object类中的方法

getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName（）方法可以获得类的名称      （获取一个类）

to String（）方法

to String（）方法的功能是将一个对象返回为字符串形式，它会返回一个String 实例。当这个类转换为字符串或与字符串连接时，将自动调用重写的to String（）方法。

equals()方法

在Java中，有两种比较对象的方式，分别为“==”运算符与equals（）方法。两者的区别在于“==”比较的是两个对象引用内存地址是否相等，而equals（）方法比较的是两个对象的实际内容。

对象类型的转换

向上转换

向上转换就是将子类类型的对象转换为父类类型的对象（子类转父类） 把子类类型的对象直接赋值给父类类型的对象（子类对象赋值给父类引用）

向下转换

向下类型将父类类型的对象转换为子类类型的对象。（父类转子类） 但是，运用向下转型如果把较抽象的类的对象转换为一个较具体的类的对象，这样的转换通常会出现错误。就需要借助强制类型转换

使用instanceof关键字判断对象类型

方法的重载

由于构造方法都需要根据类名进行命名，为了让方法名相同而形参不同的构造方法同时存在，就必须用到方法重载。 方法名相同，参数不同（返回参数不同，传入参数不同）

final关键字

final变量

final修饰变量——不能被改变（变量）

final方法

final修饰方法——不能被重写

final类

final修饰类——不能被继承

多态

利用多态可以使程序具有良好的扩展性，并可以对所有类进行通用的处理。 子类继承父类，所形成的多种形态。就叫多态 继承父类所形成的多种结果，使用多个方法、变量、类，只要结果不同就是多态

抽象类与接口

抽象类

抽象方法没有方法体 抽象类 ：有抽象方法的类一定是抽象类 假设父类是抽象类的话，子类是普通类，那么子类继承父类的话就需要被重写,否则就会报错。

接口

所有方法都是抽象方法叫接口。Java语言中每个类可以实现多个接口。可以单继承多实现

包和内部类

包在整个管理过程中起到了非常重要的作用，使用包可以有效的管理繁杂的类文件，解决类重名的问题。在类中应用包与权限修饰符，可以控制其他人对类成员的访问。

Java类包

在Java中每定义好一个类，通过Java编译器进行编译后，都会生成一个扩展名为.class的文件。当程序规模扩大时就很容易发生类名冲突现象，所以Java就提供了一种管理类文件的机制，就是类包。

类名冲突

编译器不会允许存在同名的类文件，解决这类问题的办法是将这两个类放置在不同的类包中

完整的类路径

在进入eclipse时复制存储的路径然后在文件管理中打开就可以直接进入eclipse保存的文件中查找里面的文件。 随意点进去一个文件夹里面会出现不同的其他文件 bin保存的是class文件，src保存的是Java文件 创建的包也会出现在src文件夹中。eclipse中所创建的所有类都会同步出现在这些文件中

创建包

在eclipse中创建包的步骤如下：

1.在SRC节点上右击，选择new、package命令。

2.弹出Java包对话框，在name文本框中输入新建的包名，如prckage1然后单击完成（finish）按钮

3.在eclipse中创建类时，可以在新建立的包上右击选择新建new命令，作业新建的类就会保存在该包中。另外还可以在新建类时同时修改包名，就可以创建两个不同的包和类

导入包

在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用import关键字指定时在包指定后加上*，这表示可以在程序中使用该包中的所有类。

import关键字除了导入包外，还可以导入静态成员，导入静态成员可以使编程更为方便

内部类

成员内部类

在一个类中使用内部类，可以在内部类中直接存其所在类的私有成员变量。语法如下： class OuterClass{        //外部类 class lnnerClass{        //内部类 } }

成员内部类不止可以在外部类中使用，在其他类中也可以使用。在其他类中创建内部类对象的语法非常特殊，语法如下： 外部类 outer = new 外部类(); 外部类.内部类 inner = outer.new 内部类();

2.使用this关键词获取内部类与外部类的引用 如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。

匿名内部类

匿名类是只在创建对象时才会编写类体的一种写法 。匿名类的特点是”现用现写“，其语法如下： new 父类/父接口(){         子类实现的内容 };

使用匿名类时应该遵循以下原则： 1、匿名类不能写构造方法 2、匿名类不能定义静态的成员 3、如果匿名类创建的对象没有赋值给任何引用变量，会导致该对象用完一次就会被Java虚拟机销毁

异常处理

异常概述

在程序中，异常可能由程序员没有预料到的各种情况产生，有可能由超出了程序员可控范围的环境因素产生，在Java中，这种程序运行时可能出现的一些错误称为异常。异常是一个程序执行期间发生的事件。它中断了正在执行的程序的正常指令流。

程序运行的结果发生了算数异常

try：try语句块中包含可能出现异常的程序代码 catch：语句块用来获取异常信息 finally：程序代码块

异常的抛出与捕捉

为了保证程序有效的执行，需要对抛出的异常进行相应的处理。在Java中，如果某个方法抛出异常，既可以在当前方法中进行捕捉，而后处理该异常，也可以将异常向上抛出，交由方法调用者来处理。

抛出异常

异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整型。可以通过Integer类的 parseInt(方法来实现。但如果该字符串不是数字形式，parseInt)方法就会抛出异常，程序将在出现异常的位置终止，不再执行下面的语句。

捕捉异常

try-catch语句块

 由上看出程序仍然输出最后的提示信息，没有因为异常而终止。在上面代码中，将可能出现异常的代码用try-catch语句块进行处理，当try语句块中的语句发生异常时，程序就会跳转到catch语句块中执行，执行完catch语句块中的程序代码后，将继续执行catch语句块后的其他代码，而不会执行try语句块中发生异常语句后面的代码。由此可知，Java的异常处理是结构化的，不会因为一个异常影响整个程序的执行。 

finally语句块

完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。但是，在以下4种特殊情况下，finally块不会被执行： <ul><li>在finally语句块中发生了异常。</li><li>在前面的代码中使用了System.exit（）退出程序。</li><li>程序所在的线程死亡。</li><li>关闭CPU。 </li></ul>

Java常见的异常类

在Java中，提供了一些异常类用于描述经常发生的异常。其中，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理

自定义异常

在程序中使用自定义异常类有以下四个步骤： <ol><li>创建自定义异常类</li><li>在方法中通过throw关键字抛出异常对象</li><li>如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续继续下一步操作。</li><li>在出现异常的方法的调用者中捕获并处理异常。 </li></ol>

在方法中抛出异常

若某个方法可能会发生异常，但不想在当前方法中处理这个异常，则可以使用throws、throw关键字在方法中抛出异常。

使用throws关键字抛出异常

 throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常，多个异常可使用逗号分隔

使用throw关键字抛出异常

throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throw关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句块。 throw通常用来抛出用户自定义异常。

运行时异常

RuntimeException异常是程序运行过程中抛出的异常。Java类库的每个包中都定义了异常类，所有这些类都是Throwable类的子类。Throwable类派生了两个子类，分别是Exception类和 Error类。Eror类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。Exception类称为非致命性类，可以通过捕捉处理使程序继续执行。Exception类又根据错误发生的原因分为RuntimeException异常和除RuntimeException之外的异常

异常的使用原则

Java异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主 要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时， 可遵循以下几条原则：<ul><li>在当前方法声明中使用try-catch语句捕获异常。</li><li>一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。</li><li>如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。 </li></ul>

字符串

String 类

单个字符可以用char类型保存，多个字符组成的文本就需要保存在string对象中，string通常被称为字符串，一个string对象最多可以保存（2^{32}-1)个字节（占用4GB空间大小）的文本内容

声明字符串

字符串必须包含在一对双引号（" "）之内 例如： "23,23","ADFG","你好"  以上这些都是字符串常量，字符串常量可以是系统能够显示的任何文字信息，甚至可以是单个字符。

创建字符串

在Java语言中，将字符串作为对象来处理，因此可以创建其他类对象一样来创建字符串对象。创建对象要使用类的构造方法。String 类的常用构造方法如下：

连接字符串

对于以声明的字符串，可以对其相应的操作，连接字符串就是字符操作中较简单的一种。可以对多个字符串进行连接，也可使字符串与其他数据类型进行连接

连接多个字符串

使用“+”运算符可实现多个字符串的功能。“+”运算符可以连接多个string对象并产生一个新的string对象。

连接其他数据类型

字符串也可和其他基本数据类型进行连接。如果将字符串同其他数据类型进行连接，会将其他数据类型的数据直接转换成字符串。

获取字符串信息

字符串作为对象，可通过相应方法获取字符串的有效信息，如获取字符串的长度、某个索引位置的字符串等

获取字符串长度

使用string类的length（）方法可获取声明的字符串对象的长度。语法如下： str.length();

字符串查找

String类提供了两种查找字符串的方法，即indexOf（）与lastdndexOf()方法。这两种方法都允许的符串中搜索指定条件的字符或字符串。indexO)方法返回的是搜索的字符或字符串首次出现的位lastindexOf)方法返回的是搜索的字符或字符串最后一次出现的位置

1. indexOf(String s) 该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的 index0f()方法时，会从当前字符串的开始位置搜索s的位置。如果没有检索到字符串s,该方法的返回值是-1语法如下： str.indexOf(substr)

2. lastIndexOf(String str) 该方法用于返回指定字符串最后一次出现的索引位置。当调用String类的lastIndexOf0方法时，会从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1。语法如下： str.lastIndexOf(substr)

获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回。语法如下： str.charAt(int index)

str：任意字符串。 index:整型值，用于指定要返回字符的下标。

字符串操作

获取子字符串

String类的 substring()方法可对字符串进行截取。substring)方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的

1. substring(int beginlndex) 该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下： str.substring(int beginlndex)

2. substring(int beginlndex, int endlndex) 该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如下： substring(int beginlndex, int endlndex)

去除空格

trim（）方法返回字符串的副本，忽略前导空格和尾部空格。语法如下： str.trim

字符串替换

replace方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下： str.replace(CharSequence target, CharSequence replacement)

target：要替换的字符或字符串。 replacement:用于替换原来字符串的内容

判断字符串的开头与结尾

startsWith()方法与endsWith方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。

1. startsWith()方法 该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下： str.startsWith(String prefix)

子主题

2. endsWith()方法 该方法用于判断当前字符串是否为以给定的子字符串结束。语法如下： str.endsWith(String suffix)

判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==”， 因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回 false。

使用比较 运算符比较两个字符串，代码如下： String tom = new String("I am a student");  String jerry = new String("I am a student"); boolean b=(tom == jerry);

1. equals()方法  如果两个字符串具有相同的字符和长度，则使用equals)方法进行比较时，返回true。否则，返回 false。语法如下： str.equals(String otherstr)

2. equalslgnoreCase()方法 使用equals（）方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase（）方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型。语法如下： str.equalslgnoreCase(String otherstr)

按字符顺序比较两个字符串

compareTo方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示 字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。语法如下： str.compareTo(String otherstr)

字母大小写转换

String类的toLowerCase()方法可将字符串中的所有大写字母改写为小写字母，而toUpperCaseO方法可将字符串中的所有小写字母改写为大写字母。

1、 toLowerCase()方法 该方法将字符串中的所有大写字母转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回：否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下： str.toLowerCase()   其中，str是要进行转换的字符串。

2. toUpperCase()方法 该方法将字符串中所有的小写字母转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换成大写，字符串长度不变。语法如下： str.toUpperCase()

字符串分割

使用split)方法可以使字符串按指定的分割字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split)方法提供了以下两种字符串分割形式。

1. split(String sign) 该方法可根据给定的分割符对字符串进行拆分。语法如下： str.split(String sign) sign为分割字符串的分割符，也可以是使用正则表达式。

2. split(String sign,int limit) 该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。语法如下：  str.split(String sign,int limit)

格式化字符串

日期和时间字符串格式化

1.日期格式化

返回一个月中的天数，代码如下： Date date = new Date(); //创建 Date 对象date String s =String.format("%te", date); //通过format()方法对date进行格式化

2.时间格式化

使用format)方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等。

3.格式化常见的日期时间组合

格式化日期与时间组合的转换符定义了各种日期时间组合的格式

常规类型格式化

常规类型格式化可应用于任何参数类型

使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\\d”表示数字0~9中的任何一个，“\d”就是元字符。

字符串生成器

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大地增加系统开销。而JDK新增了可变的字符序列StringBuilder类，大大提高了频繁增加字符串的效率。 

常用库类

包装类

lnteger类

Integer类提供了以下4个常量： <ul><li>MAX_VALUE：表示int类型可取的最大值，即2^{31}</li><li>MIN_VALUE：表示int类型可取的最小值，即-2^{31}</li><li>SIZE：用来以二进制补码形式表示int值的位数</li><li>TYPE：表示基本类型int的Class实例</li></ul>

Double类

Double类在对象中包装一个基本类型为double的值，每个Double类的对象都包含一个double类型的字段。也可以将double类型转换为String类型，将String类型转换为double类型

Double类主要提供了以下常量： <ul><li>MAX_EXPONENT：返回int值，表示有限double变量可能具有的最大指数 。</li><li>MIN_EXPONENT：返回int值，表示标准化double变量可能具有的最小指数 。</li><li>NEGATIVE_INFINITY：返回double值，表示保存double类型的负无穷大值的常量。</li><li>POSITIVE_INFIINITY：返回double值，表示保存double类型的正无穷大值的常量。</li></ul>

Boolean类

Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段

Character类

Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别（小写字母、数字），并可以很方便地将字符从大写转换成小写，反之亦然

Character 类提供了大量表示特定字符的常量，例如: <ul><li>CONNECTOR_PUNCTUATION: 返回 byte 型值，表示 Unicode 规范中的常规类别“pe”。</li><li>UNASSIGNED: 返回 byte型值，表示 Unicode 规范中的常规类别“Cn”。</li><li>TITLECASE_LETTER:返回 byte 型值，表示Unicode 规范中的常规类别“Lt”。</li></ul>

Number类

对于数值型的包装类，他们有一个共同的父类—— Number类，该类是一个抽象类

数字处理

数字格式化

数字格式化操作主要针对的是浮点型数据，包括double型和float型数据

在Java中，没有格式化的数据遵循以下原则: <ol><li>如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。</li><li>如果数据绝对值小于0.001并且大于10000000，使用科学记数法表示</li></ol>

math类

Math类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值，最小值，以及平均值函数方法。这些方法都被定义为static形式，所以在程序中应用比较简便

1.三角函数方法

Math 类中包含的三角函数方法如下: <ul><li>public static double sin(doublea):返回角的三角正弦。</li><li>public static double cos(double a):返回角的三角余弦。</li><li>public static double tan(double a):返回角的三角正切。</li><li>public static double asin(doublea): 返回一个值的反正弦。</li><li>public static double acos(doublea): 返回一个值的反余弦。</li><li>public static double atan(doublea):返回一个值的反正切。</li><li>public static double toRadians(double angdeg): 将角度转换为弧度。</li><li>public static double toDegrees(double angrad): 将弧度转换为角度。</li></ul>

2.指数函数方法

Math 类中与指数相关的函数方法如下： <ul><li>public static double exp(double a):用于获取e的a次方，即取。</li><li>publicstatic doublelog(doublea):用于取自然对数，即取Ina的值。 publicstatic double log10(doublea):用于取底数为10的a的对数。</li><li>public static double sqrt(doublea):用于取a的平方根，其中a的值不能为负值。</li><li>public static double cbrt(double a):用于取a的立方根。</li><li>public static double pow(double a,double b):用于取a的b次方。</li></ul>

3.取整函数方法

4.取最大值、最小值、绝对函数方法

在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下: <ul><li>public static double max(double adouble b):取a与b之间的最大值。</li><li>public static int min(int a,int b):取a与b之间的最小值，参数为整型。</li><li>public static long min(long a,long b):取a与b之间的最小值，参数为长整型。</li><li>public static float min(float a,float b):取a与b之间的最小值，参数为单精度浮点型。</li><li>public static double min(double a double b):取a与b之间的最小值，参数为双精度浮点型。</li><li>public static int abs(int a):返回整型参数的绝对值。</li><li>public static long abs(long a):返回长整型参数的绝对值。</li><li>public static float abs(float a):返回单精度浮点型参数的绝对值。</li><li>public static double abs(double a):返回双精度浮点型参数的绝对值。</li></ul>

Random类

Random类是JDK中的随机数生成器类，可以通过实例化一个Random对象创建一个随机数生成器，语法如下： Random r=new Random();

BigInteger类

BigInteger 类的数字范围较 Integer 类的数字范围要大得多。BigInteger类支持任意精度的整数在运算中 BigInto类可以准确地表示任何大小的整数值而不会丢失信息。在BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。

使用 BigInteger 类，可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger 类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。       例如，将2转换为BigInteger 类型，可以使用以下语句进行初始化操作: BigInteger twolnstance= new BigInteger("2");

BigDecimal类

BigDecimal类和BigInteger类都能实现大数字的运算，不同的是BigDecimal类加入了小鼠的概念。一般的float型和double型数据只可以用来做科学计算或工程计算，但由于在商业计算重要计算中要求数字精度比较高，所以要用到BigDecimal类。BigDecimal类支持任何精度的定点数，可以用来精度计算货币值

BigDecimal 类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的。BigDecimal 实现的加、减、乘、除的方法如表下：

在上述方法中，BigDecimal类中 divide0方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义如表11.10所示。

System类

system 类是JDK 中提供的系统类，该类是用 fmal 修饰的，所以不允许被继。 System 类提供了最多系统层面的操作方法，并且这些方法全部都是静态的。System 类提供的较常用方法如下表：

控制台输出字符

System类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3 个静态对象:in、out和err。

println()方法与 println()方法输出的对比效果如表 11.12 所示：

综上所述，Java 输出换行的方法有以下两种: System.out.print("\n");//利用换行符\n实现换行 System.out.printIn();//空参数即可实现换行

计时

System.currentTimeMillis()方法可以获取自 1970年1月1日零点至今的毫秒数。Date日期类也有类似的方法，但代码会比 System 类多，所以 System.currentTimeMillis()方法是为获取当前毫秒数最常用的方法。因为该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。

Scanner类

与C 语言不同，Java 从控制台中读出用户输入的值，用到的不是一行可以直接使用的代码,而是 Scaner 的类来实现的。Scanner 英文直译就是扫描仪，它的用途就和现实生活的扫描仪一样，可以把数字化信息流转为人类可识别的文字。控制台输入内容用到了 System.out 就表示向控制台输出 ，System.in 就表示从控制台输入，让 Scanner 扫描 System.in 就可以获取用户输入的值了。

使用Scanner类扫描控制台的代码如下： Scanner se = new Scanner(System.in);

日期时间类

Date类

Date类用来表示日期时间，使用该类表示时间需要使用其构造方法创建对象，

Date类的常用方法及其说明方法  <ul><li>after(Date when) 测试当前日期是否在指定的日期之后</li><li>before(Date when) 测试当前日期是否在指定的日期之前</li><li>getTime() 获得自1970年1月1日00:00:00GMT开始到现在所经过的毫秒数</li><li>setTime(long time) 设置当前Date对象所表示的日期时间值,该值用以表示1970年1月1日00:00:00GMT以后time毫秒的时间</li></ul>

日期时间格式化

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法

calendar类

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY OF MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected.Calendar 提供了一个类方法 getInstance0，以获得此类型的一个通用的对象。

Calendar 类的使用做出几点总结: <ul><li>c.set(CalendarDAY_OF_MONTH,0)获取的是上个月的最后一天，所以调用前需要将月份往后加一个月。</li><li> Calendar.MONTH的第一个月是使用0记录的，所以在获得月份数字后要加1。年和日是从1开始记录的，不需要加 1。</li><li>Calendar.DAY OF WEEK 的第一天是周日，周一是第二天，周六是最后一天。</li></ul>

Runtime类

Runtime 类是 JDK 供的运行时类，该类为 Java程序提供了与当前运行环境相连接的一个通道，Runtime 类不能使用 new 关键字创建实例，只能通过 Runtime. getRuntime()方法获取实例。

执行本地命令

本地命令指的是操作系统的命令。

Process类的常用方法如表 11.22 所示，开发可以使用 getInputStream()方法获取进程返回的信息

查看内存

Runtime类可以通过 freeMemory()方法查看当前Java 虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张。