Java从入门到精通

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

Java简介

简单

面向对象

分布性

可移植性

解释型

安全性

健壮性

多线程

高性能

动态

Java语言的特性

jdk下载网址：http//jdk.java.net

JDK下载

解压缩

配置环境变量

在win10系统下搭建JDK环境

搭建Java环境

初识Java

熟悉Eclipse简介

下载Eclipse

熟悉Eclipse

选择“文件”/“新建”/“项目”命令，打开“新建项目”对话框，对该项目的向导，在向导中选择Java项目

弹出“新建项目对话框”/“项目名”文本框中输入“Myproject”，在项目布局栏选中“为源文件和类文件创建单的文件夹”单选按钮

创建Java项目

Eclipse菜单栏中选择“文件”/“新建”/“类”命令，将打开“新建Java类”向导对话框

创建Java类文件

打开Java编译器

编写Java  code

使用编辑器写程序代码

helloJava 类包含main（）方法，它是一个可以运行的主类

运行Java程序

使用Eclipse

设置断点是程序调试中必不可少的手段，Java调试器每次遇到程序断点时都会将当前线程挂起，即暂停当前程序的运行

断点

以调试方式运行Java程序

程序调试

熟悉Eclipse开发工具

一个Java应用陈旭是由若干个类组成的；语句packageNumber为声明该类所在的包，package为包的关键字

包声明

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

成员变量和局部变量

main（）方法是类体中的主方乏。该方法从“{”开始，至“}”结束。public、static和void分别是main（）方法的权限修饰符、静态修饰符和返回值修饰符，Java程序中的main（）方法必须声明public，static，void。String[]args是一个字符串类型的数组，它是main（）方法的参数，main（）方法是程序开始执行的位置

主方法

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

子主题

导入其他类

Java主类机构

byte、short、int、long

整数类型

默认情况下小数都被看作double型，若想使用float型小数，则需要在小数后面添加F或f。定义float类型变量时，如果不加F或f，系统会认为是double类型数据，进而出错。

float（单精度）

可以使用后缀d或D来明确这是一个double类型数据，但加不加d或D没有硬性规定

double（双精度）

浮点类型

字符类型（char）用于存储单个字符，占用16位（2个字节）的内存空间。在定义字符类型变量时，要以单引号表示，如‘s’表示一个字符，但是“s”则表示一个字符串，虽然只有一个字符，但由于使用双引号，它仍然表示字符串，而不是字符。

char型

转义字符是一种特殊的字符变量，它以反斜杠“\\”开头，后跟一个或多个字符。转义字符具有特定的含义，不同于字符原有的意义，故城“转义”

转义字符

字符类型

布尔类型又称逻辑类型，简称布尔型，通过关键字Boolean来定义布尔类型变量。布尔类型只有true和false两个值，分别代表逻辑中的“真”和“假”。布尔值不能与整数类型进行转换，布尔类型通常被用在流程控制中，作为判断条件。

布尔类型

基本数据类型

标识符可以简单理解为一个名字，是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列；Java语言规定标识符由任意的字母、下划线（_）、美元符号（$）和数字组成，并且第一个字符不能是数字；标识符不能是java中的关键字（表留字）

标识符

关键字又称保留字，是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用，如int、Boolean等都是关键字

关键字

标识符和关键字

变量的使用是程序中一个十分重要的环节。声明变量就是要告诉编译器，这个变量的数据类型，这样编译器才知道需要配置多少空间给它，以及它能存放什么样的数据。

声明变量

什么是变量

在程序中一直不会改变的量称为常量，通常也被称为“final变量”，常量在整个程序中只能被赋值一次

声明常量

什么是常量

在类体中所声明的变量被称为成员变量，成员变量在整个类中都有效。类的成员变量又可分为2种，即静态变量和实例变量

成员变量

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

局部变量

变量的有效范围

变量与常量

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

赋值运算符

