首页  思维导图  详情

Java从入门到精通

2023-06-10 00:30:35   0  举报





AI智能生成

Java总结

总结图

作者其他创作

大纲/内容

初识Java

Java简介

子主题

Java语言的特性

搭建Java环境

熟悉Eclipse开发工具

熟悉Eclipse

下载Eclipse

打开浏览器下载：Eclipse Downloads | The Eclipse Foundation

找到下载好的文件进行解压

子主题

使用Eclipse

程序调试

Java语言基础

Java主类结构

Java语言是面向对象的程序设计语言，Java程序的基本组成单元是类，类体中又包括属性与方法两部分每一个应用程序都必须包含一个main（）方法，含有main（）方法的类称为主类。

        创建主类并调用其主方法

        在Eclipse下依次创建项目item、包Number和类Frist。在类体中输入以下代码，实现在控制台上输出“你好 Java”。

public class Frisit {
    static String s1 = "你好";
public static void main(String[] args) {
  // TODO Auto-generated method stub
        String s2 = "Java";
        System.out.println(s1);
        System.out.println(s2);
}

}

基本数据类型

在Java中有8种基本类型来存储数值、字符和布尔值，分为：数据型，字符型，布尔型。数据型又分为整数类型和浮点类型

整数类型：byte、short、int、long

浮点类型：float、double

整数类型

整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正数，也可以是负数。整型数据根据它所占内存大小的不同，可分为byte、short、int和long4种类型。它们具有不同的取值范围。long型需要在整数后面加L或者l(小写L)；float型则需要在小数后面添加F或f

浮点类型

浮点类型简称浮点型，用来存储含有小数部分的数值。Java语言中浮点类型分为单精度浮点型类（float）和双精度浮点类型（double），它们具有不同的取值范围。

字符类型

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

查看字符与Unicode码互转的结果

布尔类型

布尔类型只有true和false两个值，分别代表布尔逻辑中的“真” 和“假”，用作判断条件，给boolean型变量赋初值赋小写true或false,不会报错，但是如果用大写如TRUE或FALSE就会报错,那么可以在大写的前面加第一个字母为大写的Boolean,则不会报错，大写的Boolean和小写boolean的包装类。

变量与常量

其值能被改变的量称为变量。变量与常量的命名都必须使用合法的标识符。

标识符和关键字

标识符
标识符可以简单的理解为一个名字，是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。标识符由任意顺序的字母、下划线（-）、美元符号（$）、和数字组成。注：不能以数字开头；标识符要避开关键字；变量名中不能有斜杠。

关键字

运算符

赋值运算符

使用赋值运算符同时为两个变量赋值：
public class Eval {

public static void main(String[] args) {
  // TODO Auto-generated method stub
  int a, b, c ;//定义三个int型变量a，b，c
  a =15;//定义三个int型变量a,b,c
  b = a + 4;
  c = b;
  c = b = a + 4;//把变量a与4的和赋值给变量b，然后再赋值给变量c
出现两个等号从右往左运算
  System.out.println("c值为:"+c);//输出变量c的值
  System.out.println("b值为:"+b);//输出变量b的值

}

} 运行结果如下：

算术运算符

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

自增和自减运算符

++a：先运算后使用
a++：先使用后计算

比较运算符

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

逻辑运算符

&&、&：与

&&：两者都为真，结果就为真

true&&true==true true&&false==false false&&false==false

||：或

||：只要有一者为真，结果就是真

true||true==true true||false==true false||false==false

！：非

| ：非真即假非假即真

|true==false |false==true

使用不同的比较运算符判断两个整数的关系：代码如下：

public class Calculation {

public static void main(String[] args) {
  // TODO Auto-generated method stub
  int boys = 15;//男生人数
  int girls = 17;//女生人数
  int totle = boys + girls;//总人数
  boolean result1 = ((boys > girls)&&(totle>30));//男生人数多于女生，且总人数大于30
  boolean result2 = ((boys > girls)||(totle>30));//男生人数多于女生，或总人数大于30
  System.out.println("男生人数大于女生人数并且人数大于30人："+result1);//结果输出
  System.out.println("男生人数大于女生人数或者人数大于30人："+result2);

}

}

