java从入门到精通

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

什么是Java语言

桌面应用系统开发

嵌入式系统开发

电子商务应用

企业级应用开发

交互式系统开发

多媒体系统开发

分布式系统开发

Web应用系统开发

移动端应用开发

Java的应用领域

Java SE

Java EE

Java的版本

应用程序编程接口

JavaAPI文档

Java简介

简单

面向对象

分布性

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

可移植性

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

解释型

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

安全性

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

健壮性

多线程

高性能

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

动态

Java语言的特性

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

下载JDK

解压缩

配置环境变量

搭建JDK环境

搭建Java环境

初识Java

官网下载安装包

下载汉化包

下载Eclipse

视图

菜单栏

工具栏

Eclipse的界面

配置与启动

创建Java项目

创建Java类文件

编写Java代码

运行Java代码

调试Java代码

使用Eclipse

熟悉Eclipse开发工具

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

包声明

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

声明成员变量和局部变量

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

编写主方法

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

导入API类库

Java主类结构

整数类型

简称整形，用来存储整数数值，可以是正数，也可以是负数

浮点类型

简称浮点类，用于存储含有小数部分的数值（使用float类型须加一个F或f后缀）

char型，用于存储单个字符

字符类型

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

布尔类型

基本数据类型

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

标识符和关键字

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

声明变量

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

声明常量

变量与常量

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

赋值运算符

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

算术运算符

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

自增和自减运算符

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

比较运算符

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

逻辑运算符

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

位运算符

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

三元运算符

运算符

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

隐式类型转换

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

显式类型转换

数据类型转换

单行注释“//”

多行注释“/**/”

文档注释“/** */”

代码注释与编码规范

Java语言基础

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

复合语句

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

if....else语句

if条件语句

switch多分支语句

条件语句

while循环语句

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

do...while循环语句

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

for循环语句

循环语句

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

break语句

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

continue语句

循环控制

流程控制

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

数组概括

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

声明

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

分配内存

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

元素赋值

一维数组

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

二维数组

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

遍历数组

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

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

替换数组

Arrays.sort（数组名）；

对数组进行排序

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

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

复制数组

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

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

查询数组

数组的基本操作

冒泡排序

直接选择排序

反转排序

数组排序算法

数组

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

面向对象：可维护性强

对象

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

类

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

封装

继承

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

多态

面对对象概括

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

成员变量

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

成员方法

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

权限修饰符

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

局部变量

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

局部变量的有效范围

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

this关键字

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

类的构造方法

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

静态变量和静态方法

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

类的主方法

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

对象的创建

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

访问对象的属性和行为

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

对象的引用

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

对象的销毁

类和对象

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

类的继承

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

1.getClass()方法

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

2.toString()方法

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

3.equals()方法

Object类

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

向上转换

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

向下转换

对象类型的转换

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

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

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

方法的重载

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

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

final修饰类——不能被继承

final关键字

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

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

抽象类

Java语言每个类可以实现多个接口；语法如下：public interface Paintable {    void draw();  //定义接口方法可省略public abstract 关键字font color=\"#000000\

接口

抽象类与接口

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

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

类路径

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

指定包名(package)

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关键字还可以对静态方法与静态变量进行导包。

导入包

Java类包

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

成员内部类

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

匿名内部类

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

内部类

包和内部类

在程序中，错误可能产生于程序员没有预料到的各种情况，或者是超出了程序员可控范围的环境因素，如试图打开一个根本不存在的文件等，在 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\"删除，即可运行

抛出异常

举例代码：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(\"请联系管理员进行修复\");//输出信息        }    } }

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

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

捕捉异常

异常的抛出与捕捉

Java常见的异常类

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

自定义异常

举例代码：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()方法抛出的异常\");  } } }

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

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

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

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

在方法中抛出异常

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

运行时异常

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

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

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

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

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

异常的使用原则

异常处理

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

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

声明字符串

该方法用一个字符数组a创建String对象，代码如下：package a; public class Test1 {  public static void main(String[] args) {  // TODO Auto-generated method stub  //字符串变量的申明  String s;  //字符串变量初始化  // s = (\"你好\");  s = new String(\"你好\

子主题

该方法提取字符数组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(\"你好\

该构造犯法可分配一个新的String对象，使其表示字符组参数中所有元素连接的结果。代码如下： package a; public class Test1 {  public static void main(String[] args) {  // TODO Auto-generated method stub  //字符串变量的申明  String s;  //字符串变量初始化  // s = (\"你好\");  s = new String(\"你好\

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(\"你好\

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

创建字符串

String类

使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。例题10.1package 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 + \"\\" + s2;   //将对象s1、\"\\"和对象链接并将结果赋值给s  System.out.println(s);    //将s输出  } }

1、连接多个字符串

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

2、连接其他数据类型

连接字符串

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

1、获取字符串长度

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

1.indexOf(String s)

举例代码：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的长度输出 } }

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

2.lastIndexOf(String str)

2、字符串查找

举例代码：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);//输出信息 } }

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

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

获取字符串信息

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

1.substring(int beginlndex)

代码：public class Subs {  public static void main(String[] args) {  // TODO Auto-generated method stub  String str =\"《将进酒》：李白（唐）\

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

2.substring(int beginlndex，int endIndex)

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

1、获取子字符串

代码：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()); } }

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

2、去除空格

代码：public class NewStr {  public static void main(String[] args) {  // TODO Auto-generated method stub  String str = \"address\";  String newstr =str.replace(\"a\

3、字符串替换

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

1.stsrtsWith()方法

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

2.endsWith()方法

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

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

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

1.equals()方法

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

2.equalslgnoreCase()方法

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

5、判断字符串是否相等

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

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

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

1.toLowerCase（)方法

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

2. toUpperCase（)方法

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

7、字母大小写转换

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

1.split(String sign)

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

2.split(String sign，int limit)

8、字符串分割

字符串操作

String 类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。

举例代码：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\

1.日期格式化

举例代码：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\

2.时间格式化

举例代码：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\

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

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

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

举例代码：package a; public class General {            //新建类  public static void main(String[] args) {        //主方法  // TODO Auto-generated method stub  String str = String.format(\"%d\

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

2、常规类型格式化

格式化字符串

举例代码：public class Judge {  public static void main(String[] args) {  // TODO Auto-generated method stub  String regex = \

注意：在正则表达式中，“.”代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转移字符“\\\".在正则表达式中，可以使用方括号括起若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。方括号元字符还可以为其他格式，如：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(差运算）在正则表达式中允许使用限定修饰符来限定元字符出现的次数。

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

使用正则表达式

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

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

1. append()方法

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

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

字符串生成器

字符串

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

例题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对象的比较：\

例题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);  } }

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

Integer类提供了以下4个常量:MAXVALUE:表示int类型可取的最大值，即231-1。MINVALUE:表示int类型可取的最小值，即-23。SIZE:用来以二进制补码形式表示int值的位数。TYPE:表示基本类型int的Class 实例。

1、Integer类

例题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));//转换为十六进制 } }

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

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

2、double类

例题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());  } }