Java中的算术运算符主要有+（加）、减-（减）、*（乘）、/(除)、%(求余），他们都是二元运算符。

算术运算符

自增、自减运算符是弹幕运算符，可以放在操作元之前，也可以放在操作之后。操作元必须是一个整型或浮点型变量。自增、自减运算符的作用是使变量的值增或减1。放在操作元前面的自增、自减运算符，会先将变量的值加1（减1），然后再使用该变量参与表达式的运算。放在操作元后面的的自减运算符，会先使变量表达式的运算，然后将该变量加1或减1

提示：符号在前先运算再使用符号在后先使用再运算

自增和自减运算符

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较，比较运算符的运算结果是Boolean型

比较运算符

逻辑运算符包括&&（逻辑与）、||（逻辑或）、!(逻辑非）。逻辑运算符必须是boolean型数据

逻辑运算符

位运算符

三元运算符的使用格式为：条件式？值1：值2

三元运算符的运算规则为：若条件式的值为ture，则整个表达式取值1，否则取值2。例如：Boolean b = \"20<45\"？ture:false;

三元运算符

Java中的表达式就是使用运算符链接起来的符合Java规则的式子。运算符的优先级决定了表达式中运算只想的先后顺序

运算符的优先级

运算符

从低级类型向高级类型的转换，系统将自动执行，程序无须任何操作。这种类型的转换称为隐式转换。下列节本数据类型会涉及数据转换，不包括逻辑类型和字符类型。这些类型按精度从低到高的顺序为byte<short<int<long<float<double

隐式转换

当把高精度的变量值赋给低精度的变量时，必须使用显示类型转换（强制类型转换）

显示转换

数据类型转换

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

单行注释

“/*  */”为多行注释标记，符号“/*”与“*/”之间所有的内容均为注释内容

多行注释

代码注释与编码规范

Java语言基础

复合语句有开括号“{”开始，闭括号“}”结束。在使用时要注意，复合语句为局部变量创建一个作用域，该作用域为程序的一部分，在该作用中某个变量被创建并能够使用。如果在某个变量的作用的作用域外使用该变量，则会发生错误。

复合语句

if（布尔类型表达式）{语句序列}

简单的if条件语句

if(条件表达式）{    语句序列1}else{    语句序列2}

if…else 语句

if（条件表达式）{    语句序列1else if（条件表达式2）{}……else if（条件表达式n）{}

if…else…if多分支语句

if条件语句

Switch （变量或表达式）{case 取值 1：//对应取值1的代码break;//对应取值2的代码break;//…default://对应其他取值的代码break；}

switch 多分支语句

条件语句

while（条件表达式）{语句序列}

while循环

do{//循环体} while（循环条件）；

do…while循环

for（表达式1；表达式2；表达式3）{语句序列；}

for循环

循环语句

在Java中，break语句可以用于循环或者Switch语句中，用于提前结束或者跳出包含该语句的循环或者Switch语句中，用于提前结束循环或者跳出Switch语句的执行。当程序执行到break语句时，会直接跳出包含该语句的循环或Switch语句，并且继续执行后面的代码。同样break也可以跳出循环体。在循环中，一旦执行到break语句，循环将会被立即终止，程序会跳出循环并执行循环后的代码

break语句

continue语句是针对break语句补充的补充，continue语句不是立即跳出循环体，二是跳过本次循环，回到循环的条件测试部分，重新开始执行循环。在for循环语句中遇到continue后，首先执行循环的增量部分，然后进行条件测试，在while和do…while循环中，continue语句使控制回到条件测试部分

continue语句

循环控制

流程控制

声明一维数组有两种方式。数组元素类型 数组名字[];数组元素类型[] 数组名字；

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

这种创建的方法是将数组的声明和内存分配合在一起执行。语法如下：数组元素的类型 数组名= new 数组元素的类型[数组元素的个数];

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

创建一维数组

初始化一维数组

使用一维数组

一维数组

声明二维数组的语法如下：数组元素的类型 数组名字 [] [];数组元素的类型[] [] 数组名字；声明二维数组，代码如下：int a[][];

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

第二种创建方式第一种实现的功能相同，只不过声明与赋值合并到同一行代码中。举个栗子：创建一个2行4列的二维数组，代码如下：int a = new int[2][4];

创建二维数组

初始化二维数组

使用二维数组

二维数组

遍历数组就是获取数组中的每一个元素。通常遍历数组都是使用for循环来实现。遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度

遍历数组

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

填充替换数组元素

对数组进行排序

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

复制数组

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

查询数组

数组的基本操作

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

基本思想

算法实现

冒泡排序

直接选择排序属于的基本思想是将排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值

算法演示

直接选择排序

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

反转排序

数组排序算法

数组

（1）从这一问题中抽象出对象，这里抽象出的对象为大雁（2）识别这个对象的属性。对象具备的属性都是静态属性，如大雁有一对翅膀、黑色的羽毛等。（3）识别这个对象的动态行为，即这只大雁可以进行的动作，如飞行、觅食等，这些行为都是这个对象基于其竖向而具有的动作，（4）识别这个对象的属性和行为后，这个对象被定义完成了。然后，可以根据这只大雁具有的特征制定这只大雁从北方到南方的具体方案，以解决这个问题

面向对象概述

在lava 中，对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量什范围。下面通过一个实例来演示成员变量在类中所处的位置。创建一个 Book 类，在类中设置一个name 属性，并为该属性编写 Getter/ Setter 方法

在Java 语言中需要使用 class 关键字来定义类，Book 是类的名称。同时在Book 类中定义了一个成员变量，成员变量的类型为 String 类型。其实成员变量就是普通的交量，可以为它设置初始值，也可以不设置初始值。如果不设置初始值，则会有默认值。读者应该注意到成员变量 name 前面有一个 private 关键字，它用来定义一个私有成员

定义成员方法的语法格式如下：权限修饰符  返回值类型 方法名（参数类型 参数名）{…                                                                             //方法体    return 返回值}

在Java语言中，使用成员方法对应于类对象的行为。以book类为例，它包含getName（）和setName（）两个方法，这两个成员方法分别为获取图书名称和设置图书名称的方法

说明：如果一个方法中含有成员变量同名的局部变量，则方法中对这个变量的访问以局部变量进行类的成员变量和成员方法也可以统称为类成员

成员方法

Java中的权限修饰符主要包括private、public、和Protected这些修饰符控制着对类和类的成员变量以及成员方法的访问。如果一个类的成员变量或成员方法被修饰为 private，则该成员变量只能在本类中被使用，在子类中是不可见的，并且对其他包的类也是不可见的。如果将类的成员变量和成员方法的访问权限设置为 publie，那么除了可以在本类使用这些数据，还可以在子类和其他包的类中使用。如果一个类的访问权限被设置为 private，这个类将隐藏其内的所有数据，以免用户直接访问它。如果需要使类中的数据被子类或其他包中的类使用，可以将这个类设置为 public 访问权限。如果一个类使用protected 修饰符，那么只有本包内的该类的子类或其他类可以访问此类中的成员变量和成员方法。这么看来，public 和protected 修饰的类可以由子类访问，如果子类和父类不在同一包中，那么只有修饰符为public 的类可以被子类进行访问。如果父类不允许通过继承产生的子类访问它的成员变量，那么必须使用 private 声明父类的这个成员变量。表6.1 中描述了private、protected 和 public 修饰符的修饰权限

权限修饰符

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

this关键字

类

构造方法的特点如下：1.构造方法没有返回值2.构造方法的名称要与本类的名称相同 构造方法的定义语法格式如下：public Book(){...      //构造方法体}

类的构造方法

在介绍静态变量和静态方法之前，首先要要介绍static关键字，因为由static修饰的变量和方法被称为静态变量和静态方法

静态变量

静态方法

静态成员

public static void main(String[] args){    ...   //方法体}

语法

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

类的主方法

使用new操作符调用构造方法创建对象，语法如下：Test test =new Test();Test test =new Test(\"a\");

创建

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

访问属性和行为

类名 对象的引用变量

引用

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收何种对象会被Java虚拟机视为“垃圾”。主要包括以下两种情况：对象引用超过其作用范围，这个对象将被视为垃圾

销毁

对象

类和对象

类的继承

Object类是比较特殊的类，它是所有类的父类，是Java类层中最高层类。用户创建一个类时，除非已经指定要从其他类继承，否则它就是从Java.lang.Object类继承而来的。Java中的每个类都源于Java.lang.Object类，如String类、Integer类等都是继承Object类。除此之外，自定义的类也都继承于Object类。在Object类中，主要包括clone（）、finalize（）、equals（）、toString（）等方法，由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法

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

getClass（）方法

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

toString（）方法

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

equals()方法

Object类

向上转型可以被理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象之间赋值给父类类型的对象，进而实现按照父类描述子类的效果

向上转型

向下转型可以被理解为将父类类型的对象转换为子类类型的对象。但是，运用向下转型，如果把一个较抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误

向下转型

对象类型的转换

当在程序中执行向下转型操作时，如果父类对象不是子类对象的实例，就会发生ClassCastException异常，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例。可以使用instanceof关键字判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类

myobject instanceof ExampleClassmyobject：某类的对象引用

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

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

方法的重载

final关键字可用于变量声明，一旦该变量被设定，就不可以再改变该变量的值。通常，由final定义的变量为常量。例如，在类中定义PI值，可以使用如下语句：final double PI = 3.14;

private final void test（）{               …省略一些程序代码}

将方法定义为final类型，可以防止子类修改父类的定义与实现方式，同时定义final的方法的执行效率要高于非final方法，在修饰权限中曾经提到过private修饰符，如果一个父类的某个方法被设置为private，子类将无法访问该方法，自然无法覆盖该方法。也就是说，一个定义为private的方法隐式被指定为final类型，因此无须将一个定义为private的方法再定义为final类型

定义为final的类不能被继承。如果希望一个类不被任何类继承，并且不允许其他人对这个类进行任何改动，可以将这个类设置为final类

final 类名{}如果将某个类设置为final类，则该类中的所有方法都被隐式设置为final方法，但是final类中的成员变量可以被定义为final或非final形式

final类

final方法

final关键字

多态的意思是多种形态，利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。已经学习过子类对象可以作为父类的对象实例使用，这种将子类对象视为父类对象的做法称为“向上转型”

多态

抽象方法：修饰符 abstract 返回参数 方法名（传入参数）;使用abstract关键字定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，没有意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上抽象类除了被继承没有任何意义

public abstract class Parent{    //修饰类 abstract class  类名    abstract void testAbstract();    //定义抽象方法

抽象类

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体，上一节抽象遗留的问题，可以将draw（）方法封装到一个接口中，使需要draw（）方法的类实现这个接口，同时也继承图形类，这个就是接口的必要性。Java中不允许出现多重继承，但使用接口就可以实现多重继承。一个类可以同时实现多个接口，因此可以将所有需要继承的接口放置在implement关键字后并使用逗号隔开。实现多个接口的语法如下：class 类名 implement 接口1，接口2，····，接口n

但这可能会在一个类中产生庞大的代码量，因为继承一个接口时需要实现接口中所有的方法。一个接口可以继承另一个接口，语法如下： interface intf1{}interface intf2 extendsintf1{}  //接口继承接口

接口

多态抽象类与接口

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

Java中每个接口或类都来自不同的类名，无论是Java API中的类与接口还是自定义的类与接口，都需要隶属于某一个类包

类名冲突

一个程序中同时使用到java.util.Date类与java.sqlDate类，如果在程序中不指定完整的类路径，编译器不会知道这段代码使用的是java.util类包中的Date类还是java.sql类包中的Date类，例如：java.util.Date date = new java.util.Date();java.sql.Date.date2 = new java.sql.Date(1000);

完整的类路径

在项目的src节点上右击，选择“新建”/“包”命令（英文new/Package）

弹出“新建Java包”（New Java Package）对话框，在“名称”（name）文本框中输入新建的包名，然后单击完成（Finish）

在Eclipse中创建类时，可以在新建立的包上右击，选择“新建（New）”命令，这样新建的类会保存在该包中，另外也可以在New JavaClass对话框中指定新建类所在的包

语法：package 包名Java包的命名规则是全部使用小写字母

创建包

语法：import com.mr.*;         //导入com.mr包中所有的类import com.mr.Math  //导入com.mr包中的Math类

使用import关键字导入包

语法：import static 静态成员

使用import导入静态成员

导入包

Java类包

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

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

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

成员内部类

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

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

匿名内部类

内部类

包和内部类

在程序中，异常可能由程序员没有预料到的各种情况产生，也可能由超过了程序员可控范围的环境因素产生，如用户的坏数据、试图打开一个根本不存在的文件等

异常概述

异常抛出后，如果不做任何处理，程序就会被终止，例如，将一个字符串类型转换为整型，可以通过Integer类的parseInt()方法来实现

抛出异常

try{      //程序代码块}catch（Exceptionytpe1 e){      //对Exceptionytpe1 的处理}catch（Exceptionytpe2 e){      //对Exceptionytpe2 的处理}...finally{       //程序代码块}

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

try-catch语句块

以下四种情况下，finally块不会被执行：在finally语句块中发生了异常在前面的代码中使用了System.exit（）退出程序。程序所在的线程死亡关闭CPU

finally语句块

捕捉异常

异常的抛出与捕捉

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

Java常见的异常类

public class MyException extends Exception{      //创建自定义异常，继承Exception类    public MyException (String ErrorMessage){    //构造方法        super(ErrorMessage);                     //父类构造方法    }]

在方法中通过throw关键字抛出异常对象

自定义异常

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

throws关键字

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

throw关键字

在方法中抛出异常

RuntimeExcption异常是程序运行过程中抛出的异类，Java类库的每个包中定义了异常类，所有这些类都是Throwable类的子类，Throwable类派产生了两份个子类，分别是Excepion类和Error类

RuntimeException异常的种类

运行时异常

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

异常的使用原则

异常处理

第一种方法

第二种方法

字符串必须包含在一对双引号（“”）之内，例如：\"23.23\"、\"ABCD\"、\"你好\"以上这些都是字符串常量，字符串常量可以是系统能够显示的任何文字信息，甚至可以是单个字符。 String:指定该变量为字符串类型。str:任意有效的标识符，表示字符串变量的名称。声明字符串变量s，代码如下 ：String s;

声明字符串

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

创建字符串

String类

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

连接多个字符串

System.out.println(\"我每天花费\"+booktime+\"小时看书;\"+(practice+booktime)+\"小时上机练习\");

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

连接其他数据类型

连接字符串

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

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

获取字符串长度

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

1.indexOf(String s)

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

lastIndexOf(String str)

字符串查找

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

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

获取字符串信息

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

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

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

获取子字符串

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

去除空格

字符串替换

stsrtsWith()方法与endsWith()方法分别于判断是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。1.stsrtsWith()方法该方法用于判断当前字符串对象的前缀是否为参数指定的字符串语法:str.endWith(String suffix)     //suffix是指作为后缀的字符串

判断字符串的开始与结尾

对字符串对象进行比较不能简单地使用比较运算符“==”代码：String tom =new String(\"I am a student\"); String jerry = new String(\"I am a student\

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

1.equals()方法

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

2.equalslgnoreCase()方法

判断字符串是否相等

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

按字典比较两个字符串

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

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

1.toLowerCase（)方法

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

2. toUpperCase（)方法

字母大小写转换

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

1.split(String sign)

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

2.split(String sign，int limit)

字符串分割

字符串操作

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

Date data = new Date();      //创建Date对象dateString s = String.formate(\"%te\

日期和时间字符串格式化

常规类型字符串

格式化字符串

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

注意：在正则表达式中，“.”代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转移字符“\\\".在正则表达式中，可以使用方括号括起若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。方括号元字符还可以为其他格式，如：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类，大大提高了频繁增加字符串的效率

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

字符串生成器

字符串

Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段

Integer类

Double类

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

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

Boolean类

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

Character类

Number类

包装类

在Java中没有格式化的数据遵循一下原则：1.如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。2.如果数据绝对值小于0.001或者大于10000000，是用科学计数法表示。DecimalFormat中的特殊字符及其所代表的含义如下

数字格式化

Math类提供了众多数学函数方法，这些方法都被定义为static形式形式调用如下：Math.数学方法在Math类中，除了函数方法外还存在一些常用数学常量，如PI、E。形式调用如下：Math.PI Math.E

Math类中包含的三角函数方法如下：☑ _ public static 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.三角函数方法

2.指数函数方法

3.取整函数方法

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

Math类

Random对象创建一个随机数生成器语法如下：Random r = new Random;设置随机数生成器的种子 语法如下：Random r = new Random(seedValue); r: Random类对象。seedValue：随机数生成器的种子。在Random类中，提供了获取各种数据类型随机数的方法，下国之伙2今孙田计前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):返回一个概率密度为高斯少士8台晰明向叶进研

Random类

在Biglnteger类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。使用BigInteger类，可以实例化一个BigInteger对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。例如，将2转换为BigInteger类型，可以使用以下语句进行初始化操作：Biglnteger twolnstance =new Biglnteger(\"2\");注意:参数2的双引号不能省略，因为参数是以字符串的形式存在的。

一旦创建了对象实例，就可以调用Biglnteger 类中的一些方法进行运算操作，包括基本的数学。算和位运算以及一些取相反数、取绝对值等操作。下面列举了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 BigIntegerl] divideAndRemainder(BigInteger val):用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。public BigInteger pow(int exponent):进行取参数的exponent次方操作。public BigInteger negate()：取相反数。public Biglnteger shiftLeft(int n)：将数字左移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)：当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。public BigInteger min(BigInteger val)：返回较小的数值。public BigInteger max(Biglnteger val)：返回较大的数值。

BigInteger类

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

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

BigDecimal类中divide（）方法有多种设置，用于但会商小数点后的末尾的处理，名称和含义如下：

BigDecimal类

数字处理

例如，使用Date类的第2种构造方法创建一个Date类的对象，代码如下：long timeMillis = System.currentTimeMillis();    //当前系统时间所经历的毫秒数Date date =new Date(timeMillis); Date类的常用方法及其说明如下：

Date类

日期时间格式化

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

Calendar 提供了一个类方法 getnstance()，以获得此类型的一个通用的对象。Calendar类的grtnstance()方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下：Calendar rightNow =Calendar.getlnstance();说明：由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance0方法创建其对象，如果需要创建其对象，必须使用其子类，如GregorianCalendar类。Calendar类提供的常用字段及其说明如下：

Calendar类

时间日期处理

本地命令指的是操作系统的命令。例如，在Linux系统下就表示shell命令，在Windows系统下就表示cmd命令。Rutime类提供exec()方法让Java代码可以执行系统的命令，exec)方法有很多重载的形式，例如：Process exec(String command)Process exec(String， cmdarray)command：要执行的系统命令，字符串类型。cmdarray：要执行的命令和相应的命令参数，字符串数组类型。其实这两个重载方式很类似，如执行“javac hellojava”这行命令，使用第一种重载方式的代码如下：Runtime.getRuntime().exec(\"javac hello.java\");使用第二种重载方式的代码如下：String command，=(\"javac\

执行本地命令

注意：freeMemory()方法得到的剩余内存量是近似值。

查看内存

Runtime类

System类是JDK中提供的系统类，该类是用final修饰的，所以不允许被继承。Svstem类提供服多系线层面的操作方法，并且这些方法全部都是静态的。System类提供的较常用方法如下： 11.3.1 控制台输出字符1.不会自动换行的print()方法printO方法的语法如下：System.out.print(\"Hello!\");此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。2. 可以自动换行的 println()方法printlnO方法在print后面加上了“1n”后缀(就是line的简写)，语法如下：System.out.println(”书籍是人类进步的阶梯！”)；此方法输出“书籍是人类进步的阶梯！”后会自动换行。光标停留在下一行的开头。print()方法与println()方法输出的对比效果如下： 综上所述，Java输出换行的方法有以下两种：System.out.print(\"\\"); //利用换行符\ 实现奂行System.out.println(); //空参数即可实现换行误区警示：使用这两个输出方法时还要注意以下两点：(1)“System.out.println(\"n\")；”会打印两个空行。(2)“System.out.print);”无参数会报错。

输出

计时

System类

Scanner类首先要引入该类，语法如下：import java.util.Scanner;     //引入Scanner类

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

输入

Scanner类

常用类库

集合类

Java从入门到精通