运行结果如下

位运算符

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

&(按位与)：

>>>两者都为1，结果才是1

|（按位或）：

0变1,1变0

^（按位异域）：

两者相同即为0，不同则为1

~（按位取反）：

0变1,1变0

移位操作

<<,左移：

整体左移空位补0，溢出去掉

>>,右移：

整体右移，正数补0，负数补1，溢出去掉

>>>，无符号右移：

整体右移，空位补0，负数补1，溢出去掉

三元运算符

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

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

三元运算符等价于if...else语句

运算符优先级

优先级由高到低的顺序依次是:

增量和减量运算。
算术运算。
比较运算。
逻辑运算
赋值运算。

数据类型转换

隐式类型转换

从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这些类型按精度从低到高排列的顺序为byte<short<int<long<float<double。
隐式转换也要遵循一定的规则，在什么情况下将那种类型转换成另一种类型的数据。表3.10列出了各种数据类型隐式转换的一般规则。

显式类型转换

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

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

语法如下：

（类型名）要转换的值

流程控制

复合语句

条件语句

循环语句

while循环语句

do...while循环语句

for循环语句

循环控制

break语句

continue语句

数组

一维数组

二维数组

数组的基本操作

遍历数组

填充替换数组元素

1.fill（int【】a，int value）

例题：
import java.util.Arrays;//导入java.util.Arrays类
public class Swap {//创建类
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[5];//创建int型数组
        Arrays.fill(arr,8);//使用同一个值对数组进行填充
        for(int i=0;i<arr.length;i++) {//遍历循环数组中的元素
            System.out.println("第"+i+"个元素是:"+arr[i]);//将数组中的元素依次输出
        }
    }

}

运行结果如下：

2.fill（int【】a，int fromlndex，int tolndex，int value）

对数组进行排序

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

Arrays.sort(object)

例题：import java.util.Arrays;//导入java.util.Arrays类

public class Taxis {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,8};//声明数组
        Arrays.sort(arr);//将数组进行排序
        for(int i=0;i<arr.length;i++) {//循环遍历排序后的数组
            System.out.println(arr[i]);//将排序后数组中的各个元素输出
        }
    }

}

复制数组

1.copyOf（）方法

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

copyOf（arr，int newlength）

复制数组：空位补0，溢出去掉

新数组名=Arrays.copOf(旧数组名，新数组长度)；

例题：import java.util.Arrays;//导入java.util.Arrays类

public class Cope {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12};//定义数组
        int newarr[]=Arrays.copyOf(arr,5);//复制数组arr
        for(int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
            System.out.println(newarr[i]);//将新数组输出
        }
    }

}

运行结果如下：

2.copyOfRange（）方法

复制数组部分元素：前在后不在

新数组名=Arrays.copysOfRange（旧数组名，前索引，后索引）；

例题：import java.util.Arrays;//导入java.util.Arrays类

public class Repeat {//创建类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,84,10};//定义数组
        int newarr[]=Arrays.copyOfRange(arr,0,3);//复制数组
        for (int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
            System.out.println(newarr[i]);//将新数组中的每个元素输出
        }
    }

}

运行结果如下:

查询数组

数组排序算法

冒泡排序

直接选择排序

反转排序

类和对象

面向对象概述

对象

对象是事物存在的实体，现实世界中，随处可见的一种事物就是对象。

静态部分：不能动的部分，被称为“属性”

动态部分: 即对象可执行的动作，称为“行为”

类

类就是同一事物的统称，如果将现实世界中的一事物抽象成对象，类就是这类对象的统称。类是对象的设计图；类是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。

封装

面向对象程序设计具有以下特点：封装性、继承性和多态性。

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

采用封装的思想保证了类内部数据结构的完整性，提高了程序的可维护性。

继承

