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

初识Java

Java简介

什么是Java语言

Java是一种通过解释方式来执行的语言

Java的应用领域

桌面应用系统开发

嵌入式系统开发

电子商务应用

企业级应用开发

交互式系统开发

多媒体系统开发

分布式系统开发

Web应用系统开发

移动端应用开发

Java的版本

Java SE

Java EE

JavaAPI文档

应用程序编程接口

Java语言的特性

简单

Java语言是一种面向对象的语言,它通过提供最基本的方法来完成指定的任务,只需理解一些基本的概念,就可以用它编写出适合于各种情况的应用程序。

面向对象

Java语言的设计集中于对象及其接口,它提供了简单的类机制以及动态的接口模型。

分布性

Java是面向网络的语言。通过它提供的类库可以处理tcP/iP协议,用户可以通过uRL地址在网络上很方便地访问其它对象。

可移植性

与平台无关的特性使Java程序可以方便地被移植到网络上的不同机器。

解释型

解释型语言的源代码不是直接翻译成机器码，而是先翻译成中间代码，再由解释器对中间代码进行解释运行。在运行的时候才将源程序翻译成机器码，翻译一句，然后执行一句，直至结束。

安全性

用于网络、分布环境下的Java必须要防止病毒的入侵。

健壮性

Java 的强类型机制、异常处理、垃圾回收机制等都是 Java 健壮性的重要保证。对指针的丢弃是 Java 的一大进步。另外，Java 的异常机制也是健壮性的一大体现。

多线程

多线程机制使应用程序能够并行执行,而且同步机制保证了对共享数据的正确操作。

高性能

和其它解释执行的语言如basic、tcL不同,Java字节码的设计使之能很容易地直接转换成对应于特定cPu的机器码,从而得到较高的性能。

动态

Java的设计使它适合于一个不断发展的环境。

搭建Java环境

下载JDK

先确定计算机系统的位数，然后再下载相应的版本

搭建JDK环境

解压缩

配置环境变量

熟悉Eclipse开发工具

下载Eclipse

官网下载安装包

下载汉化包

Eclipse的界面

视图

菜单栏

工具栏

使用Eclipse

配置与启动

创建Java项目

创建Java类文件

编写Java代码

运行Java代码

调试Java代码

Java语言基础

Java主类结构

包声明

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间，防止类名冲突，可以让类的用户更让容易检索到类。 包的本质就是文件夹！！

声明成员变量和局部变量

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

编写主方法

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

导入API类库

在Java语言中可以通过import关键字导入相关的类

基本数据类型

整数类型

浮点类型

字符类型

char型，用于存储单个字符

布尔类型

布尔类型又称逻辑类型，只有true和false两种结果

变量与常量

标识符和关键字

一.标识符 标识符是由字母，下划线，美元符号和数字组成 数字不能为开头 要注意避开关键字 二.关键字：关键字又称保留字，是java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。

声明变量

成员变量：成员变量在整个类中都有效 局部变量：局部变量只在当前代码块中有效

声明常量

常量在整个程序中只能被赋值一次，且不能改变，如果一个常量已经被赋值了之后再次给它赋值就会报错，然后强行运行就会报错

运算符

赋值运算符

赋值运算符以符号“=”表示，它是一个二元运算符，其功能是将右方的值赋给左方的操作数。

算术运算符

java中的运算符主要有+（加）-（减）*（乘）/（除）%（求余），这些都是二元运算符。

自增和自减运算符

符号在前先运算再使用 符号在后先使用再运算

比较运算符

1、>比较左方是否大于右方 2、<比较左方是否小于右方 3、==比较左方是否等于右方 4、>=比较左方是否大于等于右方 5、<=比较左方是否小于等于右方 6、！=比较左方是否不等于右方

逻辑运算符

&：两者都为真结果才为真 |：只要有一者为真结果即为真 ！：非真即假 非假即真

位运算符

1、“按位与”运算 &：两者都为1，结果才是1 2、“按位或”运算 |只要有一者为1，结果就是1 3、“按位取反”运算 1变0，0变1 4、“按位异或”运算 两者相同即为0，不同则为1 5、移位操作 <<:左移 整体左移 空位补0 溢出去掉 >>:右移 整体右移 正数空位补0 负数空位补1 溢出去掉 >>>：无符号右移 整体右移 空位补0 溢出去掉

三元运算符

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

数据类型转换

隐式类型转换

又称自动类型转换：一定不会丢失数据

显式类型转换

又称强制类型转换：有可能会丢失数据

代码注释与编码规范

单行注释“//”

多行注释“/**/”

文档注释“/** */”

流程控制

复合语句

Java 语言的复合语句是以整个块区为单位的语句，所以又称为块语句。\n\n复合语句由开括号“{”开始，闭括号“}”结束。（提示：在使用复合语句时要注意，复合语句为局部变量创建了一个作用域，该作用域为程序的一个部分，在该作用域中某个变量被创建并且能够被使用。如果在某个变量的作用域外使用该变量，则会发生错误。）

条件语句

if条件语句

if....else语句

if....else if多分支语句用于针对某一事件的多种情况进行处理，通常表现为“如果满足某种条件，就进行某种处理，否则如果满足另一种条件则执行另一种处理”

switch多分支语句

循环语句

while循环语句

do...while循环语句

（先执行在判断）\ndo{ 循环操作；\n\n}while（循环条件）；

for循环语句

(参数初始化；条件判断；更新循环变量){\n\n 循环操作；\n\n} do while\ndo while和while的区别\ndo while会先执行循环体再判断条件，while先判断条件再执行循环体\ndo while最少执行一次，while可以一次都不执行

循环控制

break语句

break语句用于终止下面的case语句，用于强制退出循环，也就是忽略循环体中任何的循环条件和其他语句的限制。

continue语句

Continue语句只能应用在for、while、do..while循环语句，用于让程序直接直接跳转到后面的其他语句，进入下一次的循环。\n（3）break语句和continue语句的比较\n 1.使用场合\n break可用于switch结构和循环结构中\n continue只能用于循环结构中\n 2.作用\n break语句终止某个循环，程序跳转到循环块外的下一条语句。\n continue跳出本次循环，进入下一次循环

数组

数组概括

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

一维数组

声明

数组元素的类型【】 数组名 数组元素的类型 数组名 【】

