Java从入门到精通

Android应用

金融服务行业的服务器应用程序

Java Web应用程序

软件工具

交易应用程序

J2ME应用

嵌入式空间

大数据技术

高频交易领域

科学应用程序

Java的应用领域

Java的版本

怎么学好Java

JavaAPL文档

Java简介

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等

Java语言的特性

搭建Java环境

初识Java

Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。

eclipse简介

下载Eclipse 

Eclipse的配置与启动

熟悉eclipse

使用eclipse

熟悉eclipse开发工具

Java语言是面向对象的程序设计语言，Java程序的基本组成单元是类，类体中又包括属性和方法两部分。每个应用程序都必须包含一个main()方法，含有main()方法的类称为主类。对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。类：类是一个模板，它描述一类对象的行为和状态。方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定

Java主类结构

基本数据类型

关键字：又称保留字，是Java中已经被赋予特定意义的一些单词，不能被作为标识符来使用。

常量：在程序运行过程中一直不会改变的量，只能被赋值一次。

变量：可以多次赋值，分为局部变量和成员变量，局部变量优先级高于成员变量，就近原则。

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

局部变量：在类的方法体中声明的变量，它只在当前代码块中有效。

变量与常量

赋值运算符：“=”\"=\"：将右方操作数所含的值赋给左方。

算术运算符\"+\"：加\"-\"：减\"*\"：乘\"%\"：取余\"/\"：除

自增和自减运算符：\"++\

比较运算符：\">\

逻辑运算符：\"&&\

位运算符：\"&\

三元运算符：\"? :\"三元运算符的使用格式为：条件式 ？ 值1 ： 值2三元运算符在底层逻辑和if语句是一样的

运算符优先级：从先到后分别是：赋值运算符>逻辑运算符>比较运算符>算术运算符>增量和减量运算

运算符

隐式类型转换（自动类型转换）：从低级类型转向高级类型的转换，系统将自动转换，而且这个过程一定不会丢失数据

数据类型转换

Java语言基础

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

复合语句

if条件语句

Switch多分支语句

条件语句

while循环语句

do..whlie循环语句

for循环语句

循环语句

break语句      跳出本次循环

continue语句         跳过本次循环

循环控制

流程控制

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

数组概述

声明一维数组的两种方式数组元素类型 数组名字【】；数组元素类型【】 数组名字；例：int arr【】；分配内存数组名字=new 数组元素的类型【数组元素的个数】例：arr=new int【5】；声明同时为数组分配类型数组元素的类型 数组名=new 数组元素的类型【数组元素的个数】；例：int month[]=new int[12];

创建一维数组

.length自动输出数组长度

初始化一维数组

结果

使用一维数组

一维数组

声明二维数组数组元素类型 数组名字【】【】；数组元素类型【】【】 数组名字；例：int a[][];分配内存a=new int[2][4];分别为每一组分配内存a=new int[2][];a[0]=new int[2];a[1]=new int[3];声明的同时分配内存int a=new int[2][4]

创建二维数组

初始化二维数组

使用二维数组

二维数组

遍历数组

填充替换数组元素

查询数组

复制数组