类与类之间同样具有关系，这种关系被称为关联。两个类之间的关系有很多种，继承是关联中的一种。设计软件时，使用继承思想可以缩短软件开发的周期，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的概率。

继承性主要利用特定对象之间的共同属性。

多态

将父类对象应用与子类的特征就是多态。

提到多态，就不得不太抽象类和接口，因为多态的实现并不依赖与具体类，而是依赖与抽象类和接口。

类

成员变量

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

public class Book{//类
    private String name;//String类型的成员变量
    public String getName() {//name的Getter方法
        return name;
    }
    public void setName(String name) {//name的Setter方法
        this.name=name;//将参数值赋予类中的成员变量
    }
    }

在Java语言中需要使用class关键词来定义类，Book是类的名称。

成员方法

在Java语言中，使用成员方法对应于类对象的行为。定义成员方法的语法格式如下：

权限修饰符  返回值类型  方法名（参数类型  参数名）{

....                     //方法体

return  返回值；

}

权限修饰符

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

局部变量及其有效范围

局部变量

如果在成员方法内定一个变量，那么这个变量被称为局部变量。实际上方法中的形参也可作为一个局部变量。Book类中定义setName（String name）方法，String name这个形参就被看作是局部变量。
局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。

例题：
public class ChangeDemo {
    public static int[] exchange(int[] arr) {
        int tmp =arr[0];//创建局部变量tmp，保存数组第一个元素的值
        arr[0]=arr[1];//第二个元素值赋给第一个元素
        arr[1]=tmp;//第二个元素值改为tmp
        return arr;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]= {17,29};
        System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
        arr=exchange(arr);
        System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
    }

}

运行结果如下：

局部变量的有效范围

this关键字

类的构造方法

静态变量和静态方法

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

静态变量与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等。尽管使用这种方式调用静态成员比较方便，但静态成员同样遵循着public、private和protected修饰符的约束。总结以下使用static关键字要注意的几点：

1、在静态方法中不可使用this关键字。
2、在静态方法中不可以直接调用非静态方法。
3、局部变量不可以使用static关键字声明。
4、主方法必须用static声明。
5、只有内部类可以使用static关键字声明。

类的主方法

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

public static void main(String[] args) {
...... //方法体
}
在主方法的定义中可以看到其具有以下特点：

1、主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。
2、主方法没有返回值。
3、主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数。

运行代码前先要在 Eclipse中设置运行参数，步骤如下：
1、在Eclipse中的Maindem.Java文件上单击鼠标右键，在弹出的快捷菜单中选择“运行方式”/“运行配置”(英文版为Run As/Run Configrations),弹出“运行配置”(Run Configrations)对话框。
2、在“运行配置”对话框中选择“自变量”(Arguments)选择卡，在“项目”(Program arguments)文本框中输入相应的参数，每个参数间按Enter键隔开。
3、单击“运行”按钮，查看控制台运行结果。如果不按照以上步骤操作，直接运行源码，则不会输出任何结果。

对象

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

类的继承

Object类

getClass()方法

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

getClass().getname();

toString()方法

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

equals()方法

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

对象类型的转换

向上转型

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

Animal a = new dog();

向下转型

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

Dog a =(Dog)new Animal();

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

语法如下：

对象名 instanceof 类名

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

第二种使用方法：

对象名 instanceof 接口名

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

方法的重载

final关键词

多态

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

下面代码中的这种将子类对象视为父类对象的做法称为“向上转型”。

例题：class Shape{} //图形类
class Square extends Shape{} //正方形类继承图形类
class Circular extends Shape{} //圆形类继承图形类
public class Demo5 {
public static void draw(Shape s) { //绘制方法
  if(s instanceof Square) { //如果是正方形
   System.out.println("绘制正方形");
  }else if(s instanceof Circular) { //如果是圆形
   System.out.println("绘制圆形");
  }else { // 如果是其他类型
   System.out.println("绘制父类图形");
  }
}
public static void main(String[] args) {
  draw(new Shape());
  draw(new Square());
  draw(new Circular());

}

}