概要

3、Boolean类

例题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 ));  }   } }

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

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

4、character类

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

5、number类

包装类

在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);     } }

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

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

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

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

1、数字格式

例题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的角度   } }

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):将弧度转换为角度。

1.三角函数方法

例题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类中与指数相关的函数方法如下：publicstatic double exp(doublea):用于获取e的a次方，即取e^2publicstatic 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次方

2.指数函数方法

例题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后返回最接近的整数，并强制转换为长整型 } }

在具体的问题中，取整操作使用也很普遍，所以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 后返与参数最近的整数，然后强制转换为长整型。

3.取整函数方法

例题 11.10【取最大值、最小值、绝对值的方法】public class AnyFunction { public static void main(String[] args) {  // TODO Auto-generated method stub  System.out.println(\"4和8较大值：\

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

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

2、Math类

例题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()); } }

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():返回一个概率密度为高斯分布的双精度浮点型值

3、Random类

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

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

4、BigInteger类

例题11.12【使用BigInteger类进行数学运算】import java.math.BigInteger;public class BigIntegerDemo { public static void main(String[] args) {  // TODO Auto-generated method stub  //第一个大数字  BigInteger b1 = new BigInteger(\"987654321987654321\");  //第二个大数字  BigInteger b2 = new BigInteger(\"123456789123456789\");  //加法运算  System.out.println(\"加法操作：\"+b1.add(b2));  //减法运算  System.out.println(\"减法操作：\"+b1.subtract(b2));  //乘法运算  System.out.println(\"乘法操作：\"+b1.multiply(b2));  //除法运算  System.out.println(\"除法操作：\"+b1.divide(b2));  //取商运算  System.out.println(\"取商：\"+b1.divideAndRemainder(b2)[0]);  //取余运算  System.out.println(\"取余数：\"+b1.divideAndRemainder(b2)[1]);  //2次方运算  System.out.println(\"做2次方操作：\"+b1.pow(2));  //相反数运算  System.out.println(\"取相反数操作：\"+b1.negate()); } }

一旦创建了对象实例，就可以调用 BigInteger 类中的一些方法进行运算操作，包括基本的数学运享和位运算以及一些取相反数、取绝对值等操作。下面列举了 BigInteger 类中常用的几种运算方法public BigInteger add(BigInteger val): 做加法运算。public BigInteger subtract(BigInteger va): 做减法运算public BigInteger multiply(BigInteger val): 做乘法运算public BigInteger divide(BigInteger val): 做除法运算。public BigInteger remainder(BigInteger val): 做取余操作。public BigInteger]] divideAndRemainder(BigInteger val): 用数组返回余数和商，结果数组中lt爱险法的商一个值为商，第二个值为余数。public BigInteger pow(int exponent): 进行取参数的 exponent 次方操作。public BigInteger negate0: 取相反数。public BigInteger shifLef(int n): 将数字左移n位，如果n为负数，做右移操作public BigInteger shiftRight(int n):将数字右移n位，如果n为负数，做左移操作public BigInteger and(BigInteger val): 做与操作。public BigInteger or(Biglnteger val): 做或操作。public int compareTo(BigInteger val): 做数字比较操作。public boolean equals(Object x): 当参数 x是 BigInteger 类型的数字并且数值与对象实例的数相等时，返回 true。public BigInteger min(BigInteger val): 返回较小的数值。public BigInteger max(BigInteger val): 返回较大的数值 。

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位结果：\

5、BigDecimal类

数字处理

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

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

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

1、控制台输出字符

例题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)+\"毫秒\"); } }

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

2、计时

System类

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);

Scanner类

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

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

1、date类：

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

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

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

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

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

2、日期时间格式化

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所示。

3、Calendar 类

日期时间类

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方法获取进返回的信息。

一、执行本地命令

例题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(\"赋值前空闲内存字节数:\

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

二、查看内存

Runtime类

常用类库

java从入门到精通