分配内存

数组名=new 数组元素的类型【数组长度】 分配内存同时设置初始值 数组名=new 数组元素的类型【】{值1，值2，...，值n}

元素赋值

数组名[ 索引 ]（类似于序号）=值；

二维数组

声明

数组元素的类型【】 数组名 数组元素的类型 数组名 【】

分配内存

数组名=new 数组元素的类型[行数][列数] 二维数组分配内存同时设置初始值 数组名=new 数组元素的类型【】{{值1，值2，...},{值1，值2，...},{值1，值2，...}}

元素赋值

数组名[ 索引 ]= {值1，值2，...}； 数组名[ 行号 ][ 列号 ]= 值 ；

数组的基本操作

遍历数组

遍历数组就是获取数组中的每个元素

替换数组

替换数组：Arrays.fill(数组名，值);

替换部分数组元素：前改后不改 Arrays.fill(数组名，前索引，后索引，值);

对数组进行排序

Arrays.sort（数组名）；

复制数组

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

复制数组部分元素：前在后不在 新数组名=Arrays。copyOFRange（旧数组名，前索引，后索引）；

查询数组

查询数组元素：先排序再查询 索引= Arrays.binarySearch(数组名，值）；

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

数组排序算法

冒泡排序

直接选择排序

反转排序

类和对象

面对对象概括

对象

面向过程：代码紧密，不易分开，可维护性差

面向对象：可维护性强

类

就是同一类事物的统称，如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称，如鸟类、家禽类、人类等等。 简单来说就是创建的class

封装

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

继承

继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。 类与类之间同样具有关系，这种关系被称为关联。关联主要描述两个类之间的一般二元关系。

多态

继承，父类和子类，其实将父类对象应用于子类的特征就是多态。 简单地调用父类也就是图形类绘制图的方法即可绘制任何图形，这就是多态最基本的思想。 多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类及相关类。 在多态的机制中，比抽象类更方便的方式是将抽象类定义为接口。由抽象方法组成的集合就是接口

类

成员变量

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

成员方法

在Java语言中，使用成员方法对应于类对象的行为

权限修饰符

当声明类时不使用public、protected和private修饰符设置类的权限，则这个类预设为包存取范围，即只有一个包中的类可以访问这个类的成员变量或成员方法。

局部变量

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

局部变量的有效范围

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到改变量的结束为止。（但是在相互嵌套的区域中不可以这样声明，如果将局部变量id在方法体的for循环中再次定义，编译器会报错，）

this关键字

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

类的构造方法

1.构造方法没有返回值 2.构造方法的名称要与本类的名称相同。

静态变量和静态方法

静态就是static，可以有静态常量、静态变量、静态方法和多个语句静态 静态是这个类的专属，只有这个类可以用，就是这个文件可以用，只要它们在一个文件里就行

类的主方法

主方法是类的人口点，它定义了程序从何处开始。

对象

对象的创建

在Java语言中使用new操作符调用构造方法创建对象

访问对象的属性和行为

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

对象的引用

在Java语言中，尽管一切都可以看作对象，但真正的操作标识符实质上是一个引用。

对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收。在其他语言中，需要用户手动回收废弃的对象。  1、对象引用超过其作用范围，这个对象将被视为垃圾             2、  这个对象被赋值为null

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

类的继承

类在继承关系中分为两种，一种是父类，属于是被继承类，一种是子类，属于是继承类，如果某一个类继承了另一个类，那么该类就是子类，被继承的类就是父类。Java语言每个类只能继承一个父类/单继承，在Java语言中，一个类继承另一个类需要使用关键字extends，所有类的构造方法第一行都有一个隐藏的“super（）；”作用是在执行该构造方法之前调用其父类构造方法。子类在继承父类之后，创建子类对象的同时也会调用父类的构造结果。子类继承父类之后可以调用父类创建的好的属性和方法（Java虽然不允许同时继承两个父类，但不代表没有多继承的关系，可以通过类似“祖父>父亲>儿子>孙子”之类的方式实现多代继承。）。

Object类

1.getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的class实例，然后使用此实例调用getName()方法可取的类的名称。语法如下 getClass().getName(); 可以将getClass()方法与toString()方法联合使用。

2.toString()方法

oString()方法的功能是将一个对象返回为字符串形式，它会返回一个String实例。在实际的应用中通常重写toString()方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法。

3.equals()方法

在使用equals() 方法比较自行编写的类对象时，那么需要先重写equals方法，因为每个类判相等的规则都是不一样的。而且如果没有重写的话，那么系统会自动调用Object中的equals方法。

对象类型的转换

向上转换

而向上转型就是将子类对象赋值给父类对象。可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型对象直接赋值给父类类型的对象。（需要注意得是，在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法。只能调用从父类中继承下来的属性与方法。）

向下转换

向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。 但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类， 而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。

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

关键词 instanceof 对象名  instanceof  类名 判断对象是否属于该类或子类

方法的重载

方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。

final关键字

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

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

final修饰类——不能被继承

多态

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

抽象类与接口

抽象类

在解决问题时，一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。回想继承和多态原理，继承数中越是在上方的类越抽象，在多态机制中，并不需要将父类初始化为对象，我们需要的只是子类对象，所以在Java语言中设置抽象类不可以实例化为对象。

接口

Java语言每个类可以实现多个接口； 语法如下： public interface Paintable {     void draw();  //定义接口方法可省略public abstract 关键字 } 修饰符 class 类名 implements 接口1, 接口2....{ }

包和内部类

Java类包

类路径

如果一个程序内存在多个同名不同包的max类，那么该如何使用指定包的类呢？ 在使用该类时使用该类的类路径，也成为绝对路径。

指定包名(package)

在进行创建包的时候需要注意的是，Java包的命名规则建议使用全小写字母进行命名。 需要了解的是如果一个类没有被定义在一个指定的包内，那么该类就被归纳到默认包(default package)中； 在某个包下面创建一个类的话，需要在这个类的开头加上表达式 package 包名，该表达式需要放置在程序的第一行，使用package关键字指定包名之后，包名也会成为类名的一部分，在不同包下使用该类的话，需要使用 import 包名.类名 的格式。

创建包

1.双击eclipse弹出路径对话框，并复制路径

2.复制路径到文件夹中查找

3.查找后，可以看见在Eclipse里的Java代码，选择一个项目，打开src

4.新建一个项目，在里面创建一个包，右击选择package；返回文件夹就能看新建的包

5.同时创建包并在包里创建一个类

6.创建包，存储域名

7.在创建包存储域名时，把域名一次性打上去

导入包

在Java中，如果需要使用到其它包内的类的话，除了使用该类的绝对路径之外，我们还可以使用Java中 import 关键字来指定。例如，如果在其它包内也定义了一个Math，那么假如我们只想使用该Math类的话，那么我们可以使用import关键字进行导包。在进行导包后，我们在使用该包下的Math类后，可以看到，java.lang包下有一个Java给定的Math类，还有一个我们刚刚进行导的包下的Math类； 需要注意的是，如果使用import导入某个包下的所有类时，这些类并不包括该包下的子包的类。如果需要使用子包中的类时，需要对子包进行单独引用。

导入静态方法或静态成员 使用import关键字还可以对静态方法与静态变量进行导包。

内部类

成员内部类

定义在一个类成员位置的内部类，称为成员内部类，在成员内部类中可以使用外部类的的任意成员变量与成员方法，即使该外部类成员变量被private所修饰。

匿名内部类

匿名内部类本质是一个隐藏了名字的内部类。匿名类是只有在创建时才会编写类体的一种写法。匿名类的特点：现用现写； 匿名内部类在一对大括号 { } 的范围内是一个类，整体却是一个new出来的对象。

异常处理

异常概括

在程序中，错误可能产生于程序员没有预料到的各种情况，或者是超出了程序员可控范围的环境因素，如试图打开一个根本不存在的文件等，在 Java中，这种在程序运行时可能出现的一些错误称为异常

异常的抛出与捕捉

抛出异常

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

举例代码：public class Thundering {       //创建类   public static void main(String[] args) {  //主方法 String str="lili";       //定义字符串 System.out.println(str+"年龄是:");   //输出的提示信息 int age = Integer.parseInt("20L");   //数据类型的转换 System.out.println(age);   //输出信息   }   }

因为计算机误把long类型的“20L”认为字符串，而字符串是不能转换为int类型的，所以报错； 将"L"删除，即可运行

捕捉异常

异常捕获结构由try、catch和finally 3部分组成，处理操作中的五个关键词： throws: 声明本方法中可能会发生某某异常 throw: 抛出某某异常 try, catch, finally: 捕获并处理某某异常

(1).try、catch语句就是用来捕捉和异常处理的；

举例代码：public class Take {       public static void main(String[] args) {         //数字格式异常         try {//try语句块中包含可能出现异常的程序代码             String str = "lili";//定义字符串变量             System.out.println(str + "年龄是:");//输出的信息             int age = Integer.parseInt("20L");//数据类型转换             System.out.println(age);         }catch(NumberFormatException e){//catch语句块用来获取异常信息             System.out.println("！！出现数字格式异常！！");             System.out.println("请联系管理员进行修复");//输出信息         }     }   }

(2).finally语句块 无论程序是否出现异常，都会执行finally语句，但是在以下四种情况不会执行finally语句块 1.在finally语句块中出现异常 2.在前面的代码块中使用了System.exit()退出程序 3.程序所在线程死亡 4.关闭cpu

Java常见的异常类

自定义异常

1.创建自定义异常类 2.在方法中通过throw关键字抛出异常对象。 3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续惊醒下一步操作。 4.在出现异常的方法的调用者中捕获并处理异常。

举例代码：public class Tran {           //创建类  static int avg(int num1,int num2) throws MyException {  //定义方法   if(num1 < 0 || num2 < 0) {       //判断方法中是否满足指定条件    throw new MyException("不可以使用负数");   //错误信息   }             //   if(num1 > 100 || num2 > 100) {      //判断方法中参数是否满足指定条件    System.out.println("大于100，午饭计算");   }   return (num1 +num2)/2;        //将参数的平均值返回  }  public static void main(String[] args) {    //主方法   try {            //try语句处理可能出现异常的代码    int result = avg(-32,56);      //调用avg()方法    System.out.println(result);      //将avg()方法的返回值输出   }catch(MyException e) {    System.out.println(e);       //输出异常信息   }   }  }

在方法中抛出异常

1、使用throws关键字抛出异常

1).使用try-catch捕获并解决异常 (2).在当前方法上继续使用throws声明该异常的抛出

举例代码：public class Shoot {  static void pop()throws NegativeArraySizeException{    //定义方法并抛出NegativeArraySizeException异常   int [] arr=new int[-3];  }    public static void main(String[] args) {   // TODO Auto-generated method stub   try{    pop();   }catch(NegativeArraySizeException e) {    System.out.println("pop()方法抛出的异常");   }  }   }

2、使用throw关键字抛出异常

通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句块。

举例代码：public class Captor {                 //创建类   static int quotient(int x,int y)throws MyException{     //定义方法抛出异常    if(y < 0) {                                            //判断参数是否小于0     throw new MyException("除数不能是负数");                //异常信息    }    return x/y;                                            //返回值   }   public static void main(String[] args) {                //主方法    try {                                                  //try语句块包含可能发生异常的语句     int result =quotient(3,-1);                           //调用方法quotient（）    }catch(MyException e) {                                //处理自定义异常     System.out.println(e.getMessage());                   //输出异常信息    }catch(ArithmeticException e) {                        //处理ArithmeticException异常     System.out.println("除数不能为0");                     //输出提示信息    }catch(Exception e) {                                  //处理其他异常     System.out.println("程序发生了其他的异常");              //输出提示信息    }     }    }

运行时异常

运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生； 当出现RuntimeException的时候，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。

异常的使用原则

(1).不要过度使用异常，虽然通过异常可以增强程序的健壮性，但如果使用过多不必要的异常处理，可能会影响程序的执行效率；

(2).不要使用过于庞大的 try...catch块；在一个try块中放置大量的代码。这种写法看上去“很简单”但是由于try块中的代码过于庞大，业务过于复杂，会造成try块中出现异常的可能性大大增加，从而导致分析异常原因的难度也大大增加；

(3).避免使用catch（Exception)；因为如果所有异常都采用相同的处理方式，将导致无法对同异常分情况处理;另外，这种捕获方式可能将程序中的全部错误，异常捕获到，这时如果出现些“关键”异常，可能会被“悄悄地”忽略掉；

(4).不要忽略捕捉到的异常，遇到异常一定要及时处理；

(5).如果父类抛出多个异常，则覆盖方法必须抛出相同的异常或其异常的子类，不能抛出来异常。

字符串

String类

声明字符串

在Java语言中，字符串必须包含在一对双引号（“”）之内 例如："23.23"、"ABCDE"、"你好"可以通过以下语法格式莱声明字符串变量： String str;

String:指定该变量为字符串类型。 str:任意有效的标识符，表示字符串变量的名称。

创建字符串

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

子主题

该方法用一个字符数组a创建String对象，代码如下：package a;   public class Test1 {    public static void main(String[] args) {   // TODO Auto-generated method stub   //字符串变量的申明   String s;   //字符串变量初始化   // s = ("你好");   s = new String("你好");   System.out.println(s);   //字符串变量初始化 传入字符类型数组   char[] ch = {'g','o','o','d'};   String st = new String(ch);   System.out.println(st);  }   }

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

该方法提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度 。代码如下：  package a;   public class Test1 {    public static void main(String[] args) {   // TODO Auto-generated method stub   //字符串变量的申明   String s;   //字符串变量初始化   // s = ("你好");   s = new String("你好");   System.out.println(s);   //字符串变量初始化 传入字符类型数组   char[] ch = {'g','o','o','d'};   String st = new String(ch);   System.out.println(st);   //字符串变量初始化 传入字符类型数组，两个数字   char[] cha = {'s','t','u','d','e','n','t'};   String str = new String(cha,1,4);   System.out.println(str);  }   }

String(char[] value)

该构造犯法可分配一个新的String对象，使其表示字符组参数中所有元素连接的结果。代码如下：  package a;   public class Test1 {    public static void main(String[] args) {   // TODO Auto-generated method stub   //字符串变量的申明   String s;   //字符串变量初始化   // s = ("你好");   s = new String("你好");   System.out.println(s);   //字符串变量初始化 传入字符类型数组   char[] ch = {'g','o','o','d'};   String st = new String(ch);   System.out.println(st);   //字符串变量初始化 传入字符类型数组，初始索引号，个数   char[] cha = {'s','t','u','d','e','n','t'};   String str = new String(cha);   System.out.println(str);   //字符串相连接   System.out.println(s+st);  }   }

除通过以上几种使用String类的构造方法赖创建字符串变量外，还可以通过将字符串常量的引用赋值给一个字符串变量来创建字符串。代码如下：  package a;   public class Test1 {    public static void main(String[] args) {   // TODO Auto-generated method stub   //字符串变量的申明   String s;   //字符串变量初始化   // s = ("你好");   s = new String("你好");   System.out.println(s);   //字符串变量初始化 传入字符类型数组   char[] ch = {'g','o','o','d'};   String st = new String(ch);   System.out.println(st);   //字符串变量初始化 传入字符类型数组，初始索引号，个数   char[] cha = {'s','t','u','d','e','n','t'};   String str = new String(cha,1,4);   System.out.println(str);   //字符串相连接   System.out.println(s+st);  }   }

连接字符串

1、连接多个字符串

使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。 例题10.1 package package1; public class Join {       //创建类    public static void main(String[] args) {//主方法   String s1 = new String("春色绿千里");//声明String对象s1   String s2 = new String("马蹄香万家");//声明String对象s2   String s = s1 + "\n" + s2;   //将对象s1、"\n"和对象链接并将结果赋值给s   System.out.println(s);    //将s输出    }   }

2、连接其他数据类型

字符串也可同其他基本数据类型进行连接。如果将字符串同其他数据类型进行连接，会将其他数据类型的数据直接转换成字符串。 例题10.2 package package1;   public class Link {  public static void main(String[] args) {   int booktime = 4;   float practice = 2.5f;   System.out.println("我每天花费"+booktime+"小时看书;"+practice+"小时上机练习");    }   }

获取字符串信息

1、获取字符串长度

使用String类的length（）方法可获取声明的字符串对象的长度。

2、字符串查找

1.indexOf(String s)

该方法用于但会参数字符串s在指定字符串中首次出现的索引位置 语法：str.indexOf(substr) str:任意字符串对象 substr: 要搜索的字符串 查找字符a在字符串str中的索引位置，代码如下： String str ="We are students"; int size = str.indexOf("a")       //变量size的值是3 2.lastIndexOf(String str)

2.lastIndexOf(String str)

该方法用于但会指定字符串最后一次出现的索引位置 语法：str.lastIndexOf(substr)  str:任意字符串对象 substr:要搜索的字符串 注意：如果lastIndexOf()方法中的参数是空字符串""(注意没有空格)，则返回的结果与调用length()方法的返回结果相同。

举例代码：package a;   public class Text {      //创建类    public static void main(String[] args) {          //主方法   // TODO Auto-generated method stub   String str ="We are students";               //定义字符串在str   int size = str.lastIndexOf("");              //定义字符串在str中的索引位置赋值给变量size   System.out.println("空字符串在字符串str中的索引位置是："+size);  //将变量size输出   System.out.println("字符串str的长度是："+str.length());        //将字符串str的长度输出  }   }

3、获取指定索引位置的字符

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

举例代码： public class Ref {    public static void main(String[] args) {   // TODO Auto-generated method stub   String str ="hellowworld";//定义字符串为str   char mychar=str.charAt(6);//将字符串中索引位置为6的字符返回   System.out.println("字符串str中索引位置是6的字符为："+mychar);//输出信息  }   }

字符串操作

1、获取子字符串

通过String类的substring()方法可对字符串进行截取。substring()方法被两种不同的重载形式，来满足不同的需要。

1.substring(int beginlndex)

该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串， 语法：str.substring(int beginIndex)  其中，beginIndex指定从某一索引处开始截取字符串 截取字符串，代码如下：   String str ="Hello World";         //定义字符串str String substr = str.substring(3);      //获取字符串，此时substr值为lo World 注意：在字符串中，空格占用一个索引位置

2.substring(int beginlndex，int endIndex)

该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串 语法：substring(int beginlndex，int endIndex) beginlndex：开始截取子字符串的索引位置  endIndex：子字符在整个字符串中的结束位置

代码：public class Subs {    public static void main(String[] args) {   // TODO Auto-generated method stub   String str ="《将进酒》：李白（唐）";   String substr=str.substring(6,8);//对字符串进行截取   System.out.println("《将进酒》的作者是："+substr);//输出截取后的字符串    }

2、去除空格

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

代码： public class Blak {             //创建类    public static void main(String[] args) {          //主方法   // TODO Auto-generated method stub    String str ="  Java    class    ";        //定义字符串str    System.out.println("字符串原来的长度："+str.length());      //将str原来的长度输出    //将str去掉前导和尾部的空格后的长度输出    System.out.println("去掉空格后的长度："+str.trim().length());  }   }

3、字符串替换

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。 语法;str.replace(CharSequence target,CharSequence replacement)  target:要替换的字符或字符串 replacement：用于替换原来字符串的内容 replace()方法返回的结果是一个新的字符串，如果字符或字符串oldChar没有出现在该对象表达式中的字符串序列中，则将原字符串返回。

代码： public class NewStr {    public static void main(String[] args) {   // TODO Auto-generated method stub   String str = "address";   String newstr =str.replace("a","A");//把a替换   System.out.println(newstr);//输出  }   }

4、判断字符串的开始与结尾

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

1.stsrtsWith()方法

该方法用于判断当前字符串对象的前缀是否为参数指定的字符串 语法：str.stsrtsWith(String prefix)    //prefix是指作为后缀的字符串

2.endsWith()方法

该方法用于判断当前字符串是否为以给定的子字符串结束 语法:str.endWith(String suffix)     //suffix是指作为后缀的字符串

5、判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==”

1.equals()方法

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

2.equalslgnoreCase()方法

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

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

compareToO方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。 如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。 语法如下：str.compareTo(String otherstr)     //str、otherstr是要比较的两个字符串对象 注意：compareTo()方法只有在equals(Object)方法返回true时才返回0

7、字母大小写转换

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

1.toLowerCase（)方法

该方法将字符串中的所有大写字母转换为小写 语法：str.toLowerCase（)       //str是要进行转换的字符串

2. toUpperCase（)方法

该方法将字符串中所有小写字母转换为大写 语法：str.toUpperCase（)       //str是要进行转换的字符串

8、字符串分割

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()方法用于创建格式化的字符串。format()方法有两种重载形式。

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

该方法使用指定的格式字符和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。 语法：str.format(String format,Object...args) format：格式化字符串 args:格式化字符串中由格式说明字符引用的参数

2.format(Local I,String format,Object...args)

该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用其指定语言环境。 语法：str.format(Local I,String format,Object...args) I:格式化过程中要应用的语言环境。 format:格式字符串 args：格式字符串中由格式说明符引用的参数。可以为0

1、日期和时间字符串格式化

1.日期格式化

举例代码： package a; import java.util.Date;      //导入java.util.Date类 public class Eval1 {          //新建类    public static void main(String[] args) {          //主方法   // TODO Auto-generated method stub   Date date = new Date();                //创建Date对象date   String year = String.format("%tY",date);          //将date进行格式化   String month = String.format("%tB",date);   String day = String.format("%td",date);   System.out.println("今年是："+year+"年");        //输出信息   System.out.println("现在是"+month);   System.out.println("今天是："+day+"号");  }   }

2.时间格式化

举例代码：package a; import java.util.Date;         //导入java.util.Date类 public class GetDate {            //新建类    public static void main(String[] args) {     //主方法   // TODO Auto-generated method stub   Date date = new Date();                //创建Date对象date   String hour = String.format("%tH",date);          //将date进行格式化   String minute = String.format("%tM",date);   String second = String.format("%tS",date);   System.out.println("现在是："+hour+"时"+minute+"分"+second+"秒");    //输出的信息      }   }

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

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

举例代码：package a; import java.util.Date;         //导入java.util.Date类 public class DateAndTime {      //创建类    public static void main(String[] args) {       //主方法   // TODO Auto-generated method stub   Date date = new Date();                //创建Date对象date   String time = String.format("%tc",date);          //将date进行格式化   String form = String.format("%tF",date);   System.out.println("全部的时间信息是："+time);    //将格式化后的日期时间输出   System.out.println("年-月-日格式："+form);   }   }

2、常规类型格式化

常规类型格式化可应用于任何参数类型，如下表：

举例代码：package a;   public class General {            //新建类    public static void main(String[] args) {        //主方法   // TODO Auto-generated method stub   String str = String.format("%d",400/2);          //将结果以十进制格式显示   String str2 = String.format("%b",3>5);           //将结果以boolean型显示   String str3 = String.format("%x",200);           //将结果以十六进制格式显示   System.out.println("400的一半是："+str);          //输出格式化字符串   System.out.println("3》5正确吗："+str2);    System.out.println("200的十六进制数是："+str3);   }   }

使用正则表达式

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

注意：在正则表达式中，“.”代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转移字符“\". 在正则表达式中，可以使用方括号括起若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。 方括号元字符还可以为其他格式，如： 1. [^456]:代表4、5、6之外的任何字符 2. [a-r]:代表a~r中的任何一个字母 3. [a-zA-Z]:可表示任意一个英文字母 4. [a-e[g-z]]:代表a~e或g~z中的任何一个字母（并运算） 5. [a-o&&[def]]:代表字母d、e、f（交运算） 6. [a-d&&[^bc]]:代表字母 a、d(差运算） 在正则表达式中允许使用限定修饰符来限定元字符出现的次数。

举例代码： public class Judge {    public static void main(String[] args) {   // TODO Auto-generated method stub   String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}"; //定义要匹配的E-mail地址的正则表达式   String str1 ="aaa@";//定义要进行验证的字符串   String str2 ="aaaa";   String str3 ="1111@111ffyu.dfg.com";   if(str1.matches(regex)) {  //判断字符串变量    System.out.println(str1+"是一个合法的E-mail地址格式");    }   if(str2.matches(regex)) {    System.out.println(str2+"是一个合法的E-mail地址格式");    }   if(str3.matches(regex)) {    System.out.println(str3+"是一个合法的E-mail地址格式");    }     }   }

字符串生成器

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

1. append()方法

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

2. insert(int offset,arg)方法

该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char和boolean等基本数据类型的数据或其他对象。语法如下： insert(int offset arg) a、 offset:字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。 b、arg:将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。向字符串生成器中指定的位置添加字符，代码如下： StringBuilder bf = new StringBuilder("hello"); //创建字符生成器 bf.insert(5, "world"); System.out,println(bf.toString()); //添加至字符生成器的位置及内容            //此时输出信息为 helloworld

3. delete(int start，int end)方法

移除此序列的子字符串中的字符。该子字符串从指定的start处开始，一直到索引end-1处的字符。如果不存在这种字符，则一直到序列尾部。如果start等于end，则不发生任何更改。语法如下： delete(int start , int end) a、 start:将要删除的字符串的起点位置。 b、 end：将要删除的字符串的终点位置。 删除指定位置的子字符串，代码如下： StringBuilder bf = new StringBuilder("StringBuilder"); bf.delete(5,10); System.out.println(bf.toString());

常用类库

包装类

Java 是一种面向对象语言，但在 Java 中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java 提出了包装类的概念，它主要是将基本数据类型封装在包装类中，如 int 型的包装类 merer、 boolean 型的包装类 Boolemn 等，这样便可以把这些基本数据类型转换力开多Jva中的包装美及其对应的基本数据类型如下：

1、Integer类

java.lang包中的integer类，byte类，short类和long类，分别将基本数据类型interesting，byte，short和long封装成一个类，由这些类都是number类的子类，区别就是封装不同的数据类型，其包含的方法基本相同。 integer类在对象包装一个基本数据类型int的值，该类的对象包含int类型的字段。

例题11.1【integer类的常用方法】 public class IntegerDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   int num =  Integer.parseInt("456");//将字符串转换成int类型   Integer iNum = Integer.valueOf("456");//创建一个integer对象   System.out.println("int数据与integer对象的比较："+iNum.equals(num));   String str2 = Integer.toBinaryString(num);//获取数字的二进制表示   String str3 = Integer.toHexString(num);//获取数字的十六进制表示   String str4 = Integer.toOctalString(num);//获取数字的八进制表示   String str5 = Integer.toString(num, 15);//获取数字的十五进制表示   num表要转换的数，15表转换的进制   System.out.println("456的二进制表示为："+str2);   System.out.println("456的二进制表示为："+str3);   System.out.println("456的二进制表示为："+str4);   System.out.println("456的二进制表示为："+str5);  }   }

例题11.2【查看integer类的常量值】  public class GetGon {    public static void main(String[] args) {   // TODO 自动生成的方法存根   int maxint  = Integer.MAX_VALUE;//获取integer类的常量值   int minint = Integer.MIN_VALUE;   int intsize = Integer.SIZE;   System.out.println("int类型可取的最大值是："+maxint);//将常量值输出   System.out.println("int类型可取的最小值是："+minint);   System.out.println("int类型可取的二进制数是："+intsize);    }   }

2、double类

Double类和Float 类是对 double、float 基本类型的封装，它们都是Number 类的子类，都是对浮点数进行操作，所以常用方法基本相同，本节将对 Double 类进行讲解。对于Float类，可以参考 Double类的相关内容。 Double 类在对象中包装一个基本类型为 double 的值，每个Double类的对象都包含一个 double类型的字段。此外，该类还提供多个方法，可以将 double 类型转换为 String 类型，将 String 类型转换为 double类型，也提供了其他一些处理 double 类型时有用的常量和方法

例题11.3【double类的常用方法】  public class DoubleDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Double dNum = Double.valueOf("3.14");//创建double对象   System.out.println("3.14是否为非数字值："+Double.isNaN(dNum.doubleValue()));//判断是否为   System.out.println("3.14转换为int值为："+dNum.intValue());//intValue直接取整  不四舍五入   System.out.println("值为3.14的double对象与3.14的比较结果:"+dNum.equals(3.14));//判断大小   System.out.println("3.14的十六进制表示为："+Double.toHexString(dNum));//转换为十六进制  }   }

3、Boolean类

Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。此外，此类还为 boolean 类型和String类型的相互转换提供了许多方法,1了处理 boolean 类型时非常有用的其他一些常量和方法。

例题11.4【Boolean类的常用方法】 public class BooleanDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Boolean b1 = Boolean.valueOf(true);//创建Boolean对象   Boolean b2 = Boolean.valueOf("ok");   System.out.println("b1:"+b1.booleanValue());   System.out.println("b2:"+b2.booleanValue());    }   }

4、character类

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

例题11.5【character类的常用方法】  public class UpperOrLower {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Character mychar1 = Character.valueOf('A');   Character mychar2 = Character.valueOf('a');   if(Character.isUpperCase(mychar1));//判断是否为大写字母   System.out.println(mychar1+"是大写字母");   System.out.println("转换为小写字母的结果："+Character.toLowerCase(mychar1));   if(Character.isLowerCase(mychar2)) {//判断是否为小写字母    System.out.println(mychar2+"是小写字母");    System.out.println("转换为大写字母的结果："+Character.toUpperCase(mychar2 ));   }     }   }

5、number类

前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类一Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byte、int、short、long、float 和 double 的方法。例如，doubleValue0方法返回双精度浮点值，floatValue0方法返回单精度浮点值，这些方法如下：

数字处理

1、数字格式

1、数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 float 型数据。在 Java 中使用 javatextDecimalFormat格式化数字，本节将着重讲解DecimalFormat类。

【DecimalFormat 类的常用方法】 import java.text.DecimalFormat; public class DecimalFormatSimpleDemo {  static public void SimgleFormat(String pattern,double value) {   DecimalFormat myFormat = new DecimalFormat(pattern);   String output = myFormat.format(value);//将数字进行格式化   System.out.println(value+""+pattern+""+output);  }    static public void UseApplyPatternMethodFormat(String pattern,double value) {   DecimalFormat myFormat = new DecimalFormat();   myFormat.applyPattern(pattern);//调用applypattern方法设置格式化模板   System.out.println(value+""+pattern+""+myFormat.format(value));  }    public static void main(String[] args) {   // TODO 自动生成的方法存根   SimgleFormat("###,###,###",123456.789);//调用静态simgleformat方法   SimgleFormat("00000000.###kg",123456.789);//在数字后加上单位   SimgleFormat("000000.000",123.78);   UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分数形式   UseApplyPatternMethodFormat("###.##",123456.789);//将小数后格式化为两位   UseApplyPatternMethodFormat("0,00\u2030",0.789);//将数字转换为千分数形式  }   }

在DecimalFormat类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方法对数字行格式化设置。例如： DecimalFormat myFormat = newDecimalFormat();//实例化decimalFormat类对象 myFormat.setGroupingSize(2);//设置将数字分组的大小 myFormat.setGroupingUsed(false）；//设置是否支持分组 在项目中创建 DecimalMethod类，在类的主方法中调用setGroupingSize0与 setGroupingUsed0方法实现数字的分组： import java.text.DecimalFormat; public class DecimalMethod {    public static void main(String[] args) {   // TODO 自动生成的方法存根   DecimalFormat myFormat = new DecimalFormat();   myFormat.setGroupingSize(2);//将数字分组为2   String output = myFormat.format(123456.789);   System.out.println("将数字以每两个数字分组"+output);   myFormat.setGroupingUsed(false);//设置不允许分组   String output2 = myFormat.format(123456.789);   System.out.println("不允许数字分组"+output2);        }   }

2、在Java中，没有格式化的数据遵循以下原则: 口如果数据绝对值大于0.001 并且小于 10000000，使以常规小数形式表示。 口如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。 由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在 Jaw中，可以使用DecimalFormat类进行格式化操作。

3、DecimalFormat类是NumberFormat的一个子类用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一”情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中applyPattern0方法来实现数字格式化。

4、当格式化数字时，可在DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照定的特殊字符规则进行匹配。

2、Math类

Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便可以使用如下形式调用: Math.数学方法  在 Math 类中，除函数方法外还存在一些常用数学常量，如I、E等。这些数学常量作为Mah的成员变量出现，调用起来也很简单。可以使用如下形式调用， Math.PI Math.E Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。

1.三角函数方法

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

例题11.7【]在Java代码中进行三角函数运算】  public class TrigonometricFunction {    public static void main(String[] args) {   // TODO 自动生成的方法存根   System.out.println("90度的正弦值："+Math.sin(Math.PI/2));//取90的正弦   System.out.println("0度的余弦值："+Math.cos(0));//取0的余弦   System.out.println("60度的正切值："+Math.tan(Math.PI/3));//取60的正切   System.out.println("2的平方根与2 商的反正弦值："+Math.asin(Math.sqrt(2)/2));   System.out.println("2的平方根与2 商的反正弦值："+Math.acos(Math.sqrt(2)/2));   System.out.println("1的反正切值："+Math.atan(1));//取1的反切值   System.out.println("120度的弧度值："+Math.toRadians(120.0)); //取120的度的弧度值   System.out.println("Π/2的角度值："+Math.toDegrees(Math.PI/2));//取Π/2的角度     }   }

2.指数函数方法

Math类中与指数相关的函数方法如下： publicstatic double exp(doublea):用于获取e的a次方，即取e^2 publicstatic double log(doublea):用于取自然对数，即取Ina的值 publicstaticdoublelog10(doublea):用于取底数为10的a的对数。 public static doublesqrt(doublea):用于取a的平方根，其中a的值不能为负值。 public static double cbrt(doublea):用于取a的立方根。 public static double pow(double adouble b):用于取a的b次方

例题11.8【在Java代码中进行指数函数运算】 public class ExponentFunction {    public static void main(String[] args) {   // TODO 自动生成的方法存根   System.out.println("e的平方值："+Math.exp(2));//取e的2 次方   System.out.println("以e为底2的对数值”"+Math.log(2));//取以e 为底2的对数   System.out.println("以e为底2的对数值”"+Math.log(2));//取以10 为底2的对数   System.out.println("4的平方根值："+Math.sqrt(4));//取4的平方根   System.out.println("8的立方根值："+Math.cbrt(8));//取8的立方根   System.out.println("2的2次方值："+Math.pow(2, 2));//取2的2次方  }   }

3.取整函数方法

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

例题11.9【各场景下取整函数的运算结果】 public class IntFunction {  public static void main(String[] args) {   // TODO Auto-generated method stub   System.out.println("使用ceil()方法取整："+Math.ceil(5.2));   //返回一个大于等于参数的整数   System.out.println("使用floor()方法取整："+Math.floor(2.5));   //返回一个小于等于参数的整数   System.out.println("使用rint()方法取整："+Math.rint(2.7));   //返回与参数最接近的整数   System.out.println("使用rint()方法取整："+Math.rint(2.5));   //返回与参数最接近的整数   System.out.println("使用round()方法取整："+Math.round(3.4f));   //将参数加上0.5后返回最接近的整数   System.out.println("使用round()方法取整："+Math.round(2.5));   //将参数加上0.5后返回最接近的整数，并强制转换为长整型  }   }

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

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

例题 11.10【取最大值、最小值、绝对值的方法】 public class AnyFunction {  public static void main(String[] args) {   // TODO Auto-generated method stub   System.out.println("4和8较大值："+Math.max(4, 8));   //取两个参数的最大值   System.out.println("4.4和4较小值："+Math.min(4.4, 4));   //取两个参数的最小值   System.out.println("-7的绝对值："+Math.abs(-7));   //取参数的绝对值  }   }

3、Random类

Random类是JDK 中的随机数生成器类，可以通过实例化一个 Random 对象创建一个随机数生器，语法如下: Random r = new Random(): 以这种方式实例化对象时，Java 编译器将以系统当前时间作为随机数生成器的种子。因为解时刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两个运行结累的随机数。 用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下: Random r = new Random(seedValue) r:Random类对象。 scedValue:随机数生成器的种子。 在Random 类中，提供了获取各种数据类型随机数的方法，下面列举几个常用的方法： public int nextInt（）:返回一个随机整数。 public int nextInt(int n): 返回大于等于0且小于n 的随机整数。 public long nextLong(): 返回一个随机长整型值。 public boolean nextBoolean(): 返回一个随机布尔型值。 public float nextFloat(): 返回一个随机单精度浮点型值。 public double nextDouble(): 返回一个随机双精度浮点型值。 public double nextGaussian():返回一个概率密度为高斯分布的双精度浮点型值

例题11.11【获取不同的取值范围，不同类型的随机数】 import java.util.Random; public class RandomDemo {  public static void main(String[] args) {   // TODO Auto-generated method stub   Random r = new Random();//实例化一个Random类   //随机产生一个整数   System.out.println("随机产生一个整数："+r.nextInt());   //随机产生一个大于等于0小于10的整数   System.out.println("随机产生一个大于等于0小于10的整数："+r.nextInt(10));   //随机产生一个布尔型的值   System.out.println("随机产生一个布尔型的值："+r.nextBoolean());   //随机产生一个双精度浮点型的值   System.out.println("随机产生一个双精度浮点型的值："+r.nextDouble());   //随机产生一个单精度浮点型的值   System.out.println("随机产生一个单精度浮点型的值："+r.nextFloat());   //随机产生一个概率密度为高斯分布的双精度浮点型的值   System.out.println("随机产生一个概率密度为高斯分布的双精度浮点型的值："+r.nextGaussian());  }   }

4、BigInteger类

1、在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数大公约数以及判断是否为质数等操作。

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

5、BigDecimal类

BirDecimal 类支持任何精度的定点数，可以用它来精响计货值在BigDecimal类中，常用的两个构造方法如下：

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

11.13【使用BigDecimal类进行数学运算】 import java.math.BigDecimal; import java.math.RoundingMode; public class BigDecimalDemo {  public static void main(String[] args) {   // TODO Auto-generated method stub   //第一个大小数   BigDecimal b1 = new BigDecimal("0.00987654321987654321");   //第二个大小数   BigDecimal b2 = new BigDecimal("0.00123456789123456789");   //加法运算   System.out.println("两个数字相加结果："+b1.add(b2));   //减法运算   System.out.println("两个数字相减结果："+b1.subtract(b2));   //乘法运算   System.out.println("两个数字相乘结果："+b1.multiply(b2));   //除法运算，商小数点后保留9位，并将结果进行四舍五入操作   System.out.println("两个数字相除，保留小数点后9位结果："+b1.divide(b2,9,RoundingMode.HALF_UP));  }   }

System类

Svstem类是JDK 中提供的系统类，该类是用 fial 修饰的，所以不允许被承。System 类提供了很多系统层面的操作方法，并且这些方法全部都是静态的。System类提供的较常用方法如表 11.11所示。

1、控制台输出字符

1.不会自动换行的print（)方法 System.out.print("Hello!");

2.可以自动换行的println()方法 System.outprintln("书籍是人类进步的阶梯!");

2、计时

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

例题11.14【查看执行一万次字符串拼接所消耗的时间】 public class SystemTimeDemo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   long start = System.currentTimeMillis();//程序开始记录时间   String str = null;//创建null字符串   for(int i = 0;i<10000;i++) {//循环一万次    str +=i;//字符串与循环变量拼接   }   long end = System.currentTimeMillis();//记录循环结束时间   System.out.println("循环用时："+(end-start)+"毫秒");  }   }

Scanner类

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

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

3.Scanner类的几个常用方法

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

日期时间类

1、date类：

Date 类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如表11.14所示。

1,  使用 Date类的第2种构造方法创建一个 Date类的对象，代码如下: long timeMillis=System.currentTimeMillis();  //当前系统时间所经历的毫秒数 Date date = new Date(timeMillis); 上述代码中的System类的currentTimeMillis0方法主要用来获取当前系统时间距标准基准时间的毫秒数。另外，这里需要注意的是，创建 Date 对象时使用的是 long 型整数，而不是 double 型，这主要是因为 double类型可能会损失精度。

2.Date 类的常用方法及其说明如表 11.15所示

2、日期时间格式化

1.DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种: SHORT:完全为数字，如12.13.52或3:30pm。 MEDIUM:较长，如Jan 12,1952。 LONG:更长，如January12,1952或3:30:32pm。 FULL:完全指定，如Tuesday、April12、1952AD或3:3042pm PST

2.可以使用其静态方法getDateInstance(进行创建，语法如下: DateFormat df = DateFormat.getDatelnstance();

3.DateFormat类的常用方法及其说明如表11.16所示

4.由于DateFormat类是一个抽象类，不能用 new创建实例对象。因此，除了使用getXXXInstance0方能创健其对象，还可以使用其子类，如 SimpleDateFormat 类，该类是一个以与语言环境相关的方式*花式化和分析日期的具体类，它允许进行格式化 (日期一文本)、分析(文本一日期)和规范化。

5.SimpleDateFormat 类提供了19个格式化字符，可以让开发者随意编写日期格式，这19个格式化字符如表11.17所示。

6.一些常用的日期时间格式如表 11.18所示

3、Calendar 类

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

2.Calendar 提供了一个类方法 getInstance0，以获得此类型的一个通用的对象。Calendar 类的getInstance0方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下: Calendar rightNow = Calendar.getlnstance();

3.Calendar类提供的常用字段及其说明如表11.19所示。

4.Calendar类提供的常用方法及其说明如表 11.20所示。

Runtime类

1.Runtime类是 JDK 提供的运行时类，该类为Ja 提供了与当前运行环境相连接的一个通Java程可以利用设头提的超行环填执行一些简单的操作。Runtime 类不能使用 new 关键字创建看例，只能通过RuntimegetRuntime0方法获取实例。

2.Runtime类的常用方决知表11、21所示，本节将重点讲解利用 Runtime 类执行本地命令和查看虚拟机所占内存这两个操作。

一、执行本地命令

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

2.Proces 类的常用方法如表 11.22 所示，开发可以使用 getlnputStream0方法获取进返回的信息。

二、查看内存

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

例题11.20【监控虚拟机内存使用情况】 public class MemoryDamo {    public static void main(String[] args) {   // TODO 自动生成的方法存根   Runtime r=Runtime.getRuntime();//获取本地Runtime对免   Integer ints[] = new Integer[10000];//创建长度为10000的整型   long before = r.freeMemory();//获取当前空闲内存数   System.out.println("赋值前空闲内存字节数:"+ before);   for (int i = 0, length = ints.length; i < length; i++) {//循环为整型数组赋值    ints[i]= i;//赋值   }   long after = r.freeMemory();//获取当前空闲内存数   System.out.println("赋值后空闲内存字节数:"+after);   System.out.println("数组用掉的内存字节数:"+(before- after));//输出数组用掉的内存量  }   }