运行结果如下：

抽象类与接口

抽象类

抽象方法：

修饰符 abstract 返回参数方法名（传入参数）；

抽象方法没有方法体

抽象类：有抽象方法的类一定是抽象类

public abstract void methodName();

假设父类是抽象类，子类是普通类，子类继承父类就需要被重写，如果不重写就会报错。

承载这个抽象方法的抽象类必须被继承，抽象类除了被继承没有任何意义。

作用：继承，制定规则。

接口

所有方法都是抽象方法

修饰符 interface 接口名{

}

实现 implements

Java语言每个类可以实现多个接口，可以单继承，多实现。

Java中不允许出现多重继承，但使用接口就可以实现多重继承。一个类可以同时实现对各接口。

修饰符 class 类名 implements 接口1，接口2，...{

}

包和内部类

Java类包

类名冲突

Java中每个接口或类都来自不同的类包，无论JavaAPI中的类与接口还是自定义的类与接口，都需要隶属于某一个类包，这个类包包含了一些类和接口。如果没有包的存在，管理程序中的类名称将是一件非常麻烦的事情。如果程序只由一个类组成，自然不会出现类名重叠的问题，但是随着程序的类的数量增多，难免会出现这一问题。编译器不会允许存在同名的类文件。解决这类问题的办法是将这两个类放置在不同的类包中。

完整的类路径

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

创建包

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

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

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

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

导入包

1.使用import关键字导入包
如果在程序中使用import关键字导入com.mr.Math类

内部包

成员内部类

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

匿名内部类

匿名类是只在创建对象时才会编写类体的一种写法。匿名类的特点是”现用现写“，其语法如下：

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

异常处理

异常概述

在Java中，这种在程序运行时可能出现的一些错误称为异常。异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。

程序运行的结果发生了算数异常
ArithmeticException（根据给出的错误提示可知，发生错误是因为在算数表达式“3/0”中，0作为除数出现）系统不在执行下去，提前结束。这种情况就是所说的异常。

try：try语句块中包含可能出现异常的程序代码

catch：语句块用来获取异常信息

finally：程序代码块

异常的抛出与捕捉

抛出异常

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

捕捉异常

Java语言的异常捕获结构由try、catch和finally3部分组成。其中，try语句存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码块如何退出，都将执行finally语句块。
try{
     //程序代码块
}
catch(Exceptiontype1 e){
     //对Exceptiontype1 的处理
}
catch(Exceptiontype2 e){
     //Exceptiontype2 的处理
}
…
finally{
      //程序代码块
}

通过异常处理器的语法可知，异常处理器大致分为try-catch语句块和finally语句块。

1.try-catch语句块

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

在finally语句块中发生了异常。
在前面的代码中使用了System.exit（）退出程序。
程序所在的线程死亡。
关闭CPU。

Java常见的异常类

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

自定义异常

使用Java内置的异常类可以描述

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

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

字符串ErrorMessage是要输出的错误信息。若想抛出用户自定义的异常对象，要使用throw关键字

自定义异常的抛出和捕捉：

带有int型参数的方法AVG（）

在方法中抛出异常

使用throws关键字抛出异常

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

使用throws关键字将异常抛给上一级，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

使用throw关键字抛出异常

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

运行时异常

Java 中提供了常见的 RuntimeException 异常，这些异常可通过 try-catch 语句捕获

异常的使用原则

Java 异常强制用户去考虑程序的强健性和安全性。异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应的处理。编写代码处理某个方法可能出现的异常时，可遵循以下几条原则:

在当前方法声明中使用try-catch 语句捕获异常。
一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。
如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常。

字符串

String类

连接字符串

连接多个字符串

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

先连接一副对联的上、下联，再分行输出在控制台上。代码如下：

连接其他数据类型

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

统计每天的阅读和上级时间。代码如下：

获取字符串信息

获取字符串长度

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

str.length();

字符串查找

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

1、indexOf(String s)

