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

初始Java

Java简介

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

什么是Java语言

Java是1995年有Sun公司推出的一门极富创造力的面向对象的程序设计语言，它是一种通过解释方式来执行的语言，其语法规则和c++类似

Java的应用领域

桌面应用系统开发

嵌入式系统开发

电子商务应用

企业级应用开发

交互式系统开发

多媒体系统开发

分布式系统开发

Wed应用系统开发

移动端应用开发

Java语言的特性

面向对象

分布性

可移植性

解释性

安全性

健壮性

多线程

高性能

动态

搭建Java环境

运行原理

熟悉Eclipse开发工具

熟悉Eclipse

Eclipse简介 

它基于Java语言编写，目前最流行的Java集成开发工具之一。Eclipse所有代码都是开源的，可扩展。

使用Eclipse

Java语言基础

Java主类结构

包声明

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

声明成员变量和局部变量

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

编写主方法

main()方法是类体中的主方法。该方法从"{"开始，至"}"结束。public、static和viod分别是main()方法的权限修饰符、静态修饰符和返回值修饰符。

基本数据结构

数值型

整数类型(byte、short、int、long)

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

浮点类型

(float、double）

用来存储含有小数部分的数值。分为单精度浮点类型（float）和双精度浮点类型（double）

字符型

char型

字符类型（char）用于存储单个字符，要用单引号表示，如's'表示一个字符。"s"则表示一个字符串。

转义字符

它以反斜杠"\"开头，后跟一个或多个字符。意思是"回车换行"。

布尔型

又称逻辑类型，简称布尔型，通过关键字boolean来定义布尔类型变量。布尔类型只有true和false两个值，分别代表布尔逻辑中的“真”和“假”

变量与常量

在程序执行过程中，其值不能被改变的量称为常量，其值能被改变的量称为变量。

标识符和关键词

标识符

是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。标识符由任意顺序的字母(英文字母，大小写都可)、下划线(_)、美元符号($)和数字(不可放在第一位)组成。标识符不能是Java中的关键字，变量名中不可有斜杠。

关键词

是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。

声明变量

变量名必须是一个有效的标识符

变量名不可以使用Java中的关键字

变量名不能重复

应选择有意义的单词作为变量名

声明常量

通常也被称为"final变量"，常量在整个程序中只能被赋值一次。

变量的有效范围

成员变量

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

局部变量

在类的方法体中声明的变量（方法内部定义，”{“与”}“之间的代码中声明的变量）称为局部变量。局部变量只在当前代码块中有效，也就是只能在”{“与”}“之内使用。

运算符

赋值运算符

赋值运算符以符号“=”表示，它是一个二元运算符（对两个操作数做处理），其功能是将右方操作数所含的赋值给左方的操作数。左方的操作数必须是一个变量，而右方的操作数 则可以是任何表达式，包括变量、常量、有效的表达式。表达式中若含有两个以上的“=”运算符 ，会从最右方的“=”开始处理。

算术运算符

Java中的算术运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余）。其中，“+”和“-”运算符还可以作为数值的正负值的正负符号。

自增和自减运算符

符号在前，先运算后使用；符号在后，先使用，后计算。

比较运算符

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运行结果为true,否则为false.

逻辑运算符

逻辑运算符的操作元必须是boolean型数据。在逻辑运算符中，除了“！”是一元运算符，其他都是二元运算符。

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

逻辑运算符口诀：两者都为真，结果才是真。 只要有一者为真，结果就是真。非真即假，非假即真。

位运算符

位运算符除“按位与”和“按位或”运算符外，其他只能用于处理整数的操作数，包括byte、short、char、int和long等数据类型。位运算符是完全针对位方面的操作。

左边最高位是符号位，最高位是0表示正数，若位1则表示负数。负数采用补码表示。

三元运算符

三元运算符的使用格式为：返回值=判断公式？结果1：结果2

三元运算符的运算规则为：若条件式的值为true，则整个表达式取结果1，否则取结果2.

三元运算符等价于if...else语句，例如：

数据类型转换

类型转换是将一个值从一种类型更改为另一种类型的过程。数据类型转换有两种，可分为：

隐式类型转换：也叫自动类型转换，它一定不会丢失数据。

从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这些类型按精度从低到高排列的顺序为byte<short<int<long<float<double。

显式类型转换：也叫强制类型转换，有可能会丢失数据

当把高精度的变量的赋值给低精度的变量时，必须使用显式类型转换运算

例如，将高精度数字转换为低精度数字。代码如下：

代码注释与编码规范

单行注释

语法：//注释内容

多行注释

语法：

流程控制

复合语句

Java语言的复合语句是以整个块区为单位的语句，所以又称块语句。复合语句由开括号"{"开始，闭括号"}"结束。

复合语句中的每个语句都是从上到下被执行。

条件语句

条件语句可根据不同的条件执行不同的语句。

if条件语句

使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的“布尔表达式”。如果该表达式返回的结果为true，则执行其后的语句;如果为false，则不执行if条件之后的语句。

简单的if条件语句

if...else 语语句

通常表现为”如果满足某种条件，就进行某种处理，否则就进行另一种处理。”

if...else if多分支语句

通常表现为“如果满足满足某种条件，就进行某种处理，否则如果满足另一种条件则执行另一种处理”。

switch多分支语句

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

循环语句

while循环语句

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

do...while循环语句

do...while循环语句：与while循环语句相似，区别在于while语句先判断条件是否成立再执行循环体。do...while循环语句先执行一次循环后，在判断条件是否成立。

for循环语句

for循环时Java程序设计中最有用的循环语句之一。可以用来重复执行某条语句，直到某个条件得到满足。

循环控制

break语句

跳出当前循环

运行流程图：

continue语句

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

运行流程图：

数组

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

一维数组

数组作为对象允许使用new关键词进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。

先声明，再用new关键词进行内存分配

声明一维数组有下列两种方式：

声明的同时为数组分配内存空间

使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0

语法：

二维数组

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

先声明，再用new关键字进行内存分配

语法：

声明的同时为数组分配内存空间

数组的基本操作

遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。 遍历二维数组需使用双层for循环，通过数组的length属性可获得数组长度。 在遍历数组时，使用foreach语句可能会更简单。

填充替换数组元素

子主数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型：

1、fill(int[] a,int value)

该方法可将指定的int值分配给int型数组的每个元素

2、fill(int[] a,int fromlndex,int tolndex,int calue)

该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromlndex（包括）一直到索引tolndex（不包括）。如果fromlndex=tolndex，则填充范围为空。

对数组进行排序

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：Arrays.sort(数组名)

前改后不改

复制数组

Arrays类的copyOf()方法与copyRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyRange()方法则将指定数组的指定长度复制到一个新数组中。

1、copyOf()方法

该方法提供了多种重载形式，用于满足不同类型数组的复制。语法如下：

2、copyRange()方法

该方法同样提供了多种重载形式。语法如下：

查询数组

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

1、binarySearch(Object[] a,Objrct key)

语法如下：

2、binarySearch(Object[] a,int fromlndex,int tolndex,Objrct key)

语法如下：

数组排序算法

冒泡排序

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放、较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序。

冒泡排序由双层循环实现，其中外层循环用于控制排序轮数。

运行结果：

直接选择排序

直接选择排序属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法。

反转排序

把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。

类和对象

面向对象概述

对象

现实世界中，随处可见的一种事物就是对象。对象是事物存在的实体，如人、书桌、计算机、高楼大厦等。通常都会将对象划分为两个部分，即静态部分与动态部分。

静态部分就是不能动的部分，这个部分被称为“属性”，任何对象都会具备其自身属性，如一个人，其属性包括高矮、胖瘦、性别、年龄等。

静态部分就是不能动的部分，这个部分被称为“属性”，任何对象都会具备其自身属性，如一个人，其属性包括高矮、胖瘦、性别、年龄等。动态部分即对象

类

类就是对象的设计图

类就是同一类事物的通常。类是封装对象的属性和行为的载体，反过来说，具有相同属性和行为的一类实体被称为类。例如，鸟类封装了所有鸟的共同属性和具有的行为。

封装

封装是面向对象编程的核心思想。

将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。

封装可以提高程序的可维护性。

继承

一个类处于继承体系中，它既可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类，继承父类的属性和方法。

多态

继承、父类和子类，其实将父类对象应用于子类的特性就是多态。

类

成员变量

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

成员方法

在Java语言中，使用成员方法对应于类的行为。以Book类为例，它包括getName()和setName()两个方法，定义成员方法的语法格式如下：

权限修饰符

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

使用getter(获取)和setter(设置)方法：this表示这个类

局部变量

如果在成员方法内定一个变量，那么这个变量被称为局部变量

局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

例6.2：在ChangeDemo类中创建静态的exchange（）方法，该方法可以将数组参数arr的前两个元素值互换，通过在方法中定义一个保存临时数据的局部变量tmp,利用tmp交换两个。

局部变量的有效范围

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

this关键字

this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键词只能在本类中使用。

类的构造方法

在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。

静态变量和静态方法

由static修饰的变量和方法被称为静态变量和动态方法。被声明为static的变量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和”.“运算符调用静态成员。

静态成员同样遵循着public、private和protected修饰符的约束。

总结以下使用static关键字要注意的几点：

类的主方法

主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。

主方法的语法如下：

对象

Java是一门面向对象的程序设计语言，对象是由类实例化而来的，所有问题都通过对象来处理。对象可以通过操作类的属性和方法来解决相应的问题。

对象的创建

在Java语言中，通过new操作符来创建对象。准确的来说，可以在Java语言中使用new操作符调用构造方法创建对象。语法如下：

访问对象的属性和行为

用户使用new操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。

对象的引用

语法：类名 对象的引用变量

继承、多态、抽象类和接口

类的继承

Java语言每个类只能继承一个父类，叫做单继承。

所有的类的构造方法，第一行都有一个隐藏的“super();”，作用是在执行该构造方法之前调用其父类的构造方法。 public只能有一个，用public修饰的类就是类名(文件名)。

Object类

在Java中所有的类都直接或间接继承了Java.lang.Object类。Object类是比较特殊的类，它是所有类的父类。

getClass()方法

它会返回对象执行时的Class实例，然后使用实例调用getClass()方法可以取得类的名称。语法如下：getClass().getname();

toString()方法

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

equals()方法

在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals()方法。两者的区别在于：“==”比较的是两个对象，应用内存地址是否相同，而equals()方法比较的是两个对象的实际内容。

对象类型的转换

向上转型

子类转父类 ，子类对象赋值给父类引用。子类类型的对象直接赋值给父类类型的对象。自动类型转换

向下转型

父类转子类，父类对象赋值给子类引用。可以理解为将父类类型的对象转换为子类类型的对象。但是运用向下转换，如果把一个叫抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误，这时就需要借助强制类型转换。

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

语法如下：1、对象名 instanceof 类名

判断对象是否属于该类或其子类。

2、对象名 instanceof 接口名

判断对象是否属于该接口的实现类

方法的重载

方法名相同，参数不同（返回参数不同，传入参数不同）

final 关键字

final被译为”最后的“”最终的“，凡是被final关键词修饰过的内容都是不可改变的。

final变量

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

final方法

修饰方法——不能被重写

final类

修饰类——不能被继承

多态

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

抽象类和接口

抽象类

使用abstract关键字定义的类称为抽象类，使用这个关键字的方法称为抽象方法。

接口

所有方法都是抽象方法

包和内部类

Java类包

在 Java中每定义好一个类，通过Java编译器之后，都会生成一个扩展名为.class的文件。

类名冲突

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

创建包

在Eclipse中创建包的步骤如下： 1.新建一个项目，然后右击src，选择new、Package。

2.弹出“新建Java包”New Java Package对话框，在“名称”Name文本框中输入的包名Package3，然后点击完成Finish.

3.在Eclipse中创建类时，可以在新建里的包“Package3”右击，选择新建new，然后点击class新建。

导入包

import关键字的语法如下：

在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用import关键字指定时在包指定后加上*，这表示可以在程序中使用该包中的所有类。 import关键字除了导入包外，还可以导入静态成员，导入静态成员可以使编程更为方便。

在类中应用包与权限修饰符，可以控制其他人对类成员的访问。

内部类

成员内部类

1.成员内部类简介

在成员内部类中可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private。 内部类初始化方式与其他类的初始化方式相同，都是使用new关键字。

2.使用this关键词获取内部类与外部类的引用

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

匿名内部类

使用匿名类时应该遵循以下原则：

异常处理

异常的抛出与捕捉

抛出异常

异常抛出后，如果不做任何处理，程序就会被终止

本实例报出的是NumberFormatException（字符串转换为数字）异常。

捕捉异常

Java语言的异常捕获结构有try、catch和finally3种部分组成。其中，try语句块存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。语法如下：

1、try-catch语句块

运行结果：

2、finally语句块

完整的异常处理语句一定要包括finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally语句。但是，在以下4种特殊情况下，finally块不会被执行：

Java常见的异常类

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

使用 Java 内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户只需继承Exception类即可自定义异常类。在程序中使用自定义异常类，大体可分为以下几个步骤: (1)创建自定义异常类。 (2)在方法中通过throw关键字抛出异常对象。 (3)如果在当前抛出异常的方法中处理异常，可以使用 try-catch 语句块捕获并处理，否则在方法的声明处通过 throws 关键字指明要抛出给方法调用者的异常，继续进行下一步操作。 (4)在出现异常的方法的调用者中捕获并处理异常。

自定义异常

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

在方法中抛出异常

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

异常的使用原则

编写代码处理某个方法可能出现的异常时，可遵循以下几条原则: 1、在当前方法声明中使用ty-catch语句捕获异常。 2、一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。 3、如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。

字符串

String类

创建字符串

1.String(char a[])

该方法用一个字符数组a创建 String 对象，代码如下: char a[ ] = {'g','o','o','d'}; String s = new String(a);等价于  String s = new String("good")

2.String(char a[], int offset, int length)

该方法提取字符数组 a 中的一部分创建一个字符串对象。参数 ofset 表示开始截取字符串的位置length 表示截取字符串的长度。代码如下: char a[] ={ 's','t','u','d','e','n','t'}; String s = new String(a,2,4);等价于  String s = new String("uden");

3.String(char[] value)

该构造方法可分配一个新的 String 对象，使其表示字符数组参数中所有元素连接的结果。代码如下: char a[]={'s','t','u','d','e','n','t'}; String s = new String(a);等价于   String s = new String("student");

声明字符串

在Java语言中，字符串必须包含在一对双引号(" ")之内。例如： “23.23”、“ABCDE”、“你好”

连接字符串

连接多个字符串

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

运算符是有优先级的，圆括号的优先级最高，所以先被执行，然后再将结果与字符串相连。

获取字符串信息

获取字符串的长度

使用Sting 类的length0方法可获取声明的字符串对象的长度。语法如下：str.length(); 其中，str为字符串对象。

获取字符串长度，代码如下： String str = "We are students"; int size = str.length(); 上段代码是将字符串 sr 的长度值给 in 型变量 size，此时变量 size 的值为 15，这表示 ngth方法返回的字符串的长度(包括字符串中的空格)。

字符串查找

1、indexOf(String s)

该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。

2、lastIndexOf(String str)

该方法用于返回指定字符中最后一次出现的索引位置。

获取指定索引位置的字符

使用 charAt()方法可将指定索引处的字符返回。语法如下:str.charAt(int index)  str：任意字符串。  index：整型值，用于指定要返回字符的下标。

字符串操作

获取子字符串

1.substring(int beginIndex)

该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下.:str.substring(int beginlndex) 其中，beginIndex 指定从某一索引处开始截取字符串。

2. substring(int beginlndex, int endlndex)

该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如下:substring(int beginindex, int endindex) beginIndex:开始截取子字符串的索引位置。 endIndex:子字符串在整个字符串中的结束位置。

去除空格

trim()方法返回字符串的副本，忽略前导空格和尾部空格。语法如下:str.trim() 其中，str 为任意字符串对象。

字符串替换

replace0方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下: str.replace(CharSequence target, CharSequence replacement) target:要替换的字符或字符串。 replacement:用于替换原来字符串的内容。

判断字符串的开始与结尾

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

1、startsWith()方法

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

2、endsWith()方法

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

判断字符串是否相等

使用比较运算符比较两个字符串。代码如下: String tom = new String("I am a student"); String jerry = new String("I am a student"); boolean b = (tom == jerry); 此时，布东型交量b的值为flse，因为字符串是对象，tom、jcny是引用。因此，要比较两个字符串内容是否相等，应使用 equals0方法和cqualslgnorcCase()方法。

1.equals()方法

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

2.equalsIgnoreCase()方法

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

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

如果按字典顺序此 String对象位于参数字符串之前，则比较结果为一个负整数;如果字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数:如果这两个字符串相等，则结果为0。语法如下：str.compareTo(String otherstr)

字母大小写转换

1.toLowerCase()方法

该方法将字符串中的所有大写字母转换为小写。sir.toLowerCase()

2.toUpperCase()方法

该方法将字符串中所有的小写字母转化为大写。str.toUpperCase()

字符串分割

使用split()方法可以使字符串按指定的分割线字符或字符串进行分割，并将分割后的结果存放在字符串数组中。

1、split(String sign)

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

2、split(String sign,int limit)

该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。语法如下：str.split(String sign,int limit) sign:分割字符串的分制符，也可以使用正则表达式 limit: 限制的分割次数。

格式化字符串

String类的静态format()方法用于创建格式化的字符串。

1、format(String format,Object...args)

该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地器的语言环境。语法如下:str.format(String format,Object...args)

2、format(Local l,String format,Object...args)

该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串用其指定的语言环境。语法如下: str.format(Local l,String format,Object...args)

日期和时间字符串格式化

1、日期格式化

返回一个月中的天数，代码如下: Date date = new Date():        //创建 Date 对象date String s = String.format("%te",date);  //通过 format()方法对 date 进行格式化 变量s的值是当前日期中的天数，如今天是 15 号，则s 的值为 15;%te 是转换符。

2、时间格式化

使用format()方法不仅可以完成日期的格式化，也可以实现时间的格式化。

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

格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常用的如表所示：

常规类型格式化

常规类型格式化可应用于任何参数类型，可通过如表所示：

使用正规表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。

在正则表达式中，可以使用方括号括起着于个字符来表示一个元字符，该元字符可代表方括号中任何一个字符。例如，B一“labc14"，这样字符 4、b4、c4 都是和正则表达式匹配的字等事号书括号元字符还可以为其他格式,如：  [456]:代表4、5、6之外的任何字符。 [a-r]: 代表 a~r中的任何一个字母。 [a-ZA-Z]:可表示任意一个英文字母。  [a-e[g-z]]: 代表a~e或 g~z 中的任何一个字母(并运算)。 [a-o&&[def]:代表字母 d、e、f (交运算)。  [a-d&&[^bc]]:代表字母 a、d(差运算)。

在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如,“A*”代表 A 可在字符串中出现0次或多次。限定修饰符的用法如表所示：

字符串生成器

1、append()方法

该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下:append(content) 其中，content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象。

2、insert(int offset,arg)方法

该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下:insert(int offset arg)  offset: 字符串生成器的位置。该参数必须大于等于 0，且小于等于此序列的长度。 arg: 将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。

向字符串生成器中指定的位置添加字符，代码如下: StringBuilder bf = new StringBuilder("hello");//创建字符生成器 bf.insert(5, "world");//添加至字符生成器的位置及内容 System.out.printin(bf.toString());//此时输出信息为 helloworld

3、delete(int start, int end)方法

移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end-1 处的字符。如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。语法如下:delete(int start , int end)  start;将要删除的字符串的起点位置。 end:将要删除的字符的终点位置。

删除指定位置的子字符串，代码如下: StringBuilder bf = new StringBuilder("StringBuilder");//创建字符串生成器 bf.delete(5.10);//删除的子字符串 System.out.println(bf.toString());//此时输出的信息为 Strinder

常用类库

包装类

它主要是将基本数据类型封装在包装类中，如int型的包装类Integer、boolean型的包装类Boolean等，这样便可以把这些基本数据类型转换为对象进行处理。Java中的包装类及其对应的基本数据类型如下表：

Integer类

Integer类的常用方法如下表：

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

Double类

Double类的常用方法如下：

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

Boolean类

Boolean类的常用方法如下表：

Boolean 提供了以下3个常量: TRUE:对应基值 true 的 Boolean 对象。 FALSE:对应基值false的 Boolean 对象。 TYPE:基本类型boolean的Class对象。

Character类

Character类提供了很多方法来完成对字符的操作，常用的方法如下表：

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

Number类

doubleValue0方法返回双精度浮点值，floatValue0方法返回单精度浮点值，这些方法如下表：

数字处理

数字格式化

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

格式化模板中的特殊字符及其所代表的含义。

Math类

所以在程序中应用比较简便可以使用如下形式调用: Math. 数学方法

在Math类中，除函数方法外还存在一些常用数字常量，如PI、E等。这些数学常量作为Math 关的成员变量出现，调用起来也很简单。可以使用如下形式调用: Math.PI Math.E

1.三角函数方法

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

2.指数函数方法

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

5

3.取整函数方法

在具体的问题中，取整操作使用也很普遍，所以Java 在 Math 类中添加了数字取整方法。Math 类中主要包括以下几种取整方法:  public static double ceil(double a):返回大于等于参数的最小整数。 public static double foor(double a): 返回小于等于参数的最大整数。 public static double rint(double a): 返回与参数最接近的整数，如果存在两个同样接近的整数则结果取偶数。  public staticintround(float a):将参数加上0.5后返回与参数最近的整数。  public static long round(double a): 将参数加上0.5 后返回与参数最近的整数，然后强制转换为长整型。

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

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

Random类

Random类是JDK 中的随机数生成器类，可以通过实例化一个 Random 对象创建一个随机数生成器，语法如下: Random r = new Random(); 用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下: Random r = new Random(seedValue); r：Random类对象。 seedValue:随机数生成器的种子。

在Random类中，提供了获取各种数类机数的方法，下面列举几个常用的方法: public int nextint():返回一个随机整数。 public int nextInt(int n): 返回大于等于0且小于n 的随机整数。 public long nextLong():返回一个随机长整型值。 public boolean nextBoolean():返回一个随机布尔型值。 public float nextFloat0: 返回一个随机单精度浮点型值。 public double nextDouble():返回一个随机双精度浮点型值。 public double nextGaussian(): 返回一个概率察度为高斯分布的双精度浮点型值。

BigInteger类

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

下面列举了 Biglnteger类中常用的几种运算方法：  public BigInteger add(BigInteger val): 做加法运算。 public BigInteger subtract(BigInteger val): 做减法运算。 public BigInteger multiply(BigInteger val): 做乘法运算。 public BigInteger divide(BigInteger val): 做除法运算。 public BigInteger remainder(BigInteger val): 做取余操作。 public BigInteger[] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。 public BigInteger pow(int exponent): 进行取参数的 exponent 次方操作。 public BigInteger negate(): 取相反数。  public BigInteger shifLeft(intn): 将数字左移n位，如果n为负数，做右移操作。  public BigInteger shiftRight(int n): 将数字右移n 位，如果n为负数，做左移操作。 public BigInteger and(BigInteger val): 做与操作。 public BigInteger or(BigInteger val): 做或操作。  public int compareTo(BigInteger val): 做数字比较操作。 public boolean equals(Object x): 当参数是 BigInteger 类型的数字并且数值与对象实例的数值相等时，返回 true。 public BigInteger min(BigInteger val): 返回较小的数值。 public BigInteger max(BigInteger val): 返回较大的数值。

BigDecimal类

在 BigDecimal类中，常用的两个构造方法如下表：

BigDecimal 实现的加、减、乘、除的方法如表下：

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

System类

并且这些方法全部都是静态的。System 类提供的较常用方法如下表：

控制台输出字符

1.不会自动换行的print()方法

print()方法的语法如下： System.out.print("Hello!");

2.可以自动换行的println()方法

printin()方法在 print 后面加上了“ln”后缀 (就是 line 的简写)，语法如下: System.out.println("书籍是人类进步的阶梯!");

Scanner类

使用 Scanner 类首先要引入该类，其语法如下: import java.util.Scanner;        //引入 Scanner类

Scanner 类提供了如表 11.13 所示的几种常用的方法，通过这些方法可以取控制台中输入的不同类型的值。

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

日期时间类

Date类

日期时间格式化

首先需要创建 DateFormat 类的一个对象，由于它是抽象类，因此可以使用其静态方getDateInstance()进行创建，语法如下: DateFormat df = DateFormat.getDatelnstance();

Calendar类

Calendar 类的getInstance()方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化，其使用方法如下: Calendar rightNow = Calendar.getlnstance();

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

Runtime类

Runtime 类不能使用 new 关键字创建实例，只能通过 Runtime. getRuntime()方法获取实例。

执行本地命令

Runtime 类提供 exec()方法让 Java 代码可以执行系统的命令，exec()方法有很多重载的形式，例如: Process exec(String command) Process exec(Stringl cmdarray)

其实这两个重载方式很类似，如执行“javac hello.java”这行命令，使用第一种重载方式的代码如下 <strike>Runtime.getRuntime().exec("javac hello.java");</strike> 使用第二种重载方式的代码如下: String command] =  {"javac", "hello,java" }; Runtime.getRuntime().exec(command);

查看内存

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