数组元素排序Arrays.sort(数组名）

对数组进行排序

数组的基本操作

对比相邻的元素值，满足条件就交换元素值，小的向前，大的向后

冒泡排序

直接选择最大或最小的值放在最后

直接选择排序

中间不动 两边互换

反转排序

数组排序算法

数组

对象是对事物的实例化，例如 人、鸟、电脑、手机等。这些都可以是看作是一个对象。通常对象会被分为两部分，静态部分与动态部分。静态部分就是一个事物必然拥有的部分，这个部分被称为属性，任何对象就会有属性。而动态部分就是一个事物特有的部分，这个部分被称为行为，行为可以是对象独有的，也可以是都有的。

对象

声明一个类需要通过一个关键字class3、类与对象的关系1）类是对某一类事物的描述，是抽象的、概念上的意义，对象是实际存在的该类事物的每一个个体，也被称为实例。

类

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

继承

多态是同一个行为具有多个不同表现形式或形态的能力。               多态就是同一个接口，使用不同的实例而执行不同操作。

多态

面向对象概述

在Java中，对象的属性就是成员变量的方式存在的。 其实成员变量就是普通的变量，只不过用来表示了类的属性。在创建成员变量时，可以为成员变量设定初始值，如果设定初值的话，会有默认值。如果在创建成员变量时，给定了默认值，那么在本类创建的所有对象，在没有修改这个成员变量的值前，所有对象的成员变量都是这个给定值。

成员变量

在Java中使用成员方法来对应类对象的行为。以上述的Book类为例。它包含了两个成员方法，一个是设置图书的名称，一个是获取图书的名称定义成员方法的格式 权限修饰符 返回值类型 方法名(参数类型 参数名){ //方法体 return 返回值;}成员方法的定义，其实与方法的定义没区别，只不过成员方法是对应着类对象的行为。

成员方法

权限修饰符用于控制外界对类或类中的事物的访问。Java提供了三种权限修饰符，分别是：public、private、protected。这三种权限修饰符控制着外界对被修饰事物的访问。  特别说明，如果类或方法或成员变量前没有加任何权限修饰符，那么就是默认权限default。

权限修饰符

定义在方法内部的变量称为局部变量。局部变量的定义和使用，与普通的变量一致。局部变量在方法被执行时创建，在方法结束时销毁。局部变量在使用前必须进行赋值或者初始化。

局部变量

this关键字只能在本类中使用。this关键字表示对象当前调用者的地址。

this关键字

在类中，除了成员方法之外，还有一类特殊的方法，就是构造方法。构造方法是一种于类同名的方法。在一个类创建对象时，虚拟机会根据形参，自动调用构造方法，来初始化对象。构造方法没有返回值，且构造方法的名称要与本类同名。同时满足这两点才是一个构造方法。无参构造与有参构造 这里的有参与无参，指的是有无形参。

类的构造方法

使用static关键字修饰的方法或者变量称为静态的。被static修饰的变量与方法，地址被放置于静态区内，在类文件执行时，会自动调用这块区域，且只会执行一次。静态方法与变量可以直接使用 类名.静态成员 的方式调用。静态关键字使用注意点在静态方法中不可能使用this关键字静态方法只能调用静态方法，非静态方法调用所有局部变量不可以使用static关键字声明主方法必须使用static声明所有类，只有内部类可以使用static关键字声明

静态变量和静态方法

主方法是类的入口点，它定义了程序从何处开始；主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法的定义中包含的特性：·主方法是静态的，如果要直接在主方法中调用其他方法，则该方法也必须是静态的·主方法没有返回值·主方法的形参我数组，其中args[0]~args[n]分别代表程序的第一参数到第n个参数，可以使用args.length获取整个采纳数的个数。

类的主方法

对象的创建

每个对象都有自己的属性和行为，这些属性和行为在类中体现为成员变量和成员方法，其中成员变量对应对象的属性，成员方法对应对象的行为。 在 Java 中，要引用对象的属性和行为，需要使用点（.）操作符来访问。对象名在圆点左边，而成员变量或成员方法的名称在圆点的右边。语法格式如下：对象名.属性(成员变量) // 访问对象的属性对象名.成员方法名() // 访问对象的方法

访问对象的属性和行为

对象的引用

对象的销毁

类和对象

在Java语言中，一个类继承另一个类需要使用关键字extends，关键字extends的使用方法如下：class Child extends Parent{} 因为Java只支持单继承，所以一个类只能有一个父类。子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。 允许多重继承class A{}class B extends A{}class C extends B{}子类继承父类后，在创建子类对象的同时，会先调用父类的构造方法。

类的继承

Object类是Java中的顶级父类，在Java中所有类都直接或间接的继承与Object类，它是所有类的父类在Object类中有很多Java已经帮我们定义好了的方法，下面就简单介绍几个。toString() 方法toString() 方法的功能是 将一个对象返回为字符串形式，它会返回一个String类型的实例。调用方式类名.toString(); 

equals() 方法在Java中，== 比较符，在比较基本数据类型时，比较的是数据值是否相等。而在比较引用数据时，比较的就是两个引用数据的地址值是否相同了。(使用new操作符创建的都是引用数据类型)注意，在使用equals() 方法比较自行编写的类对象时，那么需要先重写equals方法，因为每个类判相等的规则都是不一样的。而且如果没有重写的话，那么系统会自动调用Object中的equals方法。

object类

向上转型可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果。 对象之间的类型转换在Java编程中还是很常见的。类型转换分为向上转型与向下转型。而向上转型就是将子类对象赋值给父类对象。格式为： 父类 对象名 = (父类) 子类对象;需要注意得是，在进行向上类型转换后，父类对象依旧无法调用子类独有的属性与方法。只能调用从父类中继承下来的属性与方法。需要注意的是，只有具备继承关系得类与类之间才能进行对象类型转换，非继承关系之间不能进行类型转换。 

向上转型

向下类型转换可以理解为将父类类型的对象转换为子类类型的对象。 但是运用向下转型，因为父类大多是较为抽象的类，而子类大多是具体的类， 而将一个较为抽象的类转换为一个较为具体的类，这样的转换通常会出现错误，所以向下转型是不安全的。在进行向下转型时，需要借助强制类型转换。子类类型 子类对象 = (子类类型) 父类对象; 父类对象可以强制类型转换为子类对象，但是有一个前提：这个父类对象要先引用这个子类对象。

向下转型

对象类型的转换

instanceof关键字可以判断是否一个类实现了某个接口，也可以判断一个实例对象是否属于一个类instanceof 的语法格式如下：myobject instanceof ExampleClassmyobject:某类的对象引用ExampleClass:某个类

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

重载方法名不同 参数不同

方法的重载

Final修饰变量———不可改变的量（常量）例题7.10：public class FinalData{    static fina double PI = 3.1415926;     public static void main(String[] args){        System.out.println(\"圆周率的值为：\" + PI);        System.out.println(\"半径为3的圆的周长为：\" + (2 * 3 * PI));        //尝试修改PI的值        PI = 3.1415927;    }}

final变量

public final void test(){...//省略一些程序代码}例题7.11： package seven; public class Dad { public final void turnOnTheTV() {  System.out.println(\"爸爸打开了电视\"); }}class Bady extends Dad{ public final void turnOnTheTV() {  System.out.println(\"宝宝也要打开了电视\"); }}

final方法

final 类名{}

final类

final关键字

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

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体

接口

抽象类

抽象类与接口

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

简单来说，Java类名冲突，就是指package xxx.yyy.zzz下的类名以及import aaa.bbb.ccc.类名之间的冲突。

除此外，还有同一个包下同级出现同名的类以及导入两个类重名时都算类冲突。前者是Java语法基本要求之一，压根就不能这样写

类名冲突

类的定义规定，在同一个类包下面不允许出来同名的类，但是在不同类包下面就允许出现这种情况，相当于将两个同名的类放入了不同的盒子内，避免出现这个问题。如果一个程序内存在多个同名不同包的max类，那么该如何使用指定包的类呢？在使用该类时使用该类的类路径，也成为绝对路径

完整的类路径

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

创建包

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

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

导入包

Java类包

成员内部类定义在一个类成员位置的内部类，称为成员内部类，在成员内部类中可以使用外部类的的任意成员变量与成员方法，即使该外部类成员变量被private所修饰。 package test; public class Demo_4 {    private int num;    static int i=0;        // 内部类     class test{        public void show(){            // 内部类调用外部类的成员变量            System.out.println(num);            System.out.println(i);        }    }}因为private等权限修饰符是针对外界的调用而进行权限判断的，但是成员内部类定义在该类的内部，那么相对于该类的一部分，就像该类的方法也是可以调用被private修饰的成员变量一般，成员内部类属于外部类的成员之一。内部类是依赖于外部类的存在而存在。除非程序中已经有了一个外部类的对象，否则内部类一般不会单独存在。两种方法：对外部类编写get方法，对外提供内部类的对象如果内部类没有被private修饰，那么可以在外界创建一个内部类的对象；外部类与内部类之间也可使用this关键字，如果在内部类中需要使用到外部类的成员变量，那么可以使用外部类.this.变量名的方式使

成员内部类

匿名内部类本质是一个隐藏了名字的内部类。匿名类是只有在创建时才会编写类体的一种写法public class Demo_4{    public static void main(String[] args) {        // 匿名内部类        new Swit(){            @Override            public void swit(){                System.out.println(\"重写了swit方法\");            }        };    }}interface Swit{    public void swit();} 匿名内部类编译后会产生一个以 “外部类名$序号“ 为名称的 .class文件，序号以1-n排列，分别代表1-n个匿名内部类。那么我们可以找到这个.class文件，并对其进行反编译来查看我的结论是否正确。上述反编译的结果可以说明，使用匿名内部类的格式创建的是一个匿名内部类的对象，而大括号内{}的才是匿名内部类的类体。1.匿名内部类的对象如果没有赋值给任何引用变量的话，该对象会在使用后被Java虚拟机自动销毁。2.匿名类不能写构造方法。3.匿名类不能定义静态的成员。那么匿名内部类对象可以赋值给那些引用变量呢？可以被赋值给被继承的接口或者父类对象。形成多态

匿名内部类

内部类

包和内部类

在程序中，可能会因为各种程序员预料不到的异常出现，也可能由超过程序员可控范围的环境因素产生，如用户的坏数据，试图打开一个根本不存在的文件等，在java中，被称为异常，

异常概述

通常，为了保证程序有效的运行，需要对抛出的异常进行相应的处理例题9.2package dibazhang; public class liti9_2 {  public static void main(String[] args) {  //数字格式异常//  try {   String str = \"lili\";   System.out.println(str + \"年龄是:\");   int age = Integer.parseInt(\"20L\");   System.out.println(age);//  }catch(NumberFormatException e){//   System.out.println(\"！！出现数字格式异常！！\");//   System.out.println(\"请联系管理员进行修复\");//  }//  finally {//   System.out.println(\"程序结束\");//  }  } } 结果：

抛出异常

try，catch语句就是用来捕捉和处理异常的语法：try{    //程序代码块}catch（Exception1 e）{     //对Exception1的处理 }catch（Exception2 e）{     //对Exception2的处理}...finally{    //程序代码块}

例题package dibazhang; public class liti9_2 {  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(\"请联系管理员进行修复\");//输出信息  } }}结果：

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

捕捉异常

异常的抛出与捕捉

异常 说明ClassCastException 类型转换异常ClassNotFoundException 未找到相应类异常ArithmeticException 算术异常ArraylndexOutOfBoundsException 数组下标越界异常ArrayStoreException 数组中包含不兼容的值抛出的异常SOLException 操作数据库异常类NullPointerException 空指针异常NoSuchFieldException 字段未找到异常NoSuchMethodException 方法未找到抛出的异常NumberFormatException 字符串转换为数字抛出的异常NegativeArraySizeException 数组元素个数为负数抛出的异常StringlndexOutOfBoundsException 字符串索引超出范围抛出的异常OException 输入输出异常lllegalAccessException 不允许访问某类异常InstantiationException 当应用程序试图使用Class类中的newinstance0方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常EOFException 文件已结束异常FileNotFoundException 文件未找到异常

Java常见的异常类

用户只需要继承Exception类即可自定义异常类，大体可以分为以下几个步骤1.创建自定义异常类2.在方法中通过throw关键字抛出异常对象3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throw关键字指明要抛出给方法调用者的异常，继续进行下一步操作

package dijuizhang; public class MyException extends Exception{//创建自定义异常类，继承Exception类 public MyException(String message) {//构造方法  super(message);  //父类构造方法 }}现在我们创建好自定义异常类了，我们再写一个小程序来使用异常类

自定义异常

例题：package dijuizhang; public class liti9_6 { static void pop() throws NegativeArraySizeException{  //定义方法并抛出NegativeArraySizeException异常  int[] arr = new int[-3];//创建数组 } public static void main(String[] args) {//主方法  try {  //try语句处理异常信息   pop(); //调用pop方法  }catch(NegativeArraySizeException e) {   System.out.print(\"pop()方法抛出的异常\");//输出异常信息  } } }

结果：

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

使用throws关键字抛出异常

例题9.7package jiudanyuan; public class MyException extends Exception{//创建自定义异常类 String message;//定义String类型变量 public MyException(String ErrorMessagr) {//父类方法  message = ErrorMessagr; } public String getMessage() {//覆盖getMessage方法  return message; }}

throw通常用于方法体中，并且抛出一个异常对象，程序在执行到throw语句立刻中断，它后面的语句不会执行

使用throw关键字抛出异常

在方法中抛出异常

RuntimeException异常时程序运行中抛出的异常，java类库的每个包中都定义了异常类所有这些类都是Throwable类的子类，Throwable类派生了两个子类，分别是Exception类和Error类，Error类及其子类用来描述java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重，Exception类称为非致命性类，可以通过捕捉处理来使程序继续执行，Exception类又根据错误发生的原因分为 RuntimeException异常和除 RuntimeException异常之外的异常。

运行时异常

java异常强制用户考虑程序的强健性和安全性，异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应处理，编写代码处理某个方法可能出现异常时，可遵循以下几条原则1.在当前方法声明中使用try-catch语句捕获异常2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或者异常的子类

异常的使用原则

异常处理

str = \"你好\";        str = new String(\"你好\");//10和11行输出结果一致String:指定该变量为字符串类型str:任意有效的标识符，表字符串变量的名称

声明字符串

创建字符串

单个字符串可以使用char类型保存，多个字符串组成的文本就需要保存在string对象中。string通常被称为字符串，一个string对象最多可以保存（2^32-1）个字节（占用4GB空间大小）的文本内容

string类

public class join {//创建类  public static void main(String[] args) {//主方法  // TODO 自动生成的方法存根  String s1 = new String(\"春色绿千里\");//声明String对象s1  String s2 = new String(\"马蹄香万家\");//声明String对象s2  String s = s1 + \"\\

连接多个字符串

public class link {  public static void main(String[] args) {  // TODO 自动生成的方法存根  int booktime = 4;//声明变量int型变量booktime  float practice = 2.5f;//声明的float型变量practice  //将字符串与整型，浮点型相连接，并输出结果  System.out.println(\"我每天花费\"+booktime+\"小时看书;\"+practice+\"小时上机练习\"); } }

连接其他时间类型

连接字符串

获取字符串长度使用string类的length（）方法可获取声明的字符串对象的长度：(str为字符串长度)str.length();获取字符串的长度：String str = \"we are students\";int size = str.length();

获取字符串长度

lastindexOf(String str):该方法用于返回指定字符串最后一次出现的索引位置str.lastindexOf(substr) str：任意字符串对象             sbustr：要搜索的字符串

字符串查找

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

获取指定索引位置的字符

获取字符串信息

ubstring（int beginIndex）【前索引，后索引（前含后不含）】该方法返回是从指定的索引位置开始截取直到该字符串结尾的子串str.substring(int beginIndex)beginIndex:指定从某一索引处开始截取字符串   代码如下：String str = \"hello word\";String substr = str.substring(3);

获取子字符串

public class Black { //创建类  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()

去除空格

public class NewStr { public static void main(String[] args) {  // TODO Auto-generated method stub  String str = \"address\";//定义字符串str  String newstr = str.replace(\"a\

字符串替换

public class StartOrEnd {  public static void main(String[] args) {  // TODO 自动生成的方法存根  String num1 = \"22045612\";  String num2 = \"21304578\";  boolean b = num1.startsWith(\"22\");//判断字符串num1是否以22开始  boolean b2 = num2.endsWith(\"78\");//判断字符串num2是否以78结束  System.out.println(\"字符串num1是以‘22’开始的吗？\"+b);  System.out.println(\"字符串num2是以‘78’结束的吗？\"+b2);//输出信息 } }

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

判断字符串的开始与结尾

对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。

即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串，代码如下：String tom = new String(\"i am a student\");String jerry = new String(\"i am a student\");boolean b = (tom == jerry);        因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsignorecase()方法。

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

equalsIgnoreCase（）方法    忽略了大小写的情况比较两个字符串是否相等，返回结果为Boolean类型。语法如下：str.equalsIgnoreCase（String otherstr）

判断字符串是否相等

public class Wordbook {  public static void main(String[] args) {  // TODO 自动生成的方法存根  String str = new String(\"b\");  String str2 = new String(\"a\");  String str3 = new String(\"c\");  System.out.println(str + \"compareTo\" + str2 + \":\"  + str.compareTo(str2));  System.out.println(str + \"compareTo\" + str3 + \":\"    + str.compareTo(str3)); }}

语法如下： str.compearTo(String otherstr)说明：compareTo（）方法只有在equals（）方法返回turn时才返回0.

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

public class UpAndLower {  public static void main(String[] args) {  // TODO 自动生成的方法存根  String str = new String(\"Oh My God\");//创建字符串str  String newstr = str.toLowerCase();//使用toLower方法实行大小写转换  String newstr2 = str.toUpperCase();//使用toUpper方法实行大小写转换  System.out.println(newstr);//将转换后的结果输出  System.out.println(newstr2); } }

toLowerCase()方法【转换小写】str.toLowerCase() toUpperCase()方法【转换大写】str.toUpperCase()

字母大小写转换

public static void main(String[] args) {  // TODO 自动生成的方法存根  String str = \"192.168.0.1\";  String[] firstArray = str.split(\"\\\\.\");//按照\".\"进行分割，使用转义字符\"\\\\.\"  String[] secondArray = str.split(\"\\\\.\

字符串分割

字符串操作

例题10.13import java.util.Date;public class Eval {  public static void main(String[] args) {  // TODO 自动生成的方法存根  Date date = new Date();//创建Date对象date  String year = String.format(\"%tY\

日期格式化Date date = new Date();String s = String.format(\"%te\

例题10.14import java.util.Date;public class GetDate { public static void main(String[] args) {  // TODO 自动生成的方法存根  Date date =new Date();//创建Date对象date    String hour = String.format(\"%tH\

时间格式化       使用format0方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等格式化时间的转换符

例题10.15import java.util.Date;public class DateAndTime {  public static void main(String[] args) {  // TODO 自动生成的方法存根  Date date = new Date();//创建Date对象date  String time = String.format(\"%tc\

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

日期和时间字符串格式化

例题10.16public class General {  public static void main(String[] args) {  // TODO 自动生成的方法存根String str=String.format(\"%d\

常规类型格式化

格式化字符串

例题10.17public class Judge {  public static void main(String[] args) {  // TODO 自动生成的方法存根  String regex = \

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\\d”表示数字9中的任何一个，“d”就是元字符。在正则表达式中，可以使用方括号括起若千个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。例如，reg =“[abc]4”，这样字符串 a4、b4、4 都是和正则表达式匹配的字符串。方括号元字符还可以为其他格式。如:  [456]:代表4、5、6之外的任何字符 [a-r]: 代表a~r中的任何一个字母。 [a-zA-Z]:可表示任意一个英文字母。 [a-e[g-z]]:代表 a~e 或 g~z 中的任何一个字母(并运算)。[a-o&&[def]]:代表字母 d、e、f (交运算)。[a-d&&[^bc]]: 代表字母 a、d(差运算)。在正则表达式中允许使用限定修饰符来限定元字符出现的次数。例如，“A*”代表 A 可在字符串中出现 0次或多次。

使用正则表达式

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

字符串生成器

字符串

Integer类的常用方法 package lit; public class IntegerDemo {  public static void main(String[] args) {  int num=Integer.parseInt(\"456\");//将字符串转换为int类型  Integer iNum=Integer.valueOf(\"456\");//创建Integer对象  System.out.println(\"int 数据与Integer对象的比较：\

在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段该类方法还提供了多个方法，能够在int和String类型之间互相转换

查看Integer类的常量值 package lit; public class GetCon {  public static void main(String[] args) {  int maxint=Integer.MAX_VALUE;//获取常量值  int minint=Integer.MIN_VALUE;  int intsize=Integer.SIZE;  //输出  System.out.println(\"int类型可取的最大值是：\"+maxint);  System.out.println(\"int类型可取的最小值是：\"+minint);  System.out.println(\"int类型的二进制位数是：\"+intsize);  } }

除了方法Integer类还提供了以下4个常量

Integer类

Double类的常用方法package lit; public class DoubleDemo {  public static void main(String[] args) {  Double dNum=Double.valueOf(\"3.14\");  System.out.println(\"3.14是否为非数字值：\"+Double.isNaN(dNum.doubleValue()));  System.out.println(\"3.14转换为int值值：\"+dNum.intValue());//转换为int型  //判断大小  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类在对象中包装一个基本类型为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 类型的正无穷大值的常量

Double类

Boolean 类的常用方法package lit; public class BooleanDemo {  public static void main(String[] args) {  //创建Boolean对象  Boolean b1=Boolean.valueOf(\"true\");  Boolean b2=Boolean.valueOf(\"ok\");  System.out.println(\"b1:\"+b1.booleanValue());  System.out.println(\"b2:\"+b2.booleanValue());  //只要不是true就全是false } }

Boolean类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。此类还为 boolean 类型和 Sring 类型的相互转换提供了许多方法，并提供了处理 boolean 类型时非常有用的其他一些常量和方法。Boolean类还提供了以下常量:  TRUE:对应基值true的Boolean对象FALSE：对应基值false的Boolean对象TYPE：基值booleand的Class对象

Boolean类

Character类的常用方法 package lit; public class UpperOrLower {  public static void main(String[] args) {  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(mychar1));   }    } }

Character类

对于数值型的包装类，它们有一个共同的父类一Numbr类，该类是一个抽象类，它是 Byte、Integer、Short、 Long、Flat 和 Double 类的父类，其子类必须提供将表示的数值转换为 byte、int、short、long、float 和 double 的方法。在 Number 类的所有子类中都包含以上这儿种方法。

Number类

包装类

数字格式化在解决实际问题时应用非常普遍，如表示超市的商品价格，需要保留两位小数。主要针对的是浮点型数据，包括double和float数据，使用Java.text.DecimalFormatjava中没有数据格式化的数据遵行以下原则如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示DecimalFormat类是NumberFormat 的一个子类， 用于格式化十进制数字。可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat类中的applyPattern()方法来实现数字格式化。SimgleFormat()方法是在实例化 Decimalformat 对象时设置数字格式化模板 UseApplyPatternMethodPormal0)方法是在实例化 DecimalFormat 对象后调用spplype方法设置数宇格式化模板。在 DecimalFormat 类中，除了可通过格式化模板来格式化数字，还可以使用一些特殊方注对数行格式化设置。例如：myFormat2.setGroupingSize(3);//设置几个数进行初始化myFormat2.setGroupingUsed(true);//setGroupingUsed的开关String my2=myFormat2.format(7857478);//传入要格式化的数

数字格式化

在Java代码中进行三角函数运算package lit; public class TrigonometricFunction {  public static void main(String[] args) {    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°的正切  //取2的平方根与2的商的反正弦值  System.out.println(\"2的平方根与2的商的反正弦值：\"+Math.asin(Math.sqrt(2)/2));  //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类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便，使用方法如下：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): 将弧度转换为角度。以上每个方法的参数和返回值都是 double型的。将这些方法的参数的值设置为 double 型是有一定道理的，参数以弧度代替角度实现，角度与弧度的转换通常是不精确的。

在Java中使用指数函数进行运算package lit; public class ExponentFunction {  public static void main(String[] args) {  System.out.println(\"e的平方值：\"+Math.exp(2));//取e的2次方  System.out.println(\"以e为底2的对数值：\"+Math.log(2));//取以e为底2对数  System.out.println(\"以10为底2的对数值：\"+Math.log10(2));//取以10为底2的对数值  System.out.println(\"4的平方根值：\"+Math.sqrt(4));//取平方根  System.out.println(\"8的立方值：\"+Math.cbrt(8));//取8的立方  System.out.println(\"2的2次方值：\

指数函数方法 pbhe static double exp(double a): 用于获取e的a次方，即取publie static double log(double a): 用于取自然对数，即取lna的值。public staric double logl0(double a):用于取底数为10的a的对数public static double sqrt(double a):用于取a的平方根，其中a的值不能为负值public static double cbrt(double a):用于取a的立方根。public static double pow(double a，double b):用于取a的b次方。

各场景下取整函数的运算结果 package lit; public class IntFunction {  public static void main(String[] args) {   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));//返回与参数最接近的整数 //将参数加上0.5后返回最接近的整数   System.out.println(\"使用round()方法取整：\"+Math.round(3.4f)); //将参数加上0.5后返回最接近的整数，并将结果强制转换为长整型   System.out.println(\"使用round()方法取整：\"+Math.round(2.5)); } }

取整函数方法 public static double ceil(double a): 返回大于等于参数的最小整数。 public static double floor(double a): 返回小于等于参数的最大整数。public  static double rint(double a): 返回与参数最接近的整数，如果同样接近，取偶数。public static int round(float a): 将参数加上0.5 后返回与参数最近的整数。public static long round(double a): 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整型。

取最大值、最小值、绝对值的方法package lit; public class AnyFunction {  public static void main(String[] args) {  System.out.println(\"4和8的较大者：\

Math类

获取不同取值范围、不同类型的随机数package lit; import java.util.Random; public class RandomDemo {  public static void main(String[] args) {  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的常用方法 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(): 返回一个概率密度为高斯分布的双精度浮点型值。

Random 类是JDK 中的随机数生成器类可以通过实例化一个 Random 对象创建一个随机数生成器，语法如下：Random r=new Random();因为每时每刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两个运行结果相同的随机数。可以在实例化 Random 类对象时，设置随机数生成器的种子，语法如下:Random r = new Random(seedValue);

Random类

使用 BigInteger 类进行数学运算package lit; import java.math.BigInteger; public class BigIntgerDemo {  public static void main(String[] args) {  BigInteger b1=new BigInteger(\"987654321987654321\");//第1个大数字  BigInteger b2=new BigInteger(\"123456789123456789\");//第2个大数字  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]);//取余数  System.out.println(\"做2次方操作：\"+b1.pow(2));//取2次方运算  System.out.println(\"取相反数操作：\"+b1.negate());//相反数运算    } }

BigInteger类中常用的几种运算方法: 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(Biglnteger val): 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。public BigInteger pow(int exponent): 进行取参数的exponent 次方操作。public BigInteger negate(): 取相反数。public BigInteger shiftLef(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(BigInteger val): 返回较大的数值。

Integer 类是 int 的包装类int 的最大值为2的31次方减1，如果要计算更大的数字，使用 Integer 类就无法实现了所以 Java 中提供了BigInteger 类来处理更大的数字使用 BigInteger 类，可以实例化一BigInteger对象，并自动调用相应的构造函数例如，将2转换为 Biglnteger 类型，可以使用以下语句进行初始化操作:BigInteger twolnstance = new Biginteger(\"2\")

Biginteger类

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

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

divide()方法的多种处理模式

BigDecimal类

数字处理

System 类是 JDK 中提供的系统类，该类是用 final 修饰的，所以不允许被继。System 类提供的方法全部都是静态的                                                                                                                                                                                控制台输出字符System 类提供了标准输入in、标准输出out和错误输出流err不会自动换行的 print()方法System.out.print();可以自动换行的 println()方法 println()方法在 print后面加上了“In”后缀 (就是 line 的简写)System.out.println();Java 输出换行的方法有以下两种:System.out.print(\"\\");                //利用换行符n 实现换行System.out.println();                  //空参数即可实现换行

控制台输出字符

查看执行一万次字符串拼接所消耗的时间package lit; public class SystemTimeDemo {  public static void main(String[] args) {  long start=System.currentTimeMillis();//获取程序开始的时间  String str=null;  for(int i=0;i<10000;i++) {//循环次数   str+=i;     }  long end=System.currentTimeMillis();//获取程序结束时间  System.out.println(\"循环用时：\"+(end-start)+\"毫秒\");//输出 } }

Sywem.curemTimeMillis()方法可以获取现在的毫秒数。虽然 Date 日期也有类似的方法，但代码会比 Systcm 类多，所以 System.currentTimeMillis()方法是为获取当前毫秒最常用的方法。该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。

计时

system类

猜数字游戏package lit; import java.util.Random;import java.util.Scanner; public class ScannerDemo { public static void main(String[] args) {  Random r=new Random();//随机数对象  int num=r.nextInt(100);//1~99  int input=0;//记录用户输入的值  Scanner sc=new Scanner(System.in);//打开扫描器  while(true) {   System.out.println(\"猜一猜随机数是多少?\");   input=sc.nextInt();   if(input>num) {    System.out.println(\"你输入的数字大了\");   }else if(input<num) {    System.out.println(\"你输入的数字小了\");   }else if (input==num) {//如果等于随机数，结束循环    break;       }else {    System.out.println(\"你的输入有误！\");   }  }  System.out.println(\"恭喜你答对了！\");  sc.close();//关闭扫描器，不然很占内存 } }

nextLine()方法扫描的内容是从第一个字符开始到换行符为止而 next()、nextInt()等方法扫描的内容是从第一个字符开始到这段完整内容结束。使用 Scanner 类扫描控制台的代码如下:Scanner sc = new Scanner(System.in);System.in 表示控制台输入流，

Scanner 类提供的几种常用的方法

Java 从控制台中读出用户输入的值，用到的是一个叫 Scanner 的类来实现的。Scanner 英文直译就是扫描仪，它的用途就是数字化信息流转为人类可识别的文字。System.out 就表示向控制台输出System.in 就表示从控制台输入让 Sanner 扫描 System.in 就可以获取用户输入的值了使用 Scanner 类首先要引入该类，语法如下：import java.util.Scanner； 

scanner类

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

创建 Date 对象时使用的是 long 型整数，而不是 double 型，因为 double 类型可能会损失精度

获取当前的日期和时间package lit; import java.util.Date; public class DateDemo {  public static void main(String[] args) {  Date date=new Date();//创建现在的日期  long value=date.getTime();//获取毫秒数  System.out.println(\"日期：\"+date);  System.out.println(\"到现在所经历的毫秒数为：\"+value); } }

Date类

使用getDateTimeInstance()方法可获取日期和时间格式。

SimpleDateFormat的格式化字符

日期时间格式化

Calendar 类提供的常用方法

Calendar类

日期时间类

package lit; import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;public class RuntimeExecDemo {  public static void main(String[] args) {  Runtime r=Runtime.getRuntime();//获取本地Runtime对象  try {   Process p=r.exec(\"help\");//执行help命令，获取进程对象   InputStream is=p.getInputStream();//获取进程的字节输入流   BufferedReader br=new BufferedReader(new InputStreamReader(is));   String str=null;//创建空字符   while((str=br.readLine())!=null) {//如果字符流中可以获取非空内容    System.out.println(str);//打印   }    }catch(IOException e) {   e.printStackTrace();  }  }}

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

执行本地命令

监控虚拟机内存的使用情况package lit; public class MemoryDemo {  public static void main(String[] args) {     Runtime r=Runtime.getRuntime();//获取本地Runtime对象    Integer ints[]=new Integer[10000];//创建长度为10000的整型数组    long before=r.freeMemory();//获取当前空闲内存数    System.out.println(\"赋值前空闲内存字节数：\

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

查看内存

Runtime 类是 JDK 供的运行时类，该类为 Java程序提供了与当前运行环境相连接的一个通道，Runtime 类不能使用 new 关键字创建实例，只能通过 Runtime. getRuntime()方法获取实例。Runtime 类的常用方法public static Runtime getRuntime()  普通方法  用于取得Runtime类的实例public long freeMemory()  普通方法 用于返回Java虚拟机中的空闲内存public long maxMemory() 返回JVM的最大内存量public void gc() 运行垃圾回收器。释放空间。public Process exec(String command) throws IOException 执行本机命令

Runtime类

常用类库

Java从入门到精通