该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置。

//查找字符串里第一次出现该元素的位置str.indexOf("1")

int indexof=str.indexOf("1");

System.out.println(indexof);

2、lastIndexOf(String str)

该方法用于返回指定字符串最后一次出现的索引位置。当调用String类的lastIndexOf()方法时，或从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。

//查找字符串里最后一次出现该元素的位置str.lastIndexOf

int lastIndexOf=str.lastIndexOf("1");

System.out.println(lastIndexOf);

用两种方式判断字符串的长度

获取指定索引位置的字符

使用charAt()方法可将指定索引处的字符返回。

//获取指定索引号的字符

char charAt=str.charAt(3);

System.out.println(charAt);

字符串操作

获取子字符串

1、substring(int beginIndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如上：
2、substring(int beginIndex,int endIndex)
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如上：

去除空格

rim()方法返回字符串的副本，忽略前导空格和尾部空格，语法如下：
str.trim()
去掉字符串首、尾的空格

字符串替换

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串，语法如下：
str.replace(CharSequence target,CharSequence replacement)
target:要替换的字符或字符串
replacement:用于替换原来字符串的内容
将单词中的字母a替换为字母A

判断字符串的开始与结尾

1、startsWith()方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：
str.startsWith(String prefix)
prefix：作为前缀的字符串
2、endsWith()方法
该方法用于判断当前字符串是否为以给定的字符串结束。语法如下：
str.endsWith(String suffix)
suffix：作为后缀的字符串

判断字符串是否以指定的内容开始或结束

判断字符串是否相等

要比较两个字符串内容是相同相等，应使用equals()方法和equalsIgnoreCase()方法。
1、equals()方法
如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则false。语法如下：
str.equlas(String otherstr)
2、equalsIgnoreCase()方法
使用equlas（）方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍然为boolean类型。语法如下：
str.equalsIgnoreCase(String otherstr)

判断”abc“与”ABC“是否相等

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

compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符串的Unicode值，按照字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。语法如下：
str.compareTo(String otherstr)

判断字母b的位置。代码如下：

字母大小转换

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

字母大小写转换

字符串分割

使用split()方法可以使字符串按指定的分割线字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split（）方法提供了以下两种字符串分割形式。
1、split(String  sign)
该方法可根据给定的分隔符对字符串进行拆分。语法如下：
str.split(String  sign)
2、split(String sign,int limit)
      该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。语法如下：
str.split(String sign,int limit)
sign:分割字符串的分割符，也可以使用正则表达式
limit:限制的分割次数

按要求分割”192.168.0.1“

格式化字符串

使用正则表达式

正则表达式元字符及其意义如图所示:

[^456]:代表4、5、6之外的任何字符。
[a-r]:代表a~r中的任何一个字母。
[a-zA-Z]:可表示任意一个英文字母。
[a-e[g-z]]:代表a~e或g~z 中的任何一个字母(并运算)。
[a-o&&[def]:代表字母 d、e、f (交运算)。
[a-d&&[Nbc]]: 代表字母 a、d(差运算)。

字符串生成器

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

两种操作执行的时间差距很大。在程序中如果需要

1、append()方法

       该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double或者另一个字符串生成器等

append(content)

content:追加到字符串生成器中的内容

2、insert(int offset,args)方法

     该方法用于向字符串生成器中指定位置插入数据内容。通过该方法的不同重载形式，课实现向字符串生成器中插入int、flaot、char和boolean等基本数据类型的数据或其他对象。语法如下：

insert(int offset args)

offset：字符串生成器的位置

args：将插入至字符串生成器的位置

3、delete(int start,int end)

      移除此序列的字符串中的字符。该字符串从指定的start处开始，一直到索引end-1处的字符。如果不存在这种字符，则一直到序列尾部。如果start等于end,则不发生任何更改。语法如下：

delete(int start,int end)

start：将要删除的字符串的起

常用类库

包装类

Integer类

Integer类提供了以下4个常量：

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

Double类

Double类主要提供了以下常量：

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

Boolean类

Boolean 提供了以下3个常量:

TRUE:对应基值 true 的 Boolean 对象。
FALSE:对应基值false的 Boolean 对象。
TYPE:基本类型boolean的Class对象。

Character类

Character 类提供了大量表示特定字符的常量，例如:

CONNECTOR_PUNCTUATION: 返回 byte 型值，表示 Unicode 规范中的常规类别“pe”。
UNASSIGNED: 返回 byte型值，表示 Unicode 规范中的常规类别“Cn”。
TITLECASE_LETTER:返回 byte 型值，表示Unicode 规范中的常规类别“Lt”。

Number类

Number 类的方法分别被其各子类所实现，也就是说，在 Number 类的所有子类中都包含以上这几种方法。

数字处理

数字格式化

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

Math类

Random类

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

在Random类中，提供了获取各种数类机数的方法，下面列举几个常用的方法:

public int nextint():返回一个随机整数。
public int nextInt(int n): 返回大于等于0且小于n 的随机整数。
public long nextLong():返回一个随机长整型值。
public boolean nextBoolean():返回一个随机布尔型值。
public float nextFloat0: 返回一个随机单精度浮点型值。
public double nextDouble():返回一个随机双精度浮点型值。
public double nextGaussian(): 返回一个概率察度为高斯分布的双精度浮点型值。

BigInteger类

将 2 转换为 BigInteger 类型，可以使用以下语句进行初始化操作:

Biginteger twolnstance = new Bigintegor("2")；

Biglnteger类中常用的几种运算方法：

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

BigDecimal类

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

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

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

时间日期处理

Date类

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

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

Date date = new Date(timeMillis);

Date 类的常用方法及其说明如表所示。

日期时间格式化

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括 SHORT、MEDIUM、LONG 和FULL4种:

SHORT:完全为数字，如 12.13.2或3:30pm。
MEDIUM:较长，如 Jan 12,1952。
LONG:更长，如January 12,1952 或3:30:32pm。
FULL:完全指定，如 Tuesday、April 12、1952AD 或3:30:42pm PST。

使用 DateFormat 类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期,首先需要创建 DateFormat 类的一个对象，由于它是抽象类，因此可以使用其静态方getDateInstance()进行创建，语法如下:

DateFormat df = DateFormat.getDatelnstance();

使用 getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，使用getDateTimeInstance()方法可获取日期和时间格式。DateFormat 类的常用方法及其说明如表 11.16 所示:

Calender类

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

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

Calendar rightNow = Calendar.getlnstance();

Calendar 类提供的常用字段及其说明如表所示:

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

Runtime类

执行本地命令

本地命令指的是操作系统的命令。例如，在 Linux 系统下就表示 shell 命令，在 Windows 系统下
表示 cmd 命令。

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

command:要执行的系统命令，字符串类型。
cmdarray:要执行的命令和相应的命令参数，字符串数组类型。

使用第二种重载方式的代码如下:
String command] = {"javac", "hello,java" };
Runtime.getRuntime().exec(command);

查看内存

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

System类

控制台输出字符
System类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3 个静态对象:in、out和err。本书中的代码多次使用了这些对象，最常见的就是out 对象。在控制台输出字符串，输出的方法有两种。

1.不会自动换行的print()方法
print()方法的语法如下：

System.out.print("Hello!");

此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello” 文字末尾，不会自动换行。

2.可以自动换行的println()方法
printin()方法在 print 后面加上了“ln”后缀 (就是 line 的简写)，语法知下:

System.out.println("书籍是人类进步的阶梯!");

此方法输出“书籍是人类进步的阶梯!”后会自动换行。光标停留在下一行的开头。

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

Java 输出换行的方法有以下两种:

System.out.print("\n");//利用换行符\n实现换行

System.out.printIn();//空参数即可实现换行

Scanner类

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

使用Scanner类扫描控制台的代码如下：

Scanner se = new Scanner(System.in);